The following compiles:
static int foo() { return 1; }
int foo();
But, will it always compile? Is the behavior in this case well defined? And what does it means when a non-static prototype follows a static declaration?
The following compiles:
static int foo() { return 1; }
int foo();
But, will it always compile? Is the behavior in this case well defined? And what does it means when a non-static prototype follows a static declaration?
Yes it will compile and behavior is well defined. Since foo
is declared static
earlier than int foo();
1, foo
has internal linkage.
For an identifier declared with the storage-class specifier
extern
in a scope in which a prior declaration of that identifier is visible,31) if the prior declaration specifies internal or external linkage, the linkage of the identifier at the later declaration is the same as the linkage specified at the prior declaration. [...]
and the foot note states that:
31) As specified in 6.2.1, the later declaration might hide the prior declaration.
1. If no storage class is specified , the function is assumed to have external linkage. Standard says: If the declaration of an identifier for a function has no storage-class specifier, its linkage
is determined exactly as if it were declared with the storage-class specifier extern
-- 6.2.2 (p5).
By default functions are global. So making it
static int foo() { return 1; }
The function foo()
is just visible within this file. Since you just have the declaration int foo();
this is fine and well defined if you have a definition for the same int foo(){ return 2;}
then you will get redefinition error.
As stated by @haccks
6.2.1, the later declaration might hide the prior declaration.
Note the difference between declaration and definition.