A function declaration introduces anidentifier that designates a function and, optionally, specifies the types of the function parameters (theprototype). Function declarations (unlikedefinitions) may appear at block scope as well as file scope.

[edit]Syntax

In thedeclaration grammar of a function declaration, thetype-specifier sequence, possibly modified by the declarator, designates thereturn type (which may be any type other than array or function type), and thedeclarator has one ofthree(until C23)two(since C23) forms:

where

int max(int a,int b);// declarationint 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)

[edit]Explanation

The return type of the function, determined by the type specifier inspecifiers-and-qualifiers and possibly modified by thedeclarator as usual indeclarations, must be a non-array object type or the typevoid. If the function declaration is not a definition, the return type can beincomplete. The return type cannot be cvr-qualified: any qualified return type is adjusted to its unqualified version for the purpose of constructing the function type.

void f(char*s);// return type is voidint sum(int a,int b);// return type of sum is int.int(*foo(constvoid*p))[3];// return type is pointer to array of 3 int doubleconst bar(void);// declares function of type double(void)double(*barp)(void)= bar;// OK: barp is a pointer to double(void)doubleconst(*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 objectsinlineint g(int), n;// Error: inline qualifier is for functions onlytypedefint 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 hasfile scope andexternal linkage, unlessstatic is used or an earlier static declaration is visible. If the declaration occurs inside another function, the identifier has block scope (and also either internal or external linkage).

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 declarationthat is not part of afunction definition(until C23) do not need to be named:

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 aparameter-list is adeclaration 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);// OKint 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 onlystorage class specifier allowed for parameters isregister, and it is ignored in function declarations that are not definitions

int f(staticint x);// Errorint f(int[static10]);// 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(constint[10]);// declares int g(const int*)int h(int[constvolatile]);// 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), seevariadic functions for details.

int f(int, ...);

• parameters cannot have typevoid (but can have type pointer to void). The special parameter list that consists entirely of the keywordvoid is used to declare functions that take no parameters.

int f(void);// OKint 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) is parsed as a new-style declarator for a function taking two unnamed parameters of typesize_t anduintptr_t, not an old-style declarator that begins the definition of a function taking two parameters named "size_t" and "uintptr_t".
• parameters may have incomplete type and may use the VLA notation[*](since C99) (except that in afunction definition, the parameter types after array-to-pointer and function-to-pointer adjustment must be complete).

Seefunction call operator for other details on the mechanics of a function call andreturn for returning from functions.

[edit]Notes

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

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

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

*f(){// function returning int*returnNULL;}

[edit]Defect reports

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

[edit]References

[edit]See also

• In other languages

• العربية
• Česky
• Deutsch
• Español
• Français
• Italiano
• 日本語
• 한국어
• Polski
• Português
• Русский
• Türkçe
• 中文