Function prototype

From Wikipedia, the free encyclopedia
Jump to: navigation, search

A function prototype or function interface in C, Perl, PHP or C++ is a declaration of a function that omits the function body but does specify the function's return type, name, arity and argument types. While a function definition specifies what a function does, a function prototype can be thought of as specifying its interface.

In a prototype, argument names are optional (and have function prototype scope, meaning they go out of scope at the end of the prototype), however, the type is necessary along with all modifiers (e.g. if it is a pointer or a const argument).


Consider the following function prototype:

int fac(int n);

This prototype specifies that in this program, there is a function named "fac" which takes a single integer argument "n" and returns an integer. Elsewhere in the program a function definition must be provided if one wishes to use this function. It's important to be aware that a declaration of a function does not need to include a prototype. The following is a prototype-less function declaration, which just declares the function name and its return type, but doesn't tell what parameter types the definition expects.

double fac();


In C, if a function is not previously declared and its name occurs in an expression followed by a left parenthesis, it is implicitly declared as a function that returns an int and nothing is assumed about its arguments. In this case the compiler will not be able to perform compile-time checking of argument types and arity when the function is applied to some arguments. This can cause problems. The following code illustrates a situation in which the behavior of an implicitly declared function is undefined.

 #include <stdio.h>
 /* If this prototype is provided, the compiler will catch the error in
  * int main(). If it is omitted, then the error may go unnoticed.
 int fac(int n);              /* Prototype (Prototype is the function declaration in which function name, parameters and return type is including)*/
 int main(void) {             /* Calling function */
     printf("%d\n", fac());   /* Error: forgot argument to fac */
     return 0;
 int fac(int n) {             /* Called function definition */
     if (n == 0) 
         return 1;
         return n * fac(n - 1);

The function fac expects an integer argument to be on the stack or in a register when it is called. If the prototype is omitted, the compiler will have no way of enforcing this and fac will end up operating on some other datum on the stack (possibly a return address or the value of a variable that is currently not in scope). By including the function prototype, you inform the compiler that the function fac takes one integer argument and you enable the compiler to catch these kinds of errors and make the compilation process run smoothly. Please also note that implicit function declarations are removed from the C99 standard, thus omission of at least function prototype will result in compile error.

Creating library interfaces[edit]

By placing function prototypes in a header file, one can specify an interface for a library.

Class declaration[edit]

In C++, function prototypes are also used in class definitions.

See also[edit]