In programming, linkage describes how names can or can not refer to the same entity throughout the whole program or one single translation unit.
The static keyword is used in C to restrict the visibility of a function or variable to its translation unit. This is also valid in C++. C++98 and C++03 deprecated this usage in favor of anonymous namespaces, but is no longer deprecated in C++11. Also, C++ implicitly treats any const namespace-scope variable as having internal linkage unless it is explicitly declared extern, unlike C.
A name's linkage is related to, but distinct from, its scope. The scope of a name is the part of a translation unit where it is visible. For instance, a name with global scope (which is the same as file-scope in C and the same as the global namespace-scope in C++) is visible in any part of the file. Its scope will end at the end of the translation unit, whether or not that name has been given external or internal linkage.
If the name has external linkage, the entity that name denotes may be referred to from another translation unit using a distinct declaration for that same name, and from other scopes within the same translation unit using distinct declarations. Were the name given internal linkage, such a declaration would denote a distinct entity, although using the same name, but its entity could be referred to by distinct declarations within the same translation unit. A name that has no linkage at all cannot be referred to from declarations in different scopes, not even from within the same translation unit. Examples of such names are parameters of functions and local variables. The details differ between C (where only objects and functions - but not types - have linkage) and C++ and between this simplified overview.
Linkage between languages must be done with some care, as different languages adorn their external symbols differently.
A common idiom uses extern "C" to link C++ and C code.
Contents
C
Definition of 'linkage' quoted from ISO/IEC 9899:TC3 (C99 Standard). C uses the term "identifier" where this article uses "name" (the latter of which is what C++ uses to formalize linkage):
An identifier declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage.
The following is a common example of linkage:
In demo1.c:
In demo2.c:
Function foo() is declared in two files, with its function body defined in demo2.c. Via linkage, foo() called in main() inside demo1.c refers to foo in demo2.c. This is an example of external linkage for a function.
C++
C++ offers the following forms of linkage:
No linkage
Names with no linkage are those which may only be reference from the exact scope in which they are declared. For example, local variables, function parameters, and local classes.
Internal linkage
Names with internal linkage are those which may be referenced from any scope within the same translation unit. With internal linkage, each translation unit receives its own isolated copy of the symbol. A symbol gets internal linkage if declared static at namespace scope. By default, const, constexpr, and typedef objects also have internal linkage. However, using the inline specifier on an const variable at namespace scope gives it external linkage.
All entities placed inside an "unnamed namespace" (also known as an "anonymous namespace") are given internal linkage. An unnamed namespace should not be confused for the global namespace.
External linkage
Names with external linkage are those which may be referenced from any translation unit across the entire program.
Module linkage
Names with module linkage are those which may be shared across different translation units but only if they belong to the same named module. Such symbols may be accessed by any file part of the module itself, but not from code that imports that module, unless it is explicitly declared export.
Language linkage
C linkage is denoted with extern "C", which disables C++ name mangling. It allows C++ programs to link against compiled libraries written purely in C, and allows calling of C++ functions from C. extern "C" code may not expose types or features not present in C (such as classes, templates or exception throwing).
C++ linkage is denoted with extern "C++", and is used to explicitly force C++ linkage conventions. This may be used within extern "C" blocks to force a symbol to have C++ linkage. Additionally, it is used in C++ modules to force something in the module purview to be attached to the global module, allowing symbols with internal linkage from a header to still be attached to the module.
Some compilers may support additional language linkages. For example, GCC supports Java linkage with extern "Java", which is used when referencing Java code compiled by GCJ and used in C++ code to indicate that a symbol that is consumed originates from Java.
For example, from Java:
Then, in C++:
The string that appears after extern is unevaluated, that is, a string literal is expected but it is not evaluated by the compiler.
D
In D, a block of code that is meant to be declared as originating from another language can be marked extern (...):
extern (C) (for C)
extern (C++) (for C++)
extern (Objective-C) (for Objective-C)
extern (D)
Rust
In Rust, extern "C" is used to mark C linkage, and is always unsafe, as Rust cannot guarantee the safety of foreign functions.
Meanwhile, to expose Rust functions to C:
Rust offers the following external blocks:
unsafe extern "Rust" (default calling convention on Rust)
unsafe extern "C" (the default C ABI)
Other system-specific blocks exist, many of which correspond to C/C++ compiler attributes, for example unsafe extern "stdcall" corresponding to [[gnu::stdcall]].
The cxx library, a third-party library offering interoperability between C++ and Rust, offers a unsafe extern "C++" block, for declaring C++ symbols available to Rust.