-1- [Note: this clause presents the basic concepts of the C++ language. It explains the difference between an object and a name and how they relate to the notion of an lvalue. It introduces the concepts of a declaration and a definition and presents C++'s notion of type, scope, linkage, and storage duration. The mechanisms for starting and terminating a program are discussed. Finally, this clause presents the fundamental types of the language and lists the ways of constructing compound types from these.
-2- This clause does not cover concepts that affect only a single part of the language. Such concepts are discussed in the relevant clauses. ]
-3- An entity is a value, object, subobject, base class subobject, array element, variable, function, instance of a function, enumerator, type, class member, template, or namespace.
-4- A name is a use of an identifier (lex.name) that denotes an entity or label (stmt.goto, stmt.label). A variable is introduced by the declaration of an object. The variable's name denotes the object.
-5- Every name that denotes an entity is introduced by a declaration. Every name that denotes a label is introduced either by a goto statement (stmt.goto) or a labeled-statement (stmt.label).
-6- Some names denote types, classes, enumerations, or templates. In general, it is necessary to determine whether or not a name denotes one of these entities before parsing the program that contains it. The process that determines this is called name lookup (basic.lookup).
-7- Two names are the same if
-8-
An identifier used in more than one translation unit can potentially
refer to the same entity in these translation units
depending on the linkage (basic.link) of the identifier
specified in each translation unit.
3.1 - Declarations and definitions [basic.def]
-1- A declaration (clause dcl.dcl) introduces names into a translation unit or redeclares names introduced by previous declarations. A declaration specifies the interpretation and attributes of these names.
-2- A declaration is a definition unless it declares a function without specifying the function's body (dcl.fct.def), it contains the extern specifier (dcl.stc) or a linkage-specification*
[Footnote: Appearing inside the braced-enclosed declaration-seq in a linkage-specification does not affect whether a declaration is a definition. --- end foonote](dcl.link) and neither an initializer nor a function-body, it declares a static data member in a class declaration (class.static), it is a class name declaration (class.name), or it is a typedef declaration (dcl.typedef), a using-declaration (namespace.udecl), or a using-directive (namespace.udir).
-3- [Example: all but one of the following are definitions:
whereas these are just declarations:int a; //defines a extern const int c = 1; // defines c int f(int x) { return x+a; } // defines f and defines x struct S { int a; int b; }; // defines S, S::a, and S::b struct X { // defines X int x; // defines nonstatic data member x static int y; // declares static data member y X(): x(0) { } // defines a constructor of X }; int X::y = 1; // defines X::y enum { up, down }; // defines up and down namespace N { int d; } // defines N and N::d namespace N1 = N; // defines N1 X anX; // defines anX
extern int a; //declares a extern const int c; // declares c int f(int); // declares f struct S; // declares S typedef int Int; // declares Int extern X anotherX; // declares anotherX using N::d; // declares N::d
-4- [Note: in some circumstances, C++ implementations implicitly define the default constructor (class.ctor), copy constructor (class.copy), assignment operator (class.copy), or destructor (class.dtor) member functions. [Example: given
struct C {
string s; // string is the standard library class (clause lib.strings)
};
int main()
{
C a;
C b = a;
b = a;
}
struct C {
string s;
C(): s() { }
C(const C& x): s(x.s) { }
C& operator=(const C& x) { s = x.s; return *this; }
~C() { }
};
-5- [Note: a class name can also be implicitly declared by an elaborated-type-specifier (basic.scope.pdecl). ]
-6-
A program is ill-formed if the definition of any object gives
the object an incomplete type (basic.types).
3.2 - One definition rule [basic.def.odr]
-1- No translation unit shall contain more than one definition of any variable, function, class type, enumeration type or template.
-2- An expression is potentially evaluated unless either it is the operand of the sizeof operator (expr.sizeof), or it is the operand of the typeid operator and does not designate an lvalue of polymorphic class type (expr.typeid). An object or non-overloaded function is used if its name appears in a potentially-evaluated expression. A virtual member function is used if it is not pure. An overloaded function is used if it is selected by overload resolution when referred to from a potentially-evaluated expression. [Note: this covers calls to named functions (expr.call), operator overloading (clause over), user-defined conversions (class.conv.fct), allocation function for placement new (expr.new), as well as non-default initialization (dcl.init). A copy constructor is used even if the call is actually elided by the implementation. ] An allocation or deallocation function for a class is used by a new expression appearing in a potentially-evaluated expression as specified in expr.new and class.free. A deallocation function for a class is used by a delete expression appearing in a potentially-evaluated expression as specified in expr.delete and class.free. A copy-assignment function for a class is used by an implicitly-defined copy-assignment function for another class as specified in class.copy. A default constructor for a class is used by default initialization as specified in dcl.init. A constructor for a class is used as specified in dcl.init. A destructor for a class is used as specified in class.dtor.
-3- Every program shall contain exactly one definition of every non-inline function or object that is used in that program; no diagnostic required. The definition can appear explicitly in the program, it can be found in the standard or a user-defined library, or (when appropriate) it is implicitly defined (see class.ctor, class.dtor and class.copy). An inline function shall be defined in every translation unit in which it is used.
-4- Exactly one definition of a class is required in a translation unit if the class is used in a way that requires the class type to be complete. [Example: the following complete translation unit is well-formed, even though it never defines X:
struct X; //declare X as a struct type struct X* x1; // use X in pointer formation X* x2; // use X in pointer formation
-5- There can be more than one definition of a class type (clause class), enumeration type (dcl.enum), inline function with external linkage (dcl.fct.spec), class template (clause temp), non-static function template (temp.fct), static data member of a class template (temp.static), member function template (temp.mem.func), or template specialization for which some template parameters are not specified (temp.spec, temp.class.spec) in a program provided that each definition appears in a different translation unit, and provided the definitions satisfy the following requirements. Given such an entity named D defined in more than one translation unit, then
[Footnote: dcl.fct.default describes how default argument names are looked up. --- end foonote]
//translation unit 1: struct X { X(int); X(int, int); }; X::X(int = 0) { } class D: public X { }; D d2; // X(int) called by D() // translation unit 2: struct X { X(int); X(int, int); }; X::X(int = 0, int = 0) { } class D: public X { }; // X(int, int) called by D(); // D()'s implicit definition // violates the ODR
-1-
Every name is introduced in some portion of program text
called a
declarative region,
which is the largest part of the program in which that name is
valid,
that is, in which that name may be used as an unqualified name to
refer to the same entity.
In general, each particular name is valid only within
some possibly discontiguous portion of program text called its
scope.
To determine the scope of a declaration, it is sometimes convenient
to refer to the
potential scope
of a declaration.
The scope of a declaration is the same as its potential scope
unless the potential scope contains another declaration of the same
name.
In that case, the potential scope of the declaration in
the inner (contained) declarative region
is excluded from the scope of the declaration in the outer (containing)
declarative region.
-2- [Example: in
int j = 24;
int main()
{
int i = j, j;
j = 42;
}
-3- The names declared by a declaration are introduced into the scope in which the declaration occurs, except that the presence of a friend specifier (class.friend), certain uses of the elaborated-type-specifier (basic.scope.pdecl), and using-directives (namespace.udir) alter this general behavior.
-4- Given a set of declarations in a single declarative region, each of which specifies the same unqualified name,
-5-
[Note:
the name lookup rules are summarized in basic.lookup.
]
3.3.1 - Point of declaration [basic.scope.pdecl]
-1- The point of declaration for a name is immediately after its complete declarator (clause dcl.decl) and before its initializer (if any), except as noted below. [Example:
int x = 12;
{ int x = x; }
-2- [Note: a nonlocal name remains visible up to the point of declaration of the local name that hides it. [Example:
const int i = 2;
{ int i[i]; }
-3- The point of declaration for an enumerator is immediately after its enumerator-definition. [Example:
const int x = 12;
{ enum { x = x }; }
-4- After the point of declaration of a class member, the member name can be looked up in the scope of its class. [Note: this is true even if the class is an incomplete class. For example,
struct X {
enum E { z = 16 };
int b[X::z]; // OK
};
-5- The point of declaration of a class first declared in an elaborated-type-specifier is as follows:
the elaborated-type-specifier declares the identifier to be a class-name in the scope that contains the declaration, otherwiseclass-key identifier ;
if the elaborated-type-specifier is used in the decl-specifier-seq or parameter-declaration-clause of a function defined in namespace scope, the identifier is declared as a class-name in the namespace that contains the declaration; otherwise, except as a friend declaration, the identifier is declared in the smallest non-class, non-function-prototype scope that contains the declaration. [Note: if the elaborated-type-specifier designates an enumeration, the identifier must refer to an already declared enum-name. If the identifier in the elaborated-type-specifier is a qualified-id, it must refer to an already declared class-name or enum-name. See basic.lookup.elab. ]class-key identifier
-6- [Note: friend declarations refer to functions or classes that are members of the nearest enclosing namespace, but they do not introduce new names into that namespace (namespace.memdef). Function declarations at block scope and object declarations with the extern specifier at block scope refer to delarations that are members of an enclosing namespace, but they do not introduce new names into that scope. ]
-7-
[Note:
For point of instantiation of a template, see temp.inst.
]
3.3.2 - Local scope [basic.scope.local]
-1- A name declared in a block (stmt.block) is local to that block. Its potential scope begins at its point of declaration (basic.scope.pdecl) and ends at the end of its declarative region.
-2- The potential scope of a function parameter name in a function definition (dcl.fct.def) begins at its point of declaration. If the function has a function try-block the potential scope of a parameter ends at the end of the last associated handler, else it ends at the end of the outermost block of the function definition. A parameter name shall not be redeclared in the outermost block of the function definition nor in the outermost block of any handler associated with a function try-block .
-3- The name in a catch exception-declaration is local to the handler and shall not be redeclared in the outermost block of the handler.
-4-
Names declared in the
for-init-statement,
and in the
condition
of
if,
while,
for,
and
switch
statements are local to the
if,
while,
for,
or
switch
statement (including the controlled statement),
and shall not be redeclared in a subsequent condition
of that statement nor in the outermost block
(or, for the
if
statement, any of the outermost blocks)
of the controlled statement; see stmt.select.
3.3.3 - Function prototype scope [basic.scope.proto]
-1-
In a function declaration,
or in any function declarator except the declarator of a
function definition (dcl.fct.def), names of parameters (if supplied) have
function prototype scope,
which terminates at the end of the nearest enclosing function declarator.
3.3.4 - Function scope [basic.funscope]
-1-
Labels (stmt.label) have
function
scope
and may be used anywhere in the function in which they are declared.
Only labels have function scope.
3.3.5 - Namespace scope [basic.scope.namespace]
-1- The declarative region of a namespace-definition is its namespace-body. The potential scope denoted by an original-namespace-name is the concatenation of the declarative regions established by each of the namespace-definitions in the same declarative region with that original-namespace-name. Entities declared in a namespace-body are said to be members of the namespace, and names introduced by these declarations into the declarative region of the namespace are said to be member names of the namespace. A namespace member name has namespace scope. Its potential scope includes its namespace from the name's point of declaration (basic.scope.pdecl) onwards; and for each using-directive (namespace.udir) that nominates the member's namespace, the member's potential scope includes that portion of the potential scope of the using-directive that follows the member's point of declaration. [Example:
namespace N {
int i;
int g(int a) { return a; }
int j();
void q();
}
namespace { int l=1; }
// the potential scope of l is from its point of declaration
// to the end of the translation unit
namespace N {
int g(char a) // overloads N::g(int)
{
return l+a; // l is from unnamed namespace
}
int i; //error: duplicate definition int j(); // OK: duplicate function declaration
int j() //OK: definition of N::j() { return g(i); // calls N::g(int) } int q(); // error: different return type }
-2- A namespace member can also be referred to after the :: scope resolution operator (expr.prim) applied to the name of its namespace or the name of a namespace which nominates the member's namespace in a using-directive; see namespace.qual.
-3-
A name declared outside all named or unnamed namespaces (basic.namespace),
blocks (stmt.block), function declarations (dcl.fct), function
definitions (dcl.fct.def) and classes (clause class) has
global namespace scope
(also called
global scope).
The potential scope of such a name begins at its point of declaration
(basic.scope.pdecl) and ends at the end of the translation
unit that is its declarative region.
Names declared in the global namespace scope are said to be
global.
3.3.6 - Class scope [basic.scope.class]
-1- The following rules describe the scope of names declared in classes.
typedef int c;
enum { i = 1 };
class X {
char v[i]; // error: i refers to ::i
// but when reevaluated is X::i
int f() { return sizeof(c); } // OK: X::c
char c;
enum { i = 2 };
};
typedef char* T;
struct Y {
T a; // error: T refers to ::T
// but when reevaluated is Y::T
typedef long T;
T b;
};
typedef int I;
class D {
typedef I I; // error, even though no reordering involved
};
-2- The name of a class member shall only be used as follows:
-1- A name can be hidden by an explicit declaration of that same name in a nested declarative region or derived class (class.member.lookup).
-2- A class name (class.name) or enumeration name (dcl.enum) can be hidden by the name of an object, function, or enumerator declared in the same scope. If a class or enumeration name and an object, function, or enumerator are declared in the same scope (in any order) with the same name, the class or enumeration name is hidden wherever the object, function, or enumerator name is visible.
-3- In a member function definition, the declaration of a local name hides the declaration of a member of the class with the same name; see basic.scope.class. The declaration of a member in a derived class (clause class.derived) hides the declaration of a member of a base class of the same name; see class.member.lookup.
-4- During the lookup of a name qualified by a namespace name, declarations that would otherwise be made visible by a using-directive can be hidden by declarations with the same name in the namespace containing the using-directive; see (namespace.qual).
-5-
If a name is in scope and is not hidden it is said to be visible.
3.4 - Name lookup [basic.lookup]
-1- The name lookup rules apply uniformly to all names (including typedef-names (dcl.typedef), namespace-names (basic.namespace) and class-names (class.name)) wherever the grammar allows such names in the context discussed by a particular rule. Name lookup associates the use of a name with a declaration (basic.def) of that name. Name lookup shall find an unambiguous declaration for the name (see class.member.lookup). Name lookup may associate more than one declaration with a name if it finds the name to be a function name; the declarations are said to form a set of overloaded functions (over.load). Overload resolution (over.match) takes place after name lookup has succeeded. The access rules (clause class.access) are considered only once name lookup and function overload resolution (if applicable) have succeeded. Only after name lookup, function overload resolution (if applicable) and access checking have succeeded are the attributes introduced by the name's declaration used further in expression processing (clause expr).
-2- A name ``looked up in the context of an expression'' is looked up as an unqualified name in the scope where the expression is found.
-3- Because the name of a class is inserted in its class scope (clause class), the name of a class is also considered a member of that class for the purposes of name hiding and lookup.
-4-
[Note:
basic.link discusses linkage issues.
The notions of scope, point of declaration and name hiding are
discussed in basic.scope.
]
3.4.1 - Unqualified name lookup [basic.lookup.unqual]
-1- In all the cases listed in basic.lookup.unqual, the scopes are searched for a declaration in the order listed in each of the respective categories; name lookup ends as soon as a declaration is found for the name. If no declaration is found, the program is ill-formed.
-2- The declarations from the namespace nominated by a using-directive become visible in a namespace enclosing the using-directive; see namespace.udir. For the purpose of the unqualified name lookup rules described in basic.lookup.unqual, the declarations from the namespace nominated by the using-directive are considered members of that enclosing namespace.
-3- The lookup for an unqualified name used as the postfix-expression of a function call is described in basic.lookup.koenig. [Note: for purposes of determining (during parsing) whether an expression is a postfix-expression for a function call, the usual name lookup rules apply. The rules in basic.lookup.koenig have no effect on the syntactic interpretation of an expression. For example,
typedef int f;
struct A {
friend void f(A &);
operator int();
void g(A a) {
f(a);
}
};
-4- A name used in global scope, outside of any function, class or user-declared namespace, shall be declared before its use in global scope.
-5- A name used in a user-declared namespace outside of the definition of any function or class shall be declared before its use in that namespace or before its use in a namespace enclosing its namespace.
-6- A name used in the definition of a function* that is a member of namespace
[Footnote: This refers to unqualified names following the function declarator; such a name may be used as a type or as a default argument name in the parameter-declaration-clause, or may be used in the function body. --- end foonote]N (where, only for the purpose of exposition, N could represent the global scope) shall be declared before its use in the block in which it is used or in one of its enclosing blocks (stmt.block) or, shall be declared before its use in namespace N or, if N is a nested namespace, shall be declared before its use in one of N's enclosing namespaces.
namespace A {
namespace N {
void f();
}
}
void A::N::f() {
i = 5;
// The following scopes are searched for a declaration of i:
// 1) outermost block scope of A::N::f, before the use of i
// 2) scope of namespace N
// 3) scope of namespace A
// 4) global scope, before the definition of A::N::f
}
-7- A name used in the definition of a class X outside of a member function body or nested class definition*
[Footnote: This refers to unqualified names following the class name; such a name may be used in the base-clause or may be used in the class definition. --- end foonote]shall be declared in one of the following ways:
[Footnote: This lookup applies whether the definition of X is nested within Y's definition or whether X's definition appears in a namespace scope enclosing Y's definition (class.nest). --- end foonote]
namespace M {
class B { };
}
namespace N {
class Y : public M::B {
class X {
int a[i];
};
};
}
//The following scopes are searched for a declaration of i: // 1) scope of class N::Y::X, before the use of i // 2) scope of class N::Y, before the definition of N::Y::X // 3) scope of N::Y's base class M::B // 4) scope of namespace N, before the definition of N::Y // 5) global scope, before the definition of N
-8- A name used in the definition of a function that is a member function (class.mfct)* of class
[Footnote: That is, an unqualified name following the function declarator; such a name may be used as a type or as a default argument name in the parameter-declaration-clause, or may be used in the function body, or, if the function is a constructor, may be used in the expression of a mem-initializer. --- end foonote]X shall be declared in one of the following ways:
[Footnote: This lookup applies whether the member function is defined within the definition of class X or whether the member function is defined in a namespace scope enclosing X's definition. --- end foonote]
class B { };
namespace M {
namespace N {
class X : public B {
void f();
};
}
}
void M::N::X::f() {
i = 16;
}
//The following scopes are searched for a declaration of i: // 1) outermost block scope of M::N::X::f, before the use of i // 2) scope of class M::N::X // 3) scope of M::N::X's base class B // 4) scope of namespace M::N // 5) scope of namespace M // 6) global scope, before the definition of M::N::X::f
-9- Name lookup for a name used in the definition of a friend function (class.friend) defined inline in the class granting friendship shall proceed as described for lookup in member function definitions. If the friend function is not defined in the class granting friendship, name lookup in the friend function definition shall proceed as described for lookup in namespace member function definitions.
-10- In a friend declaration naming a member function, a name used in the function declarator and not part of a template-argument in a template-id is first looked up in the scope of the member function's class. If it is not found, or if the name is part of a template-argument in a template-id, the look up is as described for unqualified names in the definition of the class granting friendship. [Example:
struct A {
typedef int AT;
void f1(AT);
void f2(float);
};
struct B {
typedef float BT;
friend void A::f1(AT); // parameter type is A::AT
friend void A::f2(BT); // parameter type is B::BT
};
-11- During the lookup for a name used as a default argument (dcl.fct.default) in a function parameter-declaration-clause or used in the expression of a mem-initializer for a constructor (class.base.init), the function parameter names are visible and hide the names of entities declared in the block, class or namespace scopes containing the function declaration. [Note: dcl.fct.default further describes the restrictions on the use of names in default arguments. class.base.init further describes the restrictions on the use of names in a ctor-initializer. ]
-12- A name used in the definition of a static data member of class X (class.static.data) (after the qualified-id of the static member) is looked up as if the name was used in a member function of X. [Note: class.static.data further describes the restrictions on the use of names in the definition of a static data member. ]
-13- A name used in the handler for a function-try-block (clause except) is looked up as if the name was used in the outermost block of the function definition. In particular, the function parameter names shall not be redeclared in the exception-declaration nor in the outermost block of a handler for the function-try-block. Names declared in the outermost block of the function definition are not found when looked up in the scope of a handler for the function-try-block. [Note: but function parameter names are found. ]
-14-
[Note:
the rules for name lookup in template definitions are described in temp.res.
]
3.4.2 - Argument-dependent name lookup [basic.lookup.koenig]
-1- When an unqualified name is used as the postfix-expression in a function call (expr.call), other namespaces not considered during the usual unqualified lookup (basic.lookup.unqual) may be searched, and namespace-scope friend function declarations (class.friend) not otherwise visible may be found. These modifications to the search depend on the types of the arguments (and for template template arguments, the namespace of the template argument).
-2- For each argument type T in the function call, there is a set of zero or more associated namespaces and a set of zero or more associated classes to be considered. The sets of namespaces and classes is determined entirely by the types of the function arguments (and the namespace of any template template argument). Typedef names and using-declarations used to specify the types do not contribute to this set. The sets of namespaces and classes are determined in the following way:
namespace NS {
class T { };
void f(T);
}
NS::T parm;
int main() {
f(parm); // OK: calls NS::f
}
-3- When considering an associated namespace, the lookup is the same as the lookup performed when the associated namespace is used as a qualifier (namespace.qual) except that:
-1- The name of a class or namespace member can be referred to after the :: scope resolution operator (expr.prim) applied to a nested-name-specifier that nominates its class or namespace. During the lookup for a name preceding the :: scope resolution operator, object, function, and enumerator names are ignored. If the name found is not a class-name (clause class) or namespace-name (namespace.def), the program is ill-formed. [Example:
class A {
public:
static int n;
};
int main()
{
int A;
A::n = 42; // OK
A b; // ill-formed: A does not name a type
}
-2- [Note: Multiply qualified names, such as N1::N2::N3::n, can be used to refer to members of nested classes (class.nest) or members of nested namespaces. ]
-3- In a declaration in which the declarator-id is a qualified-id, names used before the qualified-id being declared are looked up in the defining namespace scope; names following the qualified-id are looked up in the scope of the member's class or namespace. [Example:
class X { };
class C {
class X { };
static const int number = 50;
static X arr[number];
};
X C::arr[number]; // ill-formed:
// equivalent to: ::X C::arr[C::number];
// not to: C::X C::arr[C::number];
-4- A name prefixed by the unary scope operator :: (expr.prim) is looked up in global scope, in the translation unit where it is used. The name shall be declared in global namespace scope or shall be a name whose declaration is visible in global scope because of a using-directive (namespace.qual). The use of :: allows a global name to be referred to even if its identifier has been hidden (basic.scope.hiding).
-5- If a pseudo-destructor-name (expr.pseudo) contains a nested-name-specifier, the type-names are looked up as types in the scope designated by the nested-name-specifier. In a qualified-id of the form:
where the nested-name-specifier designates a namespace scope, and in a qualified-id of the form:::opt nested-name-specifier ~ class-name
the class-names are looked up as types in the scope designated by the nested-name-specifier. [Example:::opt nested-name-specifier class-name :: ~ class-name
struct C {
typedef int I;
};
typedef int I1, I2;
extern int* p;
extern int* q;
p->C::I::~I(); // I is looked up in the scope of C
q->I1::~I2(); // I2 is looked up in the scope of
// the postfix-expression
struct A {
~A();
};
typedef A AB;
int main()
{
AB *p;
p->AB::~AB(); // explicitly calls the destructor for A
}
-1- If the nested-name-specifier of a qualified-id nominates a class, the name specified after the nested-name-specifier is looked up in the scope of the class (class.member.lookup), except for the cases listed below. The name shall represent one or more members of that class or of one of its base classes (clause class.derived). [Note: a class member can be referred to using a qualified-id at any point in its potential scope (basic.scope.class). ] The exceptions to the name lookup rule above are the following:
-2-
A class member name hidden by a name in a nested declarative region
or by the name of a derived class member can still be found
if qualified by the name of its class followed by the
::
operator.
3.4.3.2 - Namespace members [namespace.qual]
-1- If the nested-name-specifier of a qualified-id nominates a namespace, the name specified after the nested-name-specifier is looked up in the scope of the namespace, except that the template-arguments of a template-id are looked up in the context in which the entire postfix-expression occurs.
-2- Given X::m (where X is a user-declared namespace), or given ::m (where X is the global namespace), let S be the set of all declarations of m in X and in the transitive closure of all namespaces nominated by using-directives in X and its used namespaces, except that using-directives are ignored in any namespace, including X, directly containing one or more declarations of m. No namespace is searched more than once in the lookup of a name. If S is the empty set, the program is ill-formed. Otherwise, if S has exactly one member, or if the context of the reference is a using-declaration (namespace.udecl), S is the required set of declarations of m. Otherwise if the use of m is not one that allows a unique declaration to be chosen from S, the program is ill-formed. [Example:
int x;
namespace Y {
void f(float);
void h(int);
}
namespace Z {
void h(double);
}
namespace A {
using namespace Y;
void f(int);
void g(int);
int i;
}
namespace B {
using namespace Z;
void f(char);
int i;
}
namespace AB {
using namespace A;
using namespace B;
void g();
}
void h()
{
AB::g(); // g is declared directly in AB,
// therefore S is { AB::g() } and AB::g() is chosen
AB::f(1); // f is not declared directly in AB so the rules are
// applied recursively to A and B;
// namespace Y is not searched and Y::f(float)
// is not considered;
// S is { A::f(int), B::f(char) } and overload
// resolution chooses A::f(int)
AB::f('c'); // as above but resolution chooses B::f(char)
AB::x++; // x is not declared directly in AB, and
// is not declared in A or B, so the rules are
// applied recursively to Y and Z,
// S is { } so the program is ill-formed
AB::i++; // i is not declared directly in AB so the rules are
// applied recursively to A and B,
// S is { A::i, B::i } so the use is ambiguous
// and the program is ill-formed
AB::h(16.8); // h is not declared directly in AB and
// not declared directly in A or B so the rules are
// applied recursively to Y and Z,
// S is { Y::h(int), Z::h(double) } and overload
// resolution chooses Z::h(double)
}
-3- The same declaration found more than once is not an ambiguity (because it is still a unique declaration). For example:
namespace A {
int a;
}
namespace B {
using namespace A;
}
namespace C {
using namespace A;
}
namespace BC {
using namespace B;
using namespace C;
}
void f()
{
BC::a++; // OK: S is { A::a, A::a }
}
namespace D {
using A::a;
}
namespace BD {
using namespace B;
using namespace D;
}
void g()
{
BD::a++; // OK: S is { A::a, A::a }
}
-4- Because each referenced namespace is searched at most once, the following is well-defined:
namespace B {
int b;
}
namespace A {
using namespace B;
int a;
}
namespace B {
using namespace A;
}
void f()
{
A::a++; // OK: a declared directly in A, S is { A::a }
B::a++; // OK: both A and B searched (once), S is { A::a }
A::b++; // OK: both A and B searched (once), S is { B::b }
B::b++; // OK: b declared directly in B, S is { B::b }
}
-5- During the lookup of a qualified namespace member name, if the lookup finds more than one declaration of the member, and if one declaration introduces a class name or enumeration name and the other declarations either introduce the same object, the same enumerator or a set of functions, the non-type name hides the class or enumeration name if and only if the declarations are from the same namespace; otherwise (the declarations are from different namespaces), the program is ill-formed. [Example:
namespace A {
struct x { };
int x;
int y;
}
namespace B {
struct y {};
}
namespace C {
using namespace A;
using namespace B;
int i = C::x; // OK, A::x (of type int)
int j = C::y; // ambiguous, A::y or B::y
}
-6- In a declaration for a namespace member in which the declarator-id is a qualified-id, given that the qualified-id for the namespace member has the form
the unqualified-id shall name a member of the namespace designated by the nested-name-specifier. [Example:nested-name-specifier unqualified-id
namespace A {
namespace B {
void f1(int);
}
using namespace B;
}
void A::f1(int) { } // ill-formed, f1 is not a member of A
namespace A {
namespace B {
void f1(int);
}
}
namespace C {
namespace D {
void f1(int);
}
}
using namespace A;
using namespace C::D;
void B::f1(int){} // OK, defines A::B::f1(int)
-1- An elaborated-type-specifier may be used to refer to a previously declared class-name or enum-name even though the name has been hidden by a non-type declaration (basic.scope.hiding). The class-name or enum-name in the elaborated-type-specifier may either be a simple identifer or be a qualified-id.
-2- If the name in the elaborated-type-specifier is a simple identifer, and unless the elaborated-type-specifier has the following form:
the identifier is looked up according to basic.lookup.unqual but ignoring any non-type names that have been declared. If this name lookup finds a typedef-name, the elaborated-type-specifier is ill-formed. If the elaborated-type-specifier refers to an enum-name and this lookup does not find a previously declared enum-name, the elaborated-type-specifier is ill-formed. If the elaborated-type-specifier refers to an class-name and this lookup does not find a previously declared class-name, or if the elaborated-type-specifier has the form:class-key identifier ;
the elaborated-type-specifier is a declaration that introduces the class-name as described in basic.scope.pdecl.class-key identifier ;
-3- If the name is a qualified-id, the name is looked up according its qualifications, as described in basic.lookup.qual, but ignoring any non-type names that have been declared. If this name lookup finds a typedef-name, the elaborated-type-specifier is ill-formed. If this name lookup does not find a previously declared class-name or enum-name, the elaborated-type-specifier is ill-formed. [Example:
struct Node {
struct Node* Next; // OK: Refers to Node at global scope
struct Data* Data; // OK: Declares type Data
// at global scope and member Data
};
struct Data {
struct Node* Node; // OK: Refers to Node at global scope
friend struct ::Glob; // error: Glob is not declared
// cannot introduce a qualified type (dcl.type.elab)
friend struct Glob; // OK: Refers to (as yet) undeclared Glob
// at global scope.
/* ... */
};
struct Base {
struct Data; // OK: Declares nested Data
struct ::Data* thatData; // OK: Refers to ::Data
struct Base::Data* thisData; // OK: Refers to nested Data
friend class ::Data; // OK: global Data is a friend
friend class Data; // OK: nested Data is a friend
struct Data { /* ... */ }; // Defines nested Data
struct Data; // OK: Redeclares nested Data
};
struct Data; //OK: Redeclares Data at global scope struct ::Data; // error: cannot introduce a qualified type (dcl.type.elab) struct Base::Data; // error: cannot introduce a qualified type (dcl.type.elab) struct Base::Datum; // error: Datum undefined struct Base::Data* pBase; // OK: refers to nested Data
-1- In a class member access expression (expr.ref), if the . or -> token is immediately followed by an identifier followed by a <, the identifier must be looked up to determine whether the < is the beginning of a template argument list (temp.names) or a less-than operator. The identifier is first looked up in the class of the object expression. If the identifier is not found, it is then looked up in the context of the entire postfix-expression and shall name a class or function template. If the lookup in the class of the object expression finds a template, the name is also looked up in the context of the entire postfix-expression and
-2- If the id-expression in a class member access (expr.ref) is an unqualified-id, and the type of the object expression is of a class type C (or of pointer to a class type C), the unqualified-id is looked up in the scope of class C. If the type of the object expression is of pointer to scalar type, the unqualified-id is looked up in the context of the complete postfix-expression.
-3- If the unqualified-id is ~type-name, and the type of the object expression is of a class type C (or of pointer to a class type C), the type-name is looked up in the context of the entire postfix-expression and in the scope of class C. The type-name shall refer to a class-name. If type-name is found in both contexts, the name shall refer to the same class type. If the type of the object expression is of scalar type, the type-name is looked up in the scope of the complete postfix-expression.
-4- If the id-expression in a class member access is a qualified-id of the form
the class-name-or-namespace-name following the . or -> operator is looked up both in the context of the entire postfix-expression and in the scope of the class of the object expression. If the name is found only in the scope of the class of the object expression, the name shall refer to a class-name. If the name is found only in the context of the entire postfix-expression, the name shall refer to a class-name or namespace-name. If the name is found in both contexts, the class-name-or-namespace-name shall refer to the same entity. [Note: the result of looking up the class-name-or-namespace-name is not required to be a unique base class of the class type of the object expression, as long as the entity or entities named by the qualified-id are members of the class type of the object expression and are not ambiguous according to class.member.lookup.class-name-or-namespace-name::...
struct A {
int a;
};
struct B: virtual A { };
struct C: B { };
struct D: B { };
struct E: public C, public D { };
struct F: public A { };
void f() {
E e;
e.B::a = 0; // OK, only one A::a in E
F f;
f.A::a = 1; // OK, A::a is a member of F
}
-5- If the qualified-id has the form
the class-name-or-namespace-name is looked up in global scope as a class-name or namespace-name.::class-name-or-namespace-name::...
-6- If the nested-name-specifier contains a class template-id (temp.names), its template-arguments are evaluated in the context in which the entire postfix-expression occurs.
-7-
If the
id-expression
is a
conversion-function-id,
its
conversion-type-id
shall denote the same type in both the context in
which the entire
postfix-expression
occurs and in the context of the class of the
object expression (or the class pointed to by the
pointer expression).
3.4.6 - Using-directives and namespace aliases [basic.lookup.udir]
-1-
When looking up a
namespace-name
in a
using-directive
or
namespace-alias-definition,
only namespace names are considered.
3.5 - Program and linkage [basic.link]
-1- A program consists of one or more translation units (clause lex) linked together. A translation unit consists of a sequence of declarations.
translation-unit:
declaration-seqopt
-2- 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:
-3- A name having namespace scope (basic.scope.namespace) has internal linkage if it is the name of
-4- A name having namespace scope has external linkage if it is the name of
-5- In addition, a member function, static data member, class or enumeration of class scope has external linkage if the name of the class has external linkage.
-6-
The name of a function declared in block scope, and the name of an object
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.
[Example:
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. ]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 } }
-7- 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
-8- Names not covered by these rules have no linkage. Moreover, except as noted, a name declared in a local scope (basic.scope.local) has no linkage. A name with no linkage (notably, the name of a class or enumeration declared in a local scope (basic.scope.local)) shall not be used to declare an entity with linkage. If a declaration uses a typedef name, it is the linkage of the type name to which the typedef refers that is considered. [Example:
void f()
{
struct A { int x; }; // no linkage
extern A a; // ill-formed
typedef A B;
extern B b; // ill-formed
}
-9- Two names that are the same (clause basic) and that are declared in different scopes shall denote the same object, reference, function, type, enumerator, template or namespace if
-10- After all adjustments of types (during which typedefs (dcl.typedef) are replaced by their definitions), the types specified by all declarations referring to a given object 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.
-11-
[Note:
linkage to non-C++ declarations can be achieved using a
linkage-specification
(dcl.link).
]
3.6 - Start and termination [basic.start]
3.6.1 - Main function [basic.start.main]
-1- A program shall contain a global function called main, which is the designated start of the program. It is implementation-defined whether a program in a freestanding environment is required to define a main function. [Note: in a freestanding environment, start-up and termination is implementation-defined; start-up contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration. ]
-2- An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main:
int main() { /* ... */ }
int main(int argc, char* argv[]) { /* ... */ }
-3- The function main shall not be used (basic.def.odr) within a program. The linkage (basic.link) of main is implementation-defined. A program that declares main to be inline or static is ill-formed. The name main is not otherwise reserved. [Example: member functions, classes, and enumerations can be called main, as can entities in other namespaces. ]
-4- Calling the function
declared in <cstdlib> (lib.support.start.term) terminates the program without leaving the current block and hence without destroying any objects with automatic storage duration (class.dtor). If exit is called to end a program during the destruction of an object with static storage duration, the program has undefined behavior.void exit(int);
-5- A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing
return 0;
-1- The storage for objects with static storage duration (basic.stc.static) shall be zero-initialized (dcl.init) before any other initialization takes place. Zero-initialization and initialization with a constant expression are collectively called static initialization; all other initialization is dynamic initialization. Objects of POD types (basic.types) with static storage duration initialized with constant expressions (expr.const) shall be initialized before any dynamic initialization takes place. Objects with static storage duration defined in namespace scope in the same translation unit and dynamically initialized shall be initialized in the order in which their definition appears in the translation unit. [Note: dcl.init.aggr describes the order in which aggregate members are initialized. The initialization of local static objects is described in stmt.dcl. ]
-2- An implementation is permitted to perform the initialization of an object of namespace scope with static storage duration as a static initialization even if such initialization is not required to be done statically, provided that
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
-3- It is implementation-defined whether or not the dynamic initialization (dcl.init, class.static, class.ctor, class.expl.init) 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.*
[Footnote: An object defined in namespace scope having initialization with side-effects must be initialized even if it is not used (basic.stc.static). --- end foonote][Example:
//- File 1 - #include "a.h" #include "b.h" B b; A::A(){ b.Use(); }
//- File 2 - #include "a.h" A a;
It is implementation-defined whether either a or b is initialized before main is entered or whether the initializations are delayed until a is first used in main. In particular, if a is initialized before main is entered, it is not guaranteed that b will be initialized before it is used by the initialization of a, that is, before A::A is called. If, however, a is initialized at some point after the first statement of main, b will be initialized prior to its use in A::A. ]//- File 3 - #include "a.h" #include "b.h" extern A a; extern B b; int main() { a.Use(); b.Use(); }
-4-
If construction or destruction of a non-local static object
ends in throwing an uncaught exception, the result is to call
terminate
(lib.terminate).
3.6.3 - Termination [basic.start.term]
-1- Destructors (class.dtor) for initialized objects of static storage duration (declared at block scope or at namespace scope) are called as a result of returning from main and as a result of calling exit (lib.support.start.term). These objects are destroyed in the reverse order of the completion of their constructor or of the completion of their dynamic initialization. If an object is initialized statically, the object is destroyed in the same order as if the object was dynamically initialized. For an object of array or class type, all subobjects of that object are destroyed before any local object with static storage duration initialized during the construction of the subobjects is destroyed.
-2- If a function contains a local object of static storage duration that has been destroyed and the function is called during the destruction of an object with static storage duration, the program has undefined behavior if the flow of control passes through the definition of the previously destroyed local object.
-3- If a function is registered with atexit (see <cstdlib>, lib.support.start.term) then following the call to exit, any objects with static storage duration initialized prior to the registration of that function shall not be destroyed until the registered function is called from the termination process and has completed. For an object with static storage duration constructed after a function is registered with atexit, then following the call to exit, the registered function is not called until the execution of the object's destructor has completed. If atexit is called during the construction of an object, the complete object to which it belongs shall be destroyed before the registered function is called.
-4- Calling the function
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().void abort();
-1- Storage duration is the property of an object that defines the minimum potential lifetime of the storage containing the object. The storage duration is determined by the construct used to create the object and is one of the following:
-2- Static and automatic storage durations are associated with objects introduced by declarations (basic.def) and implicitly created by the implementation (class.temporary). The dynamic storage duration is associated with objects created with operator new (expr.new).
-3- The storage class specifiers static and auto are related to storage duration as described below.
-4-
The storage duration categories apply to references as well.
The
lifetime of a reference is its storage duration.
3.7.1 - Static storage duration [basic.stc.static]
-1- All objects which neither have dynamic storage duration nor are local have static storage duration. The storage for these objects shall last for the duration of the program (basic.start.init, basic.start.term).
-2- If an object of static storage duration has initialization or a destructor with side effects, it shall not be eliminated even if it appears to be unused, except that a class object or its copy may be eliminated as specified in class.copy.
-3- The keyword static can be used to declare a local variable with static storage duration. [Note: stmt.dcl describes the initialization of local static variables; basic.start.term describes the destruction of local static variables. ]
-4-
The keyword
static
applied to a class data member in a class definition
gives the data member static storage duration.
3.7.2 - Automatic storage duration [basic.stc.auto]
-1- Local objects explicitly declared auto or register or not explicitly declared static or extern have automatic storage duration. The storage for these objects lasts until the block in which they are created exits.
-2- [Note: these objects are initialized and destroyed as described in stmt.dcl. ]
-3-
If a named automatic object has initialization or a destructor with side
effects, it shall not be destroyed before the end of its block, nor shall it
be eliminated as an optimization even if it appears to be unused,
except that a class object or its copy may be eliminated as specified in
class.copy.
3.7.3 - Dynamic storage duration [basic.stc.dynamic]
-1- Objects can be created dynamically during program execution (intro.execution), using new-expressions (expr.new), and destroyed using delete-expressions (expr.delete). A C++ implementation provides access to, and management of, dynamic storage via the global allocation functions operator new and operator new[] and the global deallocation functions operator delete and operator delete[].
-2- The library provides default definitions for the global allocation and deallocation functions. Some global allocation and deallocation functions are replaceable (lib.new.delete). A C++ program shall provide at most one definition of a replaceable allocation or deallocation function. Any such function definition replaces the default version provided in the library (lib.replacement.functions). The following allocation and deallocation functions (lib.support.dynamic) are implicitly declared in global scope in each translation unit of a program
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 (class.free).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();
-3-
Any allocation and/or deallocation functions defined in a C++ program shall conform
to the semantics specified in basic.stc.dynamic.allocation and basic.stc.dynamic.deallocation.
3.7.3.1 - Allocation functions [basic.stc.dynamic.allocation]
-1- An allocation function shall be a class member function or a global function; a program is ill-formed if an allocation function is declared in a namespace scope other than global scope or declared static in global scope. The return type shall be void*. The first parameter shall have type size_t (lib.support.types). The first parameter shall not have an associated default argument (dcl.fct.default). The value of the first parameter shall be interpreted as the requested size of the allocation. An allocation function can be a function template. Such a template shall declare its return type and first parameter as specified above (that is, template parameter types shall not be used in the return type and first parameter type). Template allocation functions shall have two or more parameters.
-2- The allocation function attempts to allocate the requested amount of storage. If it is successful, it shall return the address of the start of a block of storage whose length in bytes shall be at least as large as the requested size. There are no constraints on the contents of the allocated storage on return from the allocation function. The order, contiguity, and initial value of storage allocated by successive calls to an allocation function is unspecified. The pointer returned shall be suitably aligned so that it can be converted to a pointer of any complete object type and then used to access the object or array in the storage allocated (until the storage is explicitly deallocated by a call to a corresponding deallocation function). If the size of the space requested is zero, the value returned shall not be a null pointer value (conv.ptr). The results of dereferencing a pointer returned as a request for zero size are undefined.*
[Footnote: 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. --- end foonote]
-3- An allocation function that fails to allocate storage can invoke the currently installed new_handler (lib.new.handler), if any. [Note: A program-supplied allocation function can obtain the address of the currently installed new_handler using the set_new_handler function (lib.set.new.handler). ] If an allocation function declared with an empty exception-specification (except.spec), throw(), fails to allocate storage, it shall return a null pointer. Any other allocation function that fails to allocate storage shall only indicate failure by throwing an exception of class std::bad_alloc (lib.bad.alloc) or a class derived from std::bad_alloc.
-4-
A global allocation function is only called as the result of a new
expression (expr.new), or called directly using the function call syntax
(expr.call), or called indirectly through calls to the functions in the
C++ standard library.
[Note:
in particular, a global allocation function is not called to allocate
storage for objects with static storage duration (basic.stc.static),
for objects of type
type_info
(expr.typeid),
for the copy of an object thrown by a
throw
expression (except.throw).
]
3.7.3.2 - Deallocation functions [basic.stc.dynamic.deallocation]
-1- Deallocation functions shall be class member functions or global functions; a program is ill-formed if deallocation functions are declared in a namespace scope other than global scope or declared static in global scope.
-2- Each deallocation function shall return void and its first parameter shall be void*. A deallocation function can have more than one parameter. If a class T has a member deallocation function named operator delete with exactly one parameter, then that function is a usual (non-placement) deallocation function. If class T does not declare such an operator delete but does declare a member deallocation function named operator delete with exactly two parameters, the second of which has type std::size_t (lib.support.types), then this function is a usual deallocation function. Similarly, if a class T has a member deallocation function named operator delete[] with exactly one parameter, then that function is a usual (non-placement) deallocation function. If class T does not declare such an operator delete[] but does declare a member deallocation function named operator delete[] with exactly two parameters, the second of which has type std::size_t, then this function is a usual deallocation function. A deallocation function can be an instance of a function template. Neither the first parameter nor the return type shall depend on a template parameter. [Note: that is, a deallocation function template shall have a first parameter of type void* and a return type of void (as specified above). ] A deallocation function template shall have two or more function parameters. A template instance is never a usual deallocation function, regardless of its signature.
-3- The value of the first argument supplied to one of the deallocation functions provided in the standard library may be a null pointer value; if so, the call to the deallocation function has no effect. Otherwise, the value supplied to operator delete(void*) in the standard library shall be one of the values returned by a previous invocation of either operator new(size_t) or operator new(size_t, const std::nothrow_t&) in the standard library, and the value supplied to operator delete[](void*) in the standard library shall be one of the values returned by a previous invocation of either operator new[](size_t) or operator new[](size_t, const std::nothrow_t&) in the standard library.
-4- If the argument given to a deallocation function in the standard library is a pointer that is not the null pointer value (conv.ptr), the deallocation function shall deallocate the storage referenced by the pointer, rendering invalid all pointers referring to any part of the deallocated storage. The effect of using an invalid pointer value (including passing it to a deallocation function) is undefined.*
[Footnote: On some implementations, it causes a system-generated runtime fault. --- end foonote]
-1-
The storage duration of member subobjects, base class subobjects and
array elements is that of their complete object (intro.object).
3.8 - Object Lifetime [basic.life]
-1- The lifetime of an object is a runtime property of the object. The lifetime of an object of type T begins when:
-2- [Note: the lifetime of an array object or of an object of type (basic.types) starts as soon as storage with proper size and alignment is obtained, and its lifetime ends when the storage which the array or object occupies is reused or released. class.base.init describes the lifetime of base and member subobjects. ]
-3- The properties ascribed to objects throughout this International Standard apply for a given object only during its lifetime. [Note: in particular, before the lifetime of an object starts and after its lifetime ends there are significant restrictions on the use of the object, as described below, in class.base.init and in class.cdtor. Also, the behavior of an object under construction and destruction might not be the same as the behavior of an object whose lifetime has started and not ended. class.base.init and class.cdtor describe the behavior of objects during the construction and destruction phases. ]
-4- A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor, the program is not required to call the destructor explicitly before the storage which the object occupies is reused or released; however, if there is no explicit call to the destructor or if a delete-expression (expr.delete) is not used to release the storage, the destructor shall not be implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior.
-5- Before the lifetime of an object has started but after the storage which the object will occupy has been allocated*
[Footnote: For example, before the construction of a global object of non-POD class type (class.cdtor). --- end foonote]or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that refers to the storage location where the object will be or was located may be used but only in limited ways. Such a pointer refers to allocated storage (basic.stc.dynamic.deallocation), and using the pointer as if the pointer were of type void*, is well-defined. Such a pointer may be dereferenced but the resulting lvalue may only be used in limited ways, as described below. If the object will be or was of a class type with a non-trivial destructor, and the pointer is used as the operand of a delete-expression, the program has undefined behavior. If the object will be or was of a non-POD class type, the program has undefined behavior if:
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
}
-6- Similarly, before the lifetime of an object has started but after the storage which the object will occupy has been allocated or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any lvalue which refers to the original object may be used but only in limited ways. Such an lvalue refers to allocated storage (basic.stc.dynamic.deallocation), and using the properties of the lvalue which do not depend on its value is well-defined. If an lvalue-to-rvalue conversion (conv.lval) is applied to such an lvalue, the program has undefined behavior; if the original object will be or was of a non-POD class type, the program has undefined behavior if:
-7- If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at the storage location which the original object occupied, a pointer that pointed to the original object, a reference that referred to the original object, or the name of the original object will automatically refer to the new object and, once the lifetime of the new object has started, can be used to manipulate the new object, if:
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
-8- If a program ends the lifetime of an object of type T with static (basic.stc.static) or automatic (basic.stc.auto) storage duration and if T has a non-trivial destructor,*
[Footnote: 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. --- end foonote]the program must ensure that an object of the original type occupies that same storage location when the implicit destructor call takes place; otherwise the behavior of the program is undefined. This is true even if the block is exited with an exception. [Example:
class T { };
struct B {
~B();
};
void h() {
B b;
new (&b) T;
} // undefined behavior at block exit
-9- Creating a new object at the storage location that a const object with static or automatic storage duration occupies or, at the storage location that such a const object used to occupy before its lifetime ended results in undefined behavior. [Example:
struct B {
B();
~B();
};
const B b;
void h() {
b.~B();
new (&b) const B; // undefined behavior
}
-1- [Note: basic.types and the subclauses thereof impose requirements on implementations regarding the representation of types. There are two kinds of types: fundamental types and compound types. Types describe objects (intro.object), references (dcl.ref), or functions (dcl.fct). ]
-2- For any complete POD object type T, whether or not the object holds a valid value of type T, the underlying bytes (intro.memory) making up the object can be copied into an array of char or unsigned char.*
[Footnote: By using, for example, the library functions (lib.headers) memcpy or memmove. --- end foonote]If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value. [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
-3- For any POD type T, if two pointers to T point to distinct T objects obj1 and obj2, if the value of obj1 is copied into obj2, using the memcpy library function, obj2 shall subsequently hold the same value as obj1. [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
-4- The object representation of an object of type T is the sequence of N unsigned char objects taken up by the object of type T, where N equals sizeof(T). The value representation of an object is the set of bits that hold the value of type T. For POD types, the value representation is a set of bits in the object representation that determines a value, which is one discrete element of an implementation-defined set of values.*
[Footnote: The intent is that the memory model of C++ is compatible with that of ISO/IEC 9899 Programming Language C. --- end foonote]
-5- Object types have alignment requirements (basic.fundamental, basic.compound). The alignment of a complete object type is an implementation-defined integer value representing a number of bytes; an object is allocated at an address that meets the alignment requirements of its object type.
-6- A class that has been declared but not defined, or an array of unknown size or of incomplete element type, is an incompletely-defined object type.*
[Footnote: The size and layout of an instance of an incompletely-defined object type is unknown. --- end foonote]Incompletely-defined object types and the void types are incomplete types (basic.fundamental). Objects shall not be defined to have an incomplete type.
-7- A class type (such as ``class X'') might be incomplete at one point in a translation unit and complete later on; the type ``class X'' is the same type at both points. The declared type of an array object might be an array of incomplete class type and therefore incomplete; if the class type is completed later on in the translation unit, the array type becomes complete; the array type at those two points is the same type. The declared type of an array object might be an array of unknown size and therefore be incomplete at one point in a translation unit and complete later on; the array types at those two points (``array of unknown bound of T'' and ``array of N T'') are different types. The type of a pointer to array of unknown size, or of a type defined by a typedef declaration to be an array of unknown size, cannot be completed. [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
}
-8- [Note: the rules for declarations and expressions describe in which contexts incomplete types are prohibited. ]
-9- An object type is a (possibly cv-qualified) type that is not a function type, not a reference type, and not a void type.
-10- Arithmetic types (basic.fundamental), enumeration types, pointer types, and pointer to member types (basic.compound), and cv-qualified versions of these types (basic.type.qualifier) are collectively called scalar types. Scalar types, POD-struct types, POD-union types (clause class), arrays of such types and cv-qualified versions of these types (basic.type.qualifier) are collectively called POD types.
-11-
If two types
T1
and
T2
are the same type, then
T1
and
T2
are
layout-compatible
types.
[Note:
Layout-compatible enumerations are described in dcl.enum.
Layout-compatible POD-structs and POD-unions are described in class.mem.
]
3.9.1 - Fundamental types [basic.fundamental]
-1- Objects declared as characters (char) shall be large enough to store any member of the implementation's basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value of the single character literal form of that character. It is implementation-defined whether a char object can hold negative values. Characters can be explicitly declared unsigned or signed. Plain char, signed char, and unsigned char are three distinct types. A char, a signed char, and an unsigned char occupy the same amount of storage and have the same alignment requirements (basic.types); that is, they have the same object representation. For character types, all bits of the object representation participate in the value representation. For unsigned character types, all possible bit patterns of the value representation represent numbers. These requirements do not hold for other types. In any particular implementation, a plain char object can take on either the same values as a signed char or an unsigned char; which one is implementation-defined.
-2- There are four signed integer types: ``signed char'', ``short int'', ``int'', and ``long int.'' In this list, each type provides at least as much storage as those preceding it in the list. Plain ints have the natural size suggested by the architecture of the execution environment* ;
[Footnote: that is, large enough to contain any value in the range of INT_MIN and INT_MAX, as defined in the header <climits>. --- end foonote]the other signed integer types are provided to meet special needs.
-3- For each of the signed integer types, there exists a corresponding (but different) unsigned integer type: ``unsigned char'', ``unsigned short int'', ``unsigned int'', and ``unsigned long int,'' each of which occupies the same amount of storage and has the same alignment requirements (basic.types) as the corresponding signed integer type* ;
[Footnote: See dcl.type.simple regarding the correspondence between types and the sequences of type-specifiers that designate them. --- end foonote]that is, each signed integer type has the same object representation as its corresponding unsigned integer type. The range of nonnegative values of a signed integer type is a subrange of the corresponding unsigned integer type, and the value representation of each corresponding signed/unsigned type shall be the same.
-4-
Unsigned integers, declared unsigned, shall obey the laws of arithmetic modulo 2n where n is the number of bits in the value representation of that particular size of integer.*
[Footnote: This implies that unsigned arithmetic does not overflow because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting unsigned integer type. --- end foonote]
-5- Type wchar_t is a distinct type whose values can represent distinct codes for all members of the largest extended character set specified among the supported locales (lib.locale). Type wchar_t shall have the same size, signedness, and alignment requirements (basic.types) as one of the other integral types, called its underlying type.
-6- Values of type bool are either true or false.*
[Footnote: 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 true nor false. --- end foonote][Note: there are no signed, unsigned, short, or long bool types or values. ] As described below, bool values behave as integral types. Values of type bool participate in integral promotions (conv.prom).
-7- Types bool, char, wchar_t, and the signed and unsigned integer types are collectively called integral types.*
[Footnote: Therefore, enumerations (dcl.enum) are not integral; however, enumerations can be promoted to int, unsigned int, long, or unsigned long, as specified in conv.prom. --- end foonote]A synonym for integral type is integer type. The representations of integral types shall define values by use of a pure binary numeration system.*
[Footnote: 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.) --- end foonote][Example: this International Standard permits 2's complement, 1's complement and signed magnitude representations for integral types. ]
-8- There are three floating point types: float, double, and long double. The type double provides at least as much precision as float, and the type long double provides at least as much precision as double. The set of values of the type float is a subset of the set of values of the type double; the set of values of the type double is a subset of the set of values of the type long double. The value representation of floating-point types is implementation-defined. Integral and floating types are collectively called arithmetic types. Specializations of the standard template numeric_limits (lib.support.limits) shall specify the maximum and minimum values of each arithmetic type for an implementation.
-9- The void type has an empty set of values. The void type is an incomplete type that cannot be completed. It is used as the return type for functions that do not return a value. Any expression can be explicitly converted to type cv void (expr.cast). An expression of type void shall be used only as an expression statement (stmt.expr), as an operand of a comma expression (expr.comma), as a second or third operand of ?: (expr.cond), as the operand of typeid, or as the expression in a return statement (stmt.return) for a function with the return type void.
-10-
[Note:
even if the implementation defines two or more basic types to have the same
value representation, they are nevertheless different types.
]
3.9.2 - Compound types [basic.compound]
-1- Compound types can be constructed in the following ways:
[Footnote: Static class members are objects or functions, and pointers to them are ordinary pointers to objects or functions. --- end foonote]class members, which identify members of a given type within objects of a given class, dcl.mptr.
-2- These methods of constructing types can be applied recursively; restrictions are mentioned in dcl.ptr, dcl.array, dcl.fct, and dcl.ref.
-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 (basic.types). The value representation of pointer types is implementation-defined. Pointers to cv-qualified and cv-unqualified versions (basic.type.qualifier) of layout-compatible types shall have the same value representation and alignment requirements (basic.types).
-4-
Objects of cv-qualified (basic.type.qualifier) 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 (basic.type.qualifier)
void*
shall have the same representation and alignment requirements as a cv-qualified or
cv-unqualified
char*.
3.9.3 - CV-qualifiers [basic.type.qualifier]
-1- A type mentioned in basic.fundamental and basic.compound is a cv-unqualified type. Each type which is a cv-unqualified complete or incomplete object type or is void (basic.types) has three corresponding cv-qualified versions of its type: a const-qualified version, a volatile-qualified version, and a const-volatile-qualified version. The term object type (intro.object) 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 (basic.types).*
[Footnote: The same representation and alignment requirements are meant to imply interchangeability as arguments to functions, return values from functions, and members of unions. --- end foonote]
-2- A compound type (basic.compound) 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 (dcl.array).
-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 dcl.fct and class.this 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 ?? shows the relations that constitute this ordering.
| 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 element 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 class type --- also refer to objects.*
[Footnote: 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. --- end foonote]
-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
yields an lvalue, so the call f() is an lvalue expression. ] ]int& f();
-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 expr indicates whether it expects lvalue operands and whether it yields an lvalue. ]
-5- 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.
-6- 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 (expr.type.conv)).
-7- Whenever an lvalue appears in a context where an rvalue is expected, the lvalue is converted to an rvalue; see conv.lval, conv.array, and conv.func.
-8- The discussion of reference initialization in dcl.init.ref and of temporaries in class.temporary indicates the behavior of lvalues and rvalues in other significant contexts.
-9- 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.
-10- 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 (class.mfct) can modify the object. ]
-11- Functions cannot be modified, but pointers to functions can be modifiable.
-12- 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.
-13- 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 (dcl.type.cv).
-14- 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.
-15- If a program attempts to access the stored value of an object through an lvalue of other than one of the following types the behavior is undefined*:
[Footnote: The intent of this list is to specify those circumstances in which an object may or may not be aliased. --- end foonote]