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.


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:

A name having namespace scope has internal linkage if it is the name of

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

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:

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]


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

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. end note]

A class template has the linkage of the innermost enclosing class or namespace in which it is declared.