CERT C: Rule DCL31-C

The rule checker flags situations where a function parameter or return type is not explicitly specified. To enable checking of this rule, use the value c90 for the option C standard version (-c-version).

In some circumstances, you can omit types from the C90 standard. In those cases, the int type is implicitly specified. However, the omission of an explicit type can lead to confusion. For example, in the declaration extern void foo (char c, const k);, the type of k is const int, but you might expect const char.

You might be using an implicit type in:

static foo(int a);  /* Non compliant */
static void bar(void);      /* Compliant */

In this example, the rule is violated because the return type of foo is implicit.

The issue occurs when you call a function before you declare or define it.

An implicit declaration occurs when you call a function before declaring or defining it. When you declare a function explicitly before calling it, the compiler can match the argument and return types with the parameter types in the declaration. If an implicit declaration occurs, the compiler makes assumptions about the argument and return types. For instance, it assumes a return type of int. The assumptions might not agree with what you expect and cause undesired type conversions.

#include <math.h>

extern double power3 (double val, int exponent);
int getChoice(void);

double func() {
    double res;
    int ch = getChoice();
    if(ch == 0) {
        res = power(2.0, 10);    /* Non-compliant */
    }
    else if( ch==1) {
        res = power2(2.0, 10);   /* Non-compliant */
    }
    else {
        res = power3(2.0, 10);   /* Compliant */
        return res;
    }
}

double power2 (double val, int exponent) {
    return (pow(val, exponent));
}

In this example, the rule is violated when a function that is not declared is called in the code. Even if a function definition exists later in the code, the rule violation occurs.

The rule is not violated when the function is declared before it is called in the code. If the function definition exists in another file and is available only during the link phase, you can declare the function in one of the following ways: