Function prototype

In computer programming, a function prototype or function interface is a declaration of a function that specifies the function's name and type signature (arity, data types of parameters, and return type), but omits the function body. While a function definition specifies how the function does what it does (the "implementation"), a function prototype merely specifies its interface, i.e. what data types go in and come out of it. The term function prototype is particularly used in the context of the programming languages C and C++ where placing forward declarations of functions in header files allows for splitting a program into translation units, i.e. into parts that a compiler can separately translate into object files, to be combined by a linker into an executable or a library.

In a prototype, parameter names are optional (and in C/C++ have function prototype scope, meaning their scope ends 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 parameter).

In object-oriented programming, interfaces and abstract methods serve much the same purpose.

Example

Consider the following function prototypes:

double myfunction(int n);

This prototype specifies that in this program, there is a function named "myfunction" which takes a single integer argument "n" and returns a double. 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 any arguments. The following is an argument-less function declaration, which just declares the function name and its return type, but doesn't tell what parameter types the definition expects.

double myfunction();

Uses

In earlier versions of C, if a function is not previously declared and its name occurred in an expression followed by a left parenthesis, it is implicitly declared as a function that returns an int and nothing was assumed about its arguments. In this case the compiler will not be able to perform compile-time checking of argument types and Syntax 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 myfunction(int n);              /* Prototype */
 
 int main(void) {             /* Calling function */
     printf("%d\n", myfunction());   /* Error: forgot argument to myfunction */
     return 0;
 }
 
 int myfunction(int n) {             /* Called function definition */
     if (n == 0) 
         return 1;
     else 
         return n * myfunction(n - 1);
 }

The function myfunction 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 myfunction 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 myfunction takes one integer argument and you enable the compiler to catch these kinds of errors and make the compilation process run smoothly. This feature was removed from the C99 standard, thus omission of a function prototype will result in a compile error.

Creating library interfaces

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

Class declaration

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

See also

• Modular programming
• Protocol (object-oriented programming)
• Abstract method

References