6 Basics [basic]

6.6 Program and linkage [basic.link]

A program consists of one or more translation units linked together.
A translation unit consists of a sequence of declarations.
A name is said to have linkage when it can denote the same object, reference, function, type, template, namespace or value as a name introduced by a declaration in another scope:
  • When a name has external linkage, the entity it denotes can be referred to by names from scopes of other translation units or from other scopes of the same translation unit.
  • When a name has module linkage, the entity it denotes can be referred to by names from other scopes of the same module unit or from scopes of other module units of that same module.
  • When a name has internal linkage, the entity it denotes can be referred to by names from other scopes in the same translation unit.
  • When a name has no linkage, the entity it denotes cannot be referred to by names from other scopes.
The name of an entity that belongs to a namespace scope has internal linkage if it is the name of
  • a variable, variable template, function, or function template that is explicitly declared static; or
  • a non-template variable of non-volatile const-qualified type, unless
    • it is explicitly declared extern, or
    • it is inline or exported, or
    • it was previously declared and the prior declaration did not have internal linkage; or
  • a data member of an anonymous union.
[Note 1:
An instantiated variable template that has const-qualified type can have external or module linkage, even if not declared extern.
— end note]
An unnamed namespace or a namespace declared directly or indirectly within an unnamed namespace has internal linkage.
All other namespaces have external linkage.
The name of an entity that belongs to a namespace scope that has not been given internal linkage above and that is the name of
  • a variable; or
  • a function; or
  • a named class ([class.pre]), or an unnamed class defined in a typedef declaration in which the class has the typedef name for linkage purposes ([dcl.typedef]); or
  • a named enumeration, or an unnamed enumeration defined in a typedef declaration in which the enumeration has the typedef name for linkage purposes ([dcl.typedef]); or
  • an unnamed enumeration that has an enumerator as a name for linkage purposes ([dcl.enum]); or
  • a template
has its linkage determined as follows:
  • if the enclosing namespace has internal linkage, the name has internal linkage;
  • otherwise, if the declaration of the name is attached to a named module ([module.unit]) and is not exported ([module.interface]), the name has module linkage;
  • otherwise, the name has external linkage.
In addition, a member function, a static data member, a named class or enumeration that inhabits a class scope, or an unnamed class or enumeration defined in a typedef declaration that inhabits a class scope such that the class or enumeration has the typedef name for linkage purposes ([dcl.typedef]), has the same linkage, if any, as the name of the class of which it is a member.
[Example 1: static void f(); extern "C" void h(); static int i = 0; // #1 void q() { extern void f(); // internal linkage extern void g(); // ​::​g, external linkage extern void h(); // C language linkage int i; // #2: i has no linkage { extern void f(); // internal linkage extern int i; // #3: internal linkage } }
Even though the declaration at line #2 hides the declaration at line #1, the declaration at line #3 still redeclares #1 and receives internal linkage.
— end example]
Names not covered by these rules have no linkage.
Moreover, except as noted, a name declared at block scope has no linkage.
Two declarations of entities declare the same entity if, considering declarations of unnamed types to introduce their names for linkage purposes, if any ([dcl.typedef], [dcl.enum]), they correspond ([basic.scope.scope]), have the same target scope that is not a function or template parameter scope, and either
  • they appear in the same translation unit, or
  • they both declare names with module linkage and are attached to the same module, or
  • they both declare names with external linkage.
[Note 2:
There are other circumstances in which declarations declare the same entity ([dcl.link], [temp.type], [temp.spec.partial]).
— end note]
If a declaration H that declares a name with internal linkage precedes a declaration D in another translation unit U and would declare the same entity as D if it appeared in U, the program is ill-formed.
[Note 3:
Such an H can appear only in a header unit.
— end note]
If two declarations of an entity are attached to different modules, the program is ill-formed; no diagnostic is required if neither is reachable from the other.
[Example 2:

"decls.h":int f(); // #1, attached to the global module int g(); // #2, attached to the global module

Module interface of M:module; #include "decls.h" export module M; export using ::f; // OK: does not declare an entity, exports #1 int g(); // error: matches #2, but attached to M export int h(); // #3 export int k(); // #4

Other translation unit:import M; static int h(); // error: matches #3 int k(); // error: matches #4 — end example]

As a consequence of these rules, all declarations of an entity are attached to the same module; the entity is said to be attached to that module.
For any two declarations of an entity E:
  • If one declares E to be a variable or function, the other shall declare E as one of the same type.
  • If one declares E to be an enumerator, the other shall do so.
  • If one declares E to be a namespace, the other shall do so.
  • If one declares E to be a type, the other shall declare E to be a type of the same kind ([dcl.type.elab]).
  • If one declares E to be a class template, the other shall do so with the same kind and an equivalent template-head ([temp.over.link]).
    [Note 4:
    The declarations can supply different default template arguments.
    — end note]
  • If one declares E to be a function template or a (partial specialization of a) variable template, the other shall declare E to be one with an equivalent template-head and type.
  • If one declares E to be an alias template, the other shall declare E to be one with an equivalent template-head and defining-type-id.
  • If one declares E to be a concept, the other shall do so.
Types are compared after all adjustments of types (during which typedefs ([dcl.typedef]) are replaced by their definitions); declarations for an array object can specify array types that differ by the presence or absence of a major array bound ([dcl.array]).
No diagnostic is required if neither declaration is reachable from the other.
[Example 3: int f(int x, int x); // error: different entities for x void g(); // #1 void g(int); // OK: different entity from #1 int g(); // error: same entity as #1 with different type void h(); // #2 namespace h {} // error: same entity as #2, but not a function — end example]
[Note 5:
Linkage to non-C++ declarations can be achieved using a linkage-specification ([dcl.link]).
— end note]
A declaration D names an entity E if
A declaration is an exposure if it either names a TU-local entity (defined below), ignoring
  • the function-body for a non-inline function or function template (but not the deduced return type for a (possibly instantiated) definition of a function with a declared return type that uses a placeholder type ([dcl.spec.auto])),
  • the initializer for a variable or variable template (but not the variable's type),
  • friend declarations in a class definition, and
  • any reference to a non-volatile const object or reference with internal or no linkage initialized with a constant expression that is not an odr-use ([basic.def.odr]),
or defines a constexpr variable initialized to a TU-local value (defined below).
[Note 7:
An inline function template can be an exposure even though explicit specializations of it might be usable in other translation units.
— end note]
An entity is TU-local if it is
  • a type, function, variable, or template that
    • has a name with internal linkage, or
    • does not have a name with linkage and is declared, or introduced by a lambda-expression, within the definition of a TU-local entity,
  • a type with no name that is defined outside a class-specifier, function body, or initializer or is introduced by a defining-type-specifier that is used to declare only TU-local entities,
  • a specialization of a TU-local template,
  • a specialization of a template with any TU-local template argument, or
  • a specialization of a template whose (possibly instantiated) declaration is an exposure.
    [Note 8:
    A specialization can be produced by implicit or explicit instantiation.
    — end note]
A value or object is TU-local if either
  • it is, or is a pointer to, a TU-local function or the object associated with a TU-local variable, or
  • it is an object of class or array type and any of its subobjects or any of the objects or functions to which its non-static data members of reference type refer is TU-local and is usable in constant expressions.
If a (possibly instantiated) declaration of, or a deduction guide for, a non-TU-local entity in a module interface unit (outside the private-module-fragment, if any) or module partition ([module.unit]) is an exposure, the program is ill-formed.
Such a declaration in any other context is deprecated ([depr.local]).
If a declaration that appears in one translation unit names a TU-local entity declared in another translation unit that is not a header unit, the program is ill-formed.
A declaration instantiated for a template specialization ([temp.spec]) appears at the point of instantiation of the specialization ([temp.point]).
[Example 4:

Translation unit #1:export module A; static void f() {} inline void it() { f(); } // error: is an exposure of f static inline void its() { f(); } // OK template<int> void g() { its(); } // OK template void g<0>(); decltype(f) *fp; // error: f (though not its type) is TU-local auto &fr = f; // OK constexpr auto &fr2 = fr; // error: is an exposure of f constexpr static auto fp2 = fr; // OK struct S { void (&ref)(); } s{f}; // OK, value is TU-local constexpr extern struct W { S &s; } wrap{s}; // OK, value is not TU-local static auto x = []{f();}; // OK auto x2 = x; // error: the closure type is TU-local int y = ([]{f();}(),0); // error: the closure type is not TU-local int y2 = (x,0); // OK namespace N { struct A {}; void adl(A); static void adl(int); } void adl(double); inline void h(auto x) { adl(x); } // OK, but a specialization might be an exposure

Translation unit #2:module A; void other() { g<0>(); // OK, specialization is explicitly instantiated g<1>(); // error: instantiation uses TU-local its h(N::A{}); // error: overload set contains TU-local N​::​adl(int) h(0); // OK, calls adl(double) adl(N::A{}); // OK; N​::​adl(int) not found, calls N​::​adl(N​::​A) fr(); // OK, calls f constexpr auto ptr = fr; // error: fr is not usable in constant expressions here } — end example]