revised: 01/06/2008, 06/23/2017

Puzzles SL21 ... SL30


The scope of an identifier is concerned with what the compiler can see. For example, when the compiler converts the following into machine language,

sum = alpha + beta;

it needs to know which variables sum, alpha and beta refer to. Several different entities in a single source file might use these names, and scope is used to keep them neatly separated. The output of the compiler is an object file. Each object file is created from just one source file.

The linkage of an identifier is concerned with what the linker does with various entities (variables and functions) that have already been compiled and are now located in various object files. The linker creates an executable file out of several object files and library files.

An object file contains functions and external variables that are in a form that is close to machine language. These entities are identified by name so other parts of the program can use them. A library is a file that contains a collection of object files.

An entity in an object file uses the same identifier as its declaration in a source file. For example, the function foo() might be defined in a source file. In the corresponding object file there will be a section of machine language called foo. Another source file might try to call foo(). But how can it do this when foo() exists in a different file? This is done by the linker when it links the object files together. One object file defines foo() and keeps the name foo with the definition. The other object file contains the code that calls foo(), wherever it is. The linker connects the call with the definition.

When does the same identifier in several object files correspond to just one entity and when does it correspond to several different entities? The linkage of the identifiers resolves this. Study the following picture

Compiling and Linking

The identifier x is used in three different source files. The source files are compiled into three object files. The object files are linked into one executable file. Source files in a project need to refer to entities defined in other source files. In the picture, fileA.c and fileC.c both refer to a single entity x. The x in fileB.c is a local variable and is a different entity.

Object files contain information about their entities, including their identifiers. When an entity (such as a variable) is external, the linker ensures that there is only one of that entity in the executable file. In the picture, variable x in fileA.c and fileC.c is external. Even though two object files refer to it, the linker ensures that there is just one x in the executable.

The picture shows the executable with a single int variable x (as a little box of memory) and the functions foo() and main() all linked together. The executable file does not contain the names of entities, although they are shown in the picture. An executable file is nearly pure machine code and data, although usually some debugging information is also included.

Next Page         Home