Linkage

• No linkage
• Internal linkage
• External linkage
• Module linkage

Linkage is an identifier's property. It allows the compiler in some cases to create one common entity for several same-name declarations in different translation units. Together with the scope, linkage determines from which translation units and their scopes you can access the entity.

There are 4 types of linkage: no linkage, internal linkage, external linkage, and module linkage.

No linkage

The following entities declared in the block scope have no linkage:

• Local variables without the extern specifier;
• Local classes and their methods;
• Other identifiers, except function names, such as aliases or enumerations.

For each name with no linkage the compiler generates a separate object.

Internal linkage

Any identifier with internal linkage is accessible throughout the current translation unit. For several declarations of the same name with internal linkage within one translation unit, the compiler generates a single object. For identifiers of the same name with internal linkage in different translation units, the compiler creates different objects.

The following entities declared in a namespace have internal linkage:

• Variables and functions declared static;
• Non-template variables declared const and neither declared inline and volatile, nor extern. Additionally, previously such a variable should not be declared to have external linkage;
• Data members of an anonymous union;
• Any names in an unnamed namespace, including those declared extern.

External linkage

Any identifier with external linkage is accessible from other translation units. For the identifiers of the same name with external linkage, the compiler creates a single object.

The identifier with external linkage also has a language linkage, through which translation units written in different programming languages link together.

The following entities declared in a namespace have external linkage:

• Functions without the static specifier;
• Variables without the const and extern specifiers;
• Variables declared extern;
• Enumerations;
• Names of classes and their methods, as well as nested classes and enumerations;
• Functions declared in a class with the friend specifier;
• Templates declared static unless they are function or variable templates.

The following entities declared in the block scope have external linkage:

• Variables declared extern;
• Functions.

Module linkage

Starting from the C++20 standard, an identifier can have module linkage. Such an identifier is accessible from the translation units belonging to the module in which it is declared. Accordingly, for several identical declarations of the same name entities with module linkage, one object will be created within the same module.

Identifiers have module linkage when they are attached to a named module and not declared with the export keyword. Code example:

// cute_module_main.h
module CuteModule:moduleVariable;

int moduleVariable = 0;

// cute_module_calculator.h
export module CuteModule;

import :moduleVariable;

export int GetSquaredModuleVariable() {
    return ::moduleVariable * ::moduleVariable;
}

Here, moduleVariable has module linkage.