Function declarators must be declared with the appropriate type information, including a return type and parameter list. If type information is not properly specified in a function declarator, the compiler cannot properly check function type information. When using standard library calls, the easiest (and preferred) way to obtain function declarators with appropriate type information is to include the appropriate header file.
Attempting to compile a program with a function declarator that does not include the appropriate type information typically generates a warning but does not prevent program compilation. These warnings should be resolved. (See MSC00-C. Compile cleanly at high warning levels.)
Noncompliant Code Example (Non-Prototype-Format Declarators)
This noncompliant code example uses the identifier-list form for parameter declarations:
Subclause 6.11.7 of the C Standard [ISO/IEC 9899:2011] states that "the use of function definitions with separate parameter identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature."
Compliant Solution (Non-Prototype-Format Declarators)
In this compliant solution,
int is the type specifier,
max(int a, int b) is the function declarator, and the block within the curly braces is the function body:
Noncompliant Code Example (Function Prototypes)
Declaring a function without any prototype forces the compiler to assume that the correct number and type of parameters have been supplied to a function. This practice can result in unintended and undefined behavior.
In this noncompliant code example, the definition of
file_a.c expects three parameters but is supplied only two:
However, because there is no prototype for
file_b.c, the compiler assumes that the correct number of arguments has been supplied and uses the next value on the program stack as the missing third argument:
C99 eliminated implicit function declarations from the C language. However, many compilers still allow the compilation of programs containing implicitly declared functions, although they may issue a warning message. These warnings should be resolved. (See MSC00-C. Compile cleanly at high warning levels.)
Compliant Solution (Function Prototypes)
This compliant solution correctly includes the function prototype for
func() in the compilation unit in which it is invoked, and the function invocation has been corrected to pass the right number of arguments:
Noncompliant Code Example (Function Pointers)
If a function pointer refers to an incompatible function, invoking that function via the pointer may corrupt the process stack. As a result, unexpected data may be accessed by the called function.
In this noncompliant code example, the function pointer
fn_ptr refers to the function
add(), which accepts three integer arguments. However,
fn_ptr is specified to accept two integer arguments. Setting
fn_ptr to refer to
add() results in unexpected program behavior. This example also violates EXP37-C. Call functions with the correct number and type of arguments:
Compliant Solution (Function Pointers)
To correct this example, the declaration of
fn_ptr is changed to accept three arguments:
Failing to include type information for function declarators can result in unexpected or unintended program behavior.
|Axivion Bauhaus Suite|
|LANG.FUNCS.PROT||Incomplete function prototype|
Can detect violation of this recommendation when the
|LDRA tool suite|
|Polyspace Bug Finder|
Rec. fully covered.
1304, 2050, 3331,
3335, 3408, 3450
|SonarQube C/C++ Plugin|
|ISO/IEC TR 24772:2013||Type System [IHN]|
Subprogram Signature Mismatch [OTR]
|ISO/IEC TS 17961||Using a tainted value as an argument to an unprototyped function pointer [taintnoproto]|
Rule 8.2 (required)
|[ISO/IEC 9899:2011]||Subclause 6.11.7, "Function Definitions"|
|[Spinellis 2006]||Section 2.6.1, "Incorrect Routine or Arguments"|