Linkage determines the visibility and connection method of C symbols between different translation units, and is divided into three types: external, internal and no linkage. External linkage allows symbols to be accessed throughout the program, such as default global variables and functions; internal linkage restricts symbols to be only valid in the current source file and are implemented through static or const; no linkage is used for local variables and is only valid in its scope. Using linkage correctly can avoid duplicate definitions or not finding symbols.

The linkage in C actually talks about how symbols are identified and connected between different translation units. Simply put, it is whether the symbols such as variables and functions can be correctly shared or merged in multiple source files. If you can't figure out the linkage, it is easy to have problems during the compilation and linking stage, such as repeated definitions, no symbols found, etc.

What is linkage?

Linkage literal translation is "connection", which refers to the question of whether the names of variables, functions, etc. are visible and shared between different scopes or different files. It is divided into three types:

• external linkage : Symbols are visible throughout the program and can be accessed by multiple files.
• internal linkage : The symbol is only visible in the current translation unit (that is, the current source file).
• no linkage : The symbol is only valid within the scope where it is defined, such as local variables.

For example, if a global variable is an external linkage by default, multiple source files can access it through extern ; and if static is added, it becomes internal.

Typical usage of external linkage

Most functions and global variables are external linkages by default. For example:

 // a.cpp
int globalVar = 10;

void foo() {
    // ...
}

 // b.cpp
extern int globalVar; // Declaration tells the compiler that this variable has been defined elsewhere void bar() {
    globalVar = 20; // Modify globalVar defined in a.cpp
}

In the example above, globalVar and foo() both have external linkages, so they can be accessed in multiple source files. This is also the most common requirement when writing multi-file projects.

It should be noted that if both files define global variables with the same name (non-const, non-static), the linker will report an error and prompt to repeatedly define.

How to use internal linkage?

If you want a variable or function to be used only in the current file and not to "expose" it to other files, you can use the static keyword (you can also use const to modify global variables in the namespace to implement internal):

 // utils.cpp
static int helperVar = 0; // Only visible in utils.cpp static void helperFunc() {
    // Can only be called in utils.cpp}

At this time, even if other files write extern int helperVar; they cannot access this variable, and an error will be reported during linking.

const global variable is internal by default, which is why you can define const int Max = 100; with the same name in multiple source files without error.

There is no linkage

Local variables and function parameters all belong to no linkages, and they are only valid in the code blocks that define them. for example:

 void func() {
    int localVar = 42; // localVar is only visible inside func}

If you try to access it with extern int localVar; in another function, that won't work.

Small details are easy to ignore

• The inline function can have an external linkage after C 17, but it can be repeatedly defined in multiple translation units and no errors will be reported.
• If the constexpr variable is defined in the header file, it is best to add inline (from C 17) or declare it with extern , otherwise it may lead to multiple definitions.
• Using anonymous namespaces can replace static implementation of internal linkage, with a more modern syntax:

 namespace {
    int secret = 42;
} // secret has internal linkage

Basically that's it. It is very helpful to understand the classification and usage scenarios of linkages and to avoid link errors.

The above is the detailed content of Linkage in C. For more information, please follow other related articles on the PHP Chinese website!