translation­unit:
     declaration­seq_opt

• 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.

• an object, reference, function or function template that is explicitly declared static or,
• an object or reference that is explicitly declared const and neither explicitly declared extern nor previously declared to have external linkage; or
• a data member of an anonymous union.

• an object or reference, unless it has internal linkage; or
• a function, unless it has internal linkage; or
• a named class (clause 9), or an unnamed class defined in a typedef declaration in which the class has the typedef name for linkage purposes (7.1.3); or
• a named enumeration (7.2), or an unnamed enumeration defined in a typedef declaration in which the enumeration has the typedef name for linkage purposes (7.1.3); or
• an enumerator belonging to an enumeration with external linkage; or
• a template, unless it is a function template that has internal linkage (clause 14); or
• a namespace (7.3), unless it is declared within an unnamed namespace.

[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
        }
    }

There are three objects named i in this program. The object with internal linkage introduced by the declaration in global scope (line // 1), the object with automatic storage duration and no linkage introduced by the declaration on line // 2, and the object with static storage duration and external linkage introduced by the declaration on line // 3. ]

    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]

    void f()
    {
            struct A { int x; }; // no linkage
            extern A a;          // ill­formed
            typedef A B;
            extern B b;          // ill­formed
    }

--end example] This implies that names with no linkage cannot be used as template arguments (14.3).

• 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

---

Prec.     Page 43     Suiv.
• when both names denote functions, the function types are identical for purposes of overloading; and
• when both names denote function templates, the signatures (14.5.5.1) are the same.

    int main() { /* ... */ }

and

    int main (int argc, char* argv[]) { /* ... */ }

In the latter form argc shall be the number of arguments passed to the program from the environment in which the program is run. If argc is nonzero these arguments shall be supplied in argv [0] through argv [argc­1] as pointers to the initial characters of null­terminated multibyte strings (NTMBSs) (17.3.2.1.3.2) and argv [0] shall be the pointer to the initial character of a NTMBS that represents the name used to invoke the program or "". The value of argc shall be nonnegative. The value of argv [argc] shall be 0. [Note: it is recommended that any further (optional) parameters be added after argv. ]

    void exit (int);

declared in <cstdlib> (18.3) terminates the program without leaving the current block and hence without destroying any objects with automatic storage duration (12.4). If exit is called to end a program during the destruction of an object with static storage duration, the program has undefined behavior.

    return 0;

• the dynamic version of the initialization does not change the value of any other object of namespace scope with static storage duration prior to its initialization, and
• the static version of the initialization produces the same value in the initialized object as would be produced by the dynamic initialization if all objects not required to be initialized statically were initialized dynamically.

[Note: as a consequence, if the initialization of an object obj1 refers to an object obj2 of namespace scope with static storage duration potentially requiring dynamic initialization and defined later in the same translation unit, it is unspecified whether the value of obj2 used will be the value of the fully initialized obj2 (because obj2 was statically initialized) or will be the value of obj2 merely zero­initialized. For example,

   inline double fd() { return 1.0; }
   extern double d1;
   double d2 = d1;   // unspecified:
                     // may be statically initialized to 0.0 or
                     // dynamically initialized to 1.0
   double d1 = fd(); // may be initialized statically to 1.0

--end note]

It is implementation­defined whether or not the dynamic initialization (8.5, 9.4, 12.1, 12.6.1) of an object of namespace scope is done before the first statement of main. If the initialization is deferred to some point in time after the first statement of main, it shall occur before the first use of any function or object defined in the same translation unit as the object to be initialized. ³¹⁾ [Example:

    // - File 1 -
    #include "a.h"
    #include "b.h"
    B b;
    A::A(){
       b.Use();
    }

    // - File 2 -
    #include "a.h"
    A a;

    int main() {
       a.Use();
       b.Use();
    }

    void abort();

declared in <cstdlib> terminates the program without executing destructors for objects of automatic or static storage duration and without calling the functions passed to atexit().

-- static storage duration
-- automatic storage duration
-- dynamic storage duration

    void* operator new (std::size_t) throw (std::bad_alloc);
    void* operator new[] (std::size_t) throw (std::bad_alloc);
    void operator delete (void*) throw();
    void operator delete[] (void*) throw();

These implicit declarations introduce only the function names operator new, operator new[], operator delete, operator delete[]. [Note: the implicit declarations do not introduce the names std, std::bad_alloc, and std::size_t, or any other names that the library uses to declare these names. Thus, a new­expression, delete­expression or function call that refers to one of these functions without including the header <new> is well­formed. However, referring to std, std::bad_alloc, and std::size_t is ill­formed unless the name has been declared by including the appropriate header. ]

Allocation and/ or deallocation functions can also be declared and defined for any class (12.5).

3 Any allocation and/ or deallocation functions defined in a C++ program shall conform to the semantics specified in 3.7.3.1 and 3.7.3.2.

- storage with the proper alignment and size for type T is obtained, and
- if T is a class type with a non­trivial constructor (12.1), the constructor call has completed.

The lifetime of an object of type T ends when:

- if T is a class type with a non­trivial destructor (12.4), the destructor call starts, or
- the storage which the object occupies is reused or released.

-- the pointer is used to access a non­static data member or call a non­static member function of the object, or
-- the pointer is implicitly converted (4.10) to a pointer to a base class type, or
-- the pointer is used as the operand of a static_cast (5.2.9) (except when the conversion is to void*, or to void* and subsequently to char*, or unsigned char*).

-- the pointer is used as the operand of a dynamic_cast (5.2.7). [Example:

    struct B {
        virtual void f();
        void mutate();
        virtual ~B();
    };

    struct D1 : B { void f(); };
    struct D2 : B { void f(); };

    void B::mutate() {
        new (this) D2;     // reuses storage - ends the lifetime of *this
        f();               // undefined behavior
        ... = this;        // OK, this points to valid memory
    }

    void g() {
        void* p = malloc (sizeof( D1) + sizeof (D2));
        B* pb = new (p) D1;
        pb­> mutate();
        &pb;             // OK: pb points to valid memory
        void* q = pb;    // OK: pb points to valid memory
        pb­> f();        // undefined behavior, lifetime of *pb has ended
    }

-- end example]

- the storage for the new object exactly overlays the storage location which the original object occupied, and
- the new object is of the same type as the original object (ignoring the top­level cv­qualifiers), and
- the original object was a most derived object (1.8) of type T and the new object is a most derived object of type T (that is, they are not base class subobjects). [Example:

    struct C {
        int i;
        void f();
        const C& operator=( const C& );
    };

    const C& C::operator= (const C& other)
    {
        if (this != &other ) {
            this­>~ C();          // lifetime of *this ends
            new (this) C (other); // new object of type C created
            f();                  // well­defined
        }
        return *this;
    }

    C c1;
    C c2;
    c1 = c2;                     // well­defined
    c1. f();                     // well­defined; c1 refers to a new object of type C

--end example]

    class T { };
    struct B {
        ~B();
    };

    void h() {
        B b;
        new (& b) T;
    } // undefined behavior at block exit

--end example]

    struct B {
        B();
        ~B();
    };

    const B b;
    void h() {
        b.~ B();
        new (& b) const B; // undefined behavior
    }

--end example]

    #define N sizeof (T)
    char buf [N];
    T obj;                 // obj initialized to its original value
    memcpy (buf, &obj, N); // between these two calls to memcpy,
                           // obj might be modified
    memcpy(& obj, buf, N); // at this point, each subobject of obj of scalar type
                           // holds its original value

--end example]

    T* t1p;
    T* t2p;
                                    // provided that t2p points to an initialized object ...
    memcpy (t1p, t2p, sizeof (T));  // at this point, every subobject of POD type in *t1p contains
                                    // the same value as the corresponding subobject in *t2p

--end example]

    class X;             // X is an incomplete type
    extern X* xp;        // xp is a pointer to an incomplete type
    extern int arr[];    // the type of arr is incomplete
    typedef int UNKA[];  // UNKA is an incomplete type
    UNKA* arrp;          // arrp is a pointer to an incomplete type
    UNKA** arrpp;

    void foo()
    {
        xp++;             // ill­formed: X is incomplete
        arrp++;           // ill­formed: incomplete type
        arrpp++;          // OK: sizeof UNKA* is known
    }

    struct X { int i; }; // now X is a complete type
    int arr [10];        // now the type of arr is complete

    X x;
    void bar()
    {
        xp = &x;         // OK; type is '' pointer to X''
        arrp = &arr;     // ill­formed: different types
        xp++;            // OK: X is complete
        arrp++;          // ill­formed: UNKA can't be completed
    }

--end example]

1. Compound types can be constructed in the following ways:

   -- arrays of objects of a given type, 8.3.4;
   -- functions, which have parameters of given types and return void or references or objects of a given type, 8.3.5;

   -- pointers to void or objects or functions (including static members of classes) of a given type, 8.3.1;
   -- references to objects or functions of a given type, 8.3.2;
   -- classes containing a sequence of objects of various types (clause 9), a set of types, enumerations and functions for manipulating these objects (9.3), and a set of restrictions on the access to these entities (clause 11);

   -- unions, which are classes capable of containing objects of different types at different times, 9.5;
   -- enumerations, which comprise a set of named constant values. Each distinct enumeration constitutes a different enumerated type, 7.2;

   -- pointers to non­static ⁴⁵⁾ class members, which identify members of a given type within objects of a given class, 8.3.3.

2. These methods of constructing types can be applied recursively; restrictions are mentioned in 8.3.1, 8.3.4, 8.3.5, and 8.3.2.

3. A pointer to objects of type T is referred to as a "pointer to T." [Example: a pointer to an object of type int is referred to as "pointer to int" and a pointer to an object of class X is called a "pointer to X." ] Except for pointers to static members, text referring to "pointers" does not apply to pointers to members. Pointers to incomplete types are allowed although there are restrictions on what can be done with them (3.9). The value representation of pointer types is implementation­defined. Pointers to cv­qualified and cv­unqualified versions (3.9.3) of layout­compatible types shall have the same value representation and alignment requirements (3.9).

4. Objects of cv­qualified (3.9.3) or cv­unqualified type void* (pointer to void), can be used to point to objects of unknown type. A void* shall be able to hold any object pointer. A cv­qualified or cv­unqualified (3.9.3) void* shall have the same representation and alignment requirements as a cv­qualified or cv­unqualified char*.
    

   ---

   Prec.     Page 55     Suiv.

   3.9.3 CV­qualifiers

   [basic.type.qualifier]

   1. A type mentioned in 3.9.1 and 3.9.2 is a cv­unqualified type. Each type which is a cv­unqualified complete or incomplete object type or is void (3.9) has three corresponding cv­qualified versions of its type: a const­qualified version, a volatilequalified version, and a const­volatile­qualified version. The term object type (1.8) includes the cv­qualifiers specified when the object is created. The presence of a const specifier in a decl­specifier­seq declares an object of const­qualified object type; such object is called a const object. The presence of a volatile specifier in a decl­specifier­seq declares an object of volatile­qualified object type; such object is called a volatile object. The presence of both cv­qualifiers in a decl­specifier­seq declares an object of const­volatile­qualified object type; such object is called a const volatile object. The cv­qualified or cv­unqualified versions of a type are distinct types; however, they shall have the same representation and alignment requirements (3.9). ⁴⁶⁾

   2. A compound type (3.9.2) is not cv­qualified by the cv­qualifiers (if any) of the types from which it is compounded. Any cv­qualifiers applied to an array type affect the array element type, not the array type (8.3.4).

   3. Each non­static, non­mutable, non­reference data member of a const­qualified class object is const­qualified, each non­static, non­reference data member of a volatile­qualified class object is volatile­qualified and similarly for members of a const­volatile class. See 8.3.5 and 9.3.2 regarding cv­qualified function types.

   4. There is a (partial) ordering on cv­qualifiers, so that a type can be said to be more cv­qualified than another. Table 6 shows the relations that constitute this ordering.

      Table 6 -  relations on const and volatile

      no cv­qualifier < const

      no cv­qualifier < volatile
      no cv­qualifier < const volatile
      const < const volatile
      volatile < const volatile

      5 In this International Standard, the notation cv (or cv1, cv2, etc.), used in the description of types, represents an arbitrary set of cv­qualifiers, i. e., one of {const}, {volatile}, {const, volatile}, or the empty set. Cv­qualifiers applied to an array type attach to the underlying element type, so the notation, "cv T," where T is an array type, refers to an array whose elements are so­qualified. Such array types can be said to be more (or less) cv­qualified than other types based on the cv­qualification of the underlying ele­ment types.
       
       

      3.10 Lvalues and rvalues

      [basic.lval]

      1. Every expression is either an lvalue or an rvalue.

      2. An lvalue refers to an object or function. Some rvalue expressions
         -- those of class or cv­qualified classtype
         -- also refer to objects. ⁴⁷⁾

      3. [Note: some built­in operators and function calls yield lvalues. [Example: if E is an expression of pointer type, then *E is an lvalue expression referring to the object or function to which E points. As another example, the function

             int& f();

         yields an lvalue, so the call f() is an lvalue expression. ] ]
          

         ---

         Prec.     Page 56     Suiv.

         
         4 [Note: some built­in operators expect lvalue operands. [Example: built­in assignment operators all expect their left hand operands to be lvalues. ] Other built­in operators yield rvalues, and some expect them. [Example: the unary and binary + operators expect rvalue arguments and yield rvalue results. ] The discussion of each built­in operator in clause 5 indicates whether it expects lvalue operands and whether it yields an lvalue. ]

      4. The result of calling a function that does not return a reference is an rvalue. User defined operators are functions, and whether such operators expect or yield lvalues is determined by their parameter and return types.

      5. An expression which holds a temporary object resulting from a cast to a nonreference type is an rvalue (this includes the explicit creation of an object using functional notation (5.2.3)).

      6. Whenever an lvalue appears in a context where an rvalue is expected, the lvalue is converted to an rvalue; see 4.1, 4.2, and 4.3.

      7. The discussion of reference initialization in 8.5.3 and of temporaries in 12.2 indicates the behavior of lvalues and rvalues in other significant contexts.

      8. Class rvalues can have cv­qualified types; non­class rvalues always have cv­unqualified types. Rvalues shall always have complete types or the void type; in addition to these types, lvalues can also have incomplete types.

      9. An lvalue for an object is necessary in order to modify the object except that an rvalue of class type can also be used to modify its referent under certain circumstances. [Example: a member function called for an object (9.3) can modify the object. ]

      10. Functions cannot be modified, but pointers to functions can be modifiable.

      11. A pointer to an incomplete type can be modifiable. At some point in the program when the pointed to type is complete, the object at which the pointer points can also be modified.

      12. The referent of a const­qualified expression shall not be modified (through that expression), except that if it is of class type and has a mutable component, that component can be modified (7.1.5.1).

      13. If an expression can be used to modify the object to which it refers, the expression is called modifiable. A program that attempts to modify an object through a nonmodifiable lvalue or rvalue expression is ill­formed.

      14. If a program attempts to access the stored value of an object through an lvalue of other than one of the fol­lowing
          types the behavior is undefined ⁴⁸⁾ :
          • the dynamic type of the object,
          • a cv­qualified version of the dynamic type of the object,
          • a type that is the signed or unsigned type corresponding to the dynamic type of the object,
          • a type that is the signed or unsigned type corresponding to a cv­qualified version of the dynamic type of the object,
          • an aggregate or union type that includes one of the afore mentioned types among its members (including, recursively, a member of a subaggregate or contained union),
          • a type that is a (possibly cv­qualified) base class type of the dynamic type of the object,
          • a char or unsigned char type.

          ---

          Prec.     Page 57     Suiv.

          ---

          31) An object defined in namespace scope having initialization with side­effects must be initialized even if it is not used (3.7.1).

          32) The intent is to have operator new() implementable by calling malloc() or calloc(), so the rules are substantially the same. C++ differs from C in requiring a zero request to return a non­null pointer.

          33) On some implementations, it causes a system­generated runtime fault.

          34) For example, before the construction of a global object of non­POD class type (12.7).

          35) That is, an object for which a destructor will be called implicitlyÐ either either upon exit from the block for an object with automatic storage duration or upon exit from the program for an object with static storage duration.

          36) By using, for example, the library functions (17.4.1.2) memcpy or memmove.

          37) The intent is that the memory model of C++ is compatible with that of ISO/ IEC 9899 Programming Language C.

          38) The size and layout of an instance of an incompletely­defined object type is unknown. type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting unsigned integer type.

          39) That is, large enough to contain any value in the range of INT_MIN and INT_MAX,as defined in the header <climits>.

          40) See 7.1.5.2 regarding the correspondence between types and the sequences of type­specifiers that designate them.

          41) This implies that unsigned arithmetic does not overflow because a result that cannot be represented by the resulting unsigned integer

          42) Using a bool value in ways described by this International Standard as '' undefined, '' such as by examining the value of an uninitialized automatic variable, might cause it to behave as if is neither truenor false.

          43) Therefore, enumerations (7.2) are not integral; however, enumerations can be promoted to int, unsigned int, long, or unsigned long, as specified in 4.5.

          44) A positional representation for integers that uses the binary digits 0 and 1, in which the values represented by successive bits are additive, begin with 1, and are multiplied by successive integral power of 2, except perhaps for the bit with the highest position. (Adapted from the American National Dictionary for Information Processing Systems.)

          45) Static class members are objects or functions, and pointers to them are ordinary pointers to objects or functions.

          46) The same representation and alignment requirements are meant to imply interchangeability as arguments to functions, return values from functions, and members of unions.

          47) Expressions such as invocations of constructors and of functions that return a class type refer to objects, and the implementation can
          invoke a member function upon such objects, but the expressions are not lvalues.

          48) The intent of this list is to specify those circumstances in which an object may or may not be aliased