Forward declaration

From Wikipedia, the free encyclopedia

In computer programming, a forward declaration is a declaration of a variable or function which the programmer has not yet given a complete definition.

int elements[];
void foo(int);

In the C programming language, the two lines above represent forward declarations of an array and a function of one parameter, respectively. (The latter is also a function prototype.) After processing these declarations, the compiler would allow the programmer to refer to the entities elements and foo in the rest of the program; but at some point the programmer would still have to provide definitions for the declared entities:

int elements[10];
void foo(int x) { printf("%d\n", x); }

In Pascal and other Wirth programming languages, it is a general rule that all entities must be declared before use. In C, the same general rule applies, but with an exception for undeclared functions. Thus, in C it is possible (although unwise) to implement a pair of mutually recursive functions thus:

int first(int x)
{
    if (x == 0) return 1;
    return second(x-1);
}

int second(int x)
{
    if (x == 0) return 0;
    return first(x-1);
}

In Pascal, the same implementation requires a forward declaration of second to precede its use in first. Without the forward declaration, the compiler will produce an error message indicating that the identifier second has been used without being declared.

[edit] Forward reference

The term forward reference is sometimes used as a synonym of forward declaration.[1] However, more often it is taken to refer to the actual use of an entity before any declaration; that is, the first reference to second in the code above is a forward reference.[2][3] Thus, we may say that because forward declarations are mandatory in Pascal, forward references are prohibited.

An example of (valid) forward reference in C++:

class C {
    public:
        void mutator(int x) { myValue = x; }
        int accessor() { return myValue; }
    private:
        int myValue;
};

In this example, there are two references to myValue before it is declared. C++ generally prohibits forward references, but they are allowed in the special case of class members. Since the member function accessor cannot be compiled until the compiler knows the type of the member variable myValue, it is the compiler's responsibility to remember the definition of accessor until it sees myValue's declaration.

Permitting forward reference can greatly increase the complexity and memory requirements of a compiler, and generally prevents the compiler from being implemented in one pass.