6 Basic concepts [basic]

6.5 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.
translation-unit:
	declaration-seq
A name is said to have linkage when it might 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 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.
A name having namespace scope has internal linkage if it is the name of
  • a variable, function or function template that is explicitly declared static; or,
  • a non-inline variable of non-volatile const-qualified type that is neither explicitly declared extern nor previously declared to have external linkage; or
  • a data member of an anonymous union.
An unnamed namespace or a namespace declared directly or indirectly within an unnamed namespace has internal linkage.
All other namespaces have external linkage.
A name having namespace scope that has not been given internal linkage above has the same linkage as the enclosing namespace if it is the name of
  • a variable; or
  • a function; or
  • a named class (Clause [class]), 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
  • a template.
In addition, a member function, static data member, a named class or enumeration of class scope, or an unnamed class or enumeration defined in a class-scope typedef declaration 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.
The name of a function declared in block scope and the name of a variable declared by a block scope extern declaration have linkage.
If there is a visible declaration of an entity with linkage having the same name and type, ignoring entities declared outside the innermost enclosing namespace scope, the block scope declaration declares that same entity and receives the linkage of the previous declaration.
If there is more than one such matching entity, the program is ill-formed.
Otherwise, if no matching entity is found, the block scope entity receives external linkage.
If, within a translation unit, the same entity is declared with both internal and external linkage, the program is ill-formed.
[Example
:
static void f();
static int i = 0;               // #1
void g() {
  extern void f();              // internal linkage
  int i;                        // #2: i has no linkage
  {
    extern void f();            // internal linkage
    extern int i;               // #3: external linkage, ill-formed
  }
}
Without the declaration at line #2, the declaration at line #3 would link with the declaration at line #1.
Because the declaration with internal linkage is hidden, however, #3 is given external linkage, making the program ill-formed.
end example
]
When a block scope declaration of an entity with linkage is not found to refer to some other declaration, then that entity is a member of the innermost enclosing namespace.
However such a declaration does not introduce the member name in its namespace scope.
[Example
:
namespace X {
  void p() {
    q();                        // error: q not yet declared
    extern void q();            // q is a member of namespace X
  }

  void middle() {
    q();                        // error: q not yet declared
  }

  void q() { /* ... */ }        // definition of X​::​q
}

void q() { /* ... */ }          // some other, unrelated q
end example
]
Names not covered by these rules have no linkage.
Moreover, except as noted, a name declared at block scope has no linkage.
A type is said to have linkage if and only if:
  • it is a class or enumeration type that is named (or has a name for linkage purposes ([dcl.typedef])) and the name has linkage; or
  • it is an unnamed class or unnamed enumeration that is a member of a class with linkage; or
  • it is a specialization of a class template (Clause [temp])35; or
  • it is a fundamental type; or
  • it is a compound type other than a class or enumeration, compounded exclusively from types that have linkage; or
  • it is a cv-qualified version of a type that has linkage.
A type without linkage shall not be used as the type of a variable or function with external linkage unless
[Note
:
In other words, a type without linkage contains a class or enumeration that cannot be named outside its translation unit.
An entity with external linkage declared using such a type could not correspond to any other entity in another translation unit of the program and thus must be defined in the translation unit if it is odr-used.
Also note that classes with linkage may contain members whose types do not have linkage, and that typedef names are ignored in the determination of whether a type has linkage.
end note
]
[Example
:
template <class T> struct B {
  void g(T) { }
  void h(T);
  friend void i(B, T) { }
};

void f() {
  struct A { int x; };  // no linkage
  A a = { 1 };
  B<A> ba;              // declares B<A>​::​g(A) and B<A>​::​h(A)
  ba.g(a);              // OK
  ba.h(a);              // error: B<A>​::​h(A) not defined in the translation unit
  i(ba, a);             // OK
}
end example
]
Two names that are the same and that are declared in different scopes shall denote the same variable, function, type, template or namespace if
  • both names have external linkage or else both names have internal linkage and are declared in the same translation unit; and
  • both names refer to members of the same namespace or to members, not by inheritance, of the same class; and
  • when both names denote functions, the parameter-type-lists of the functions ([dcl.fct]) are identical; and
  • when both names denote function templates, the signatures ([temp.over.link]) are the same.
After all adjustments of types (during which typedefs are replaced by their definitions), the types specified by all declarations referring to a given variable or function shall be identical, except that declarations for an array object can specify array types that differ by the presence or absence of a major array bound ([dcl.array]).
A violation of this rule on type identity does not require a diagnostic.
[Note
:
Linkage to non-C++ declarations can be achieved using a linkage-specification ([dcl.link]).
end note
]
A class template has the linkage of the innermost enclosing class or namespace in which it is declared.