2.8 Linkage

Data objects and functions can be implicitly or explicitly assigned linkage. There are three kinds of linkage:

• Internal linkage-a declaration referring to a data object or function declared in the same compilation unit, and not known outside the compilation unit.

• External linkage-a declaration referring to a definition of a data object or function known outside the compilation unit. The definition of the object also has external linkage.

• No linkage-a declaration declaring a unique data object.

When more than one declaration of the same object or function is made, linkage is made. The linked declarations can be in the same scope or in different scopes. Externally linked objects are available to any function in any compilation unit used to create the executable file. Internally linked objects are available only to the compilation unit in which the declarations appear.

The concept of linkage and the static and extern keywords are related, but not directly. Using the extern keyword in an object's declaration does not guarantee external linkage. The following rules determine the actual linkage of an object or function:

• An identifier explicitly specified with the auto or register storage class has no linkage.

• An identifier with block scope and the extern storage-class specification has linkage the same as any visible declaration of the same identifier with file scope. If no such declaration of the object or function is visible, then the object or function has external linkage.

• The declaration of functions defaults to external linkage. The only other storage class possible for a function is static , which must be specified explicitly, cannot be applied to a block scope function declaration, and results in internal linkage.

• The file scope declaration of a data object without an explicit storage class specification, or with the extern storage class specified, has external linkage.

• An identifier with file scope and the static storage class has internal linkage.

• An identifier with block scope and without the extern storage-class specification has no linkage.

Identifiers other than data objects and functions have no linkage. An identifier declared as a function parameter also has no linkage.

The following examples show declarations with different linkages:

extern int x;          /*  External linkage                        */
static int y;          /*  Internal linkage                        */
register int z;        /*  Illegal storage-class declaration       */

main ()                /*  Functions default to external linkage   */
{
    int w;             /*  No linkage                              */
    extern int x;      /*  External linkage                        */
    extern int y;      /*  Internal linkage                        */
    static int a;      /*  No linkage                              */
}

void func1 (int arg1)  /*  arg1 has no linkage                     */
{ }

In DEC C, a message is issued if the same object is declared with both internal and external linkage.