Function declarations

A function declaration introduces an identifier that designates a function and, optionally, specifies the types of the function parameters (the prototype). Function declarations (unlike definitions

Syntax

In the declaration grammar of a function declaration, the type-specifier sequence, possibly modified by the declarator, designates the return type (which may be any type other than array or function type), and the declarator

where

int max(int a, int b); // declaration
int n = max(12.01, 3.14); // OK, conversion from double to int

int max(a, b) 
    int a, b; // definition expects ints; the second call is undefined
{
    return a > b ? a : b;
}
 
int n = max(true, (char)'a'); // calls max with two int args (after promotions)
 
int n = max(12.01f, 3.14); // calls max with two double args (after promotions)

Explanation

The return type of the function, determined by the type specifier in specifiers-and-qualifiers and possibly modified by the declarator as usual in declarations, must be a non-array object type or the type void. If the function declaration is not a definition, the return type can be incomplete

void f(char *s);                    // return type is void
int sum(int a, int b);              // return type of sum is int.
int (*foo(const void *p))[3];       // return type is pointer to array of 3 int
 
double const bar(void);             // declares function of type double(void)
double (*barp)(void) = bar;         // OK: barp is a pointer to double(void)
double const (*barpc)(void) = barp; // OK: barpc is also a pointer to double(void)

Function declarators can be combined with other declarators as long as they can share their type specifiers and qualifiers

int f(void), *fip(), (*pfi)(), *ap[3]; // declares two functions and two objects
inline int g(int), n; // Error: inline qualifier is for functions only
typedef int array_t[3];
array_t a, h(); // Error: array type cannot be a return type for a function

If a function declaration appears outside of any function, the identifier it introduces has file scope and external linkage, unless static

int main(void)
{
    int f(int); // external linkage, block scope
    f(1); // definition needs to be available somewhere in the program
}

The parameters in a declaration that is not part of a function definition (until C23)

int f(int, int); // declaration
// int f(int, int) { return 7; } // Error: parameters must be named in definitions
// This definition is allowed since C23

Each parameter in a parameter-list is a declaration that introduced a single variable, with the following additional properties:

• the identifier in the declarator is optional (except if this function declaration is part of a function definition)(until C23)

int f(int, double); // OK
int g(int a, double b); // also OK
// int f(int, double) { return 1; } // Error: definition must name parameters
// This definition is allowed since C23

• the only storage class specifier allowed for parameters is register, and it is ignored in function declarations that are not definitions

int f(static int x); // Error
int f(int [static 10]); // OK (array index static is not a storage class specifier)

• any parameter of array type is adjusted to the corresponding pointer type, which may be qualified if there are qualifiers between the square brackets of the array declarator(since C99)

int f(int[]); // declares int f(int*)
int g(const int[10]); // declares int g(const int*)
int h(int[const volatile]); // declares int h(int * const volatile)
int x(int[*]); // declares int x(int*)

• any parameter of function type is adjusted to the corresponding pointer type

int f(char g(double)); // declares int f(char (*g)(double))
int h(int(void)); // declares int h(int (*)(void))

• the parameter list may terminate with , ... or be ...(since C23), see variadic functions

int f(int, ...);

• parameters cannot have type void (but can have type pointer to void). The special parameter list that consists entirely of the keyword void

int f(void); // OK
int g(void x); // Error

• any identifier that appears in a parameter list that could be treated as a typedef name or as a parameter name is treated as a typedef name: int f( size_t, uintptr_t )
• parameters may have incomplete typeand may use the VLA notation [*](since C99) (except that in a function definition

See function call operator for other details on the mechanics of a function call and return

Notes

int f(void); // declaration: takes no parameters
int g(); // declaration: takes unknown parameters
 
int main(void) {
    f(1); // compile-time error
    g(2); // undefined behavior
}
 
int f(void) { return 1; } // actual definition
int g(a,b,c,d) int a,b,c,d; { return 2; } // actual definition

Unlike in a function definition, the parameter list may be inherited from a typedef

typedef int p(int q, int r); // p is a function type int(int, int)
p f; // declares int f(int, int)

*f() { // function returning int*
   return NULL;
}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C standards.

References