______________________________________________________________________
7 Declarations [dcl.dcl]
______________________________________________________________________
1 Declarations specify how names are to be interpreted. Declarations
have the form
declaration-seq:
declaration
declaration-seq declaration
declaration:
block-declaration
function-definition
template-declaration
linkage-specification
namespace-definition
block-declaration:
simple-declaration
asm-definition
namespace-alias-definition
using-declaration
using-directive
simple-declaration:
decl-specifier-seqopt init-declarator-listopt ;
[Note: asm-definitions are described in _dcl.asm_, and linkage-speci
fications are described in _dcl.link_. Function-definitions are
described in _dcl.fct.def_ and template-declarations are described in
_temp_. Namespace-definitions are described in _namespace.def_,
using-declarations are described in _namespace.udecl_ and using-direc
tives are described in _namespace.udir_. ] The simple-declaration
decl-specifier-seqopt init-declarator-listopt ;
is divided into two parts: decl-specifiers, the components of a decl-
specifier-seq, are described in _dcl.spec_ and declarators, the compo
nents of an init-declarator-list, are described in _dcl.decl_.
2 A declaration occurs in a scope (_basic.scope_); the scope rules are
summarized in _basic.lookup_. A declaration that declares a function
or defines a class, namespace, template, or function also has one or
more scopes nested within it. These nested scopes, in turn, can have
declarations nested within them. Unless otherwise stated, utterances
in this clause about components in, of, or contained by a declaration
or subcomponent thereof refer only to those components of the declara
tion that are not nested within scopes nested within the declaration.
3 In a simple-declaration, the optional init-declarator-list can be
omitted only when declaring a class (_class_) or enumeration
(_dcl.enum_), that is, when the decl-specifier-seq contains either a
class-specifier, an elaborated-type-specifier with a class-key
(_class.name_), or an enum-specifier. In these cases and whenever a
class-specifier or enum-specifier is present in the decl-specifier-
seq, the identifiers in these specifiers are among the names being
declared by the declaration (as class-names, enum-names, or enumera
tors, depending on the syntax). In such cases, and except for the
declaration of an unnamed bit-field (_class.bit_), the decl-specified-
seq shall introduce one or more names into the program, or shall rede
clare a name introduced by a previous declaration. [Example:
enum { }; // ill-formed
typedef class { }; // ill-formed
--end example]
4 Each init-declarator in the init-declarator-list contains exactly one
declarator-id, which is the name declared by that init-declarator and
hence one of the names declared by the declaration. The type-speci
fiers (_dcl.type_) in the decl-specifier-seq and the recursive
declarator structure of the init-declarator describe a type
(_dcl.meaning_), which is then associated with the name being declared
by the init-declarator.
5 If the decl-specifier-seq contains the typedef specifier, the declara
tion is called a typedef declaration and the name of each init-
declarator is declared to be a typedef-name, synonymous with its asso
ciated type (_dcl.typedef_). If the decl-specifier-seq contains no
typedef specifier, the declaration is called a function declaration if
the type associated with the name is a function type (_dcl.fct_) and
an object declaration otherwise.
6 Syntactic components beyond those found in the general form of decla
ration are added to a function declaration to make a function-defini
tion. An object declaration, however, is also a definition unless it
contains the extern specifier and has no initializer (_basic.def_). A
definition causes the appropriate amount of storage to be reserved and
any appropriate initialization (_dcl.init_) to be done.
7 Only in function declarations for constructors, destructors, and type
conversions can the decl-specifier-seq be omitted.1)
7.1 Specifiers [dcl.spec]
1 The specifiers that can be used in a declaration are
decl-specifier:
storage-class-specifier
type-specifier
function-specifier
friend
typedef
decl-specifier-seq:
decl-specifier-seqopt decl-specifier
_________________________
1) The "implicit int" rule of C is no longer supported.
2 The longest sequence of decl-specifiers that could possibly be a type
name is taken as the decl-specifier-seq of a declaration. The
sequence shall be self-consistent as described below. [Example:
typedef char* Pc;
static Pc; // error: name missing
Here, the declaration static Pc is ill-formed because no name was
specified for the static variable of type Pc. To get a variable
called Pc, a type-specifier (other than const or volatile) has to be
present to indicate that the typedef-name Pc is the name being
(re)declared, rather than being part of the decl-specifier sequence.
For another example,
void f(const Pc); // void f(char* const) (not const char*)
void g(const int Pc); // void g(const int)
--end example]
3 [Note: since signed, unsigned, long, and short by default imply int, a
type-name appearing after one of those specifiers is treated as the
name being (re)declared. [Example:
void h(unsigned Pc); // void h(unsigned int)
void k(unsigned int Pc); // void k(unsigned int)
--end example] --end note]
7.1.1 Storage class specifiers [dcl.stc]
1 The storage class specifiers are
storage-class-specifier:
auto
register
static
extern
mutable
At most one storage-class-specifier shall appear in a given decl-spec
ifier-seq. If a storage-class-specifier appears in a decl-specifier-
seq, there can be no typedef specifier in the same decl-specifier-seq
and the init-declarator-list of the declaration shall not be empty
(except for global anonymous unions, which shall be declared static
(_class.union_). The storage-class-specifier applies to the name
declared by each init-declarator in the list and not to any names
declared by other specifiers. A storage-class-specifier shall not be
specified in an explicit specialization (_temp.expl.spec_) or an
explicit instantiation (_temp.explicit_) directive.
2 The auto or register specifiers can be applied only to names of
objects declared in a block (_stmt.block_) or to function parameters
(_dcl.fct.def_). They specify that the named object has automatic
storage duration (_basic.stc.auto_). An object declared without a
storage-class-specifier at block scope or declared as a function
parameter has automatic storage duration by default. Hence, the auto
specifier is almost always redundant and not often used; one use of
auto is to distinguish a declaration-statement from an expression-
statement (_stmt.expr_) explicitly.
3 A register specifier has the same semantics as an auto specifier
together with a hint to the implementation that the object so declared
will be heavily used. The hint can be ignored and in most implementa
tions it will be ignored if the address of the object is taken.
4 The static specifier can be applied only to names of objects and func
tions and to anonymous unions (_class.union_). There can be no static
function declarations within a block, nor any static function parame
ters. A static specifier used in the declaration of an object
declares the object to have static storage duration
(_basic.stc.static_). A static specifier can be used in declarations
of class members; _class.static_ describes its effect. For the link
age of a name declared with a static specifier, see _basic.link_.
5 The extern specifier can be applied only to the names of objects and
functions. The extern specifier cannot be used in the declaration of
class members or function parameters. For the linkage of a name
declared with an extern specifier, see _basic.link_.
6 A name declared in a namespace scope without a storage-class-specifier
has external linkage unless it has internal linkage because of a pre
vious declaration and provided it is not declared const. Objects
declared const and not explicitly declared extern have internal link
age.
7 The linkages implied by successive declarations for a given entity
shall agree. That is, within a given scope, each declaration declar
ing the same object name or the same overloading of a function name
shall imply the same linkage. Each function in a given set of over
loaded functions can have a different linkage, however. [Example:
static char* f(); // f() has internal linkage
char* f() // f() still has internal linkage
{ /* ... */ }
char* g(); // g() has external linkage
static char* g() // error: inconsistent linkage
{ /* ... */ }
void h();
inline void h(); // external linkage
inline void l();
void l(); // external linkage
inline void m();
extern void m(); // external linkage
static void n();
inline void n(); // internal linkage
static int a; // `a' has internal linkage
int a; // error: two definitions
static int b; // `b' has internal linkage
extern int b; // `b' still has internal linkage
int c; // `c' has external linkage
static int c; // error: inconsistent linkage
extern int d; // `d' has external linkage
static int d; // error: inconsistent linkage
--end example]
8 The name of a declared but undefined class can be used in an extern
declaration. Such a declaration, however, cannot be used before the
class has been defined. [Example:
struct S;
extern S a;
extern S f();
extern void g(S);
void h()
{
g(a); // error: S undefined
f(); // error: S undefined
}
--end example] The mutable specifier can be applied only to names of
class data members (_class.mem_) and can not be applied to names
declared const or static. [Example:
class X {
mutable const int* p; // ok
mutable int* const q; // ill-formed
};
--end example]
9 The mutable specifier on a class data member nullifies a const speci
fier applied to the containing class object and permits modification
of the mutable class member even though the rest of the object is
const (_dcl.type.cv_).
7.1.2 Function specifiers [dcl.fct.spec]
1 Function-specifiers can be used only in function declarations.
function-specifier:
inline
virtual
explicit
2 A function declaration (_dcl.fct_, _class.mfct_, _class.friend_) with
an inline specifier declares an inline function. The inline specifier
indicates to the implementation that inline substitution of the func
tion body at the point of call is to be preferred to the usual func
tion call mechanism. An implementation is not required to perform
this inline substitution at the point of call; however, even if this
inline substitution is omitted, the other rules for inline functions
defined by this subclause shall still be respected.
3 A function defined within a class definition is an inline function.
The inline specifier shall not appear on a block scope function
declaration.2)
4 An inline function shall be defined in every translation unit in which
it is used (_basic.def.odr_), and shall have exactly the same defini
tion in every case (see one definition rule, _basic.def.odr_). If a
function with external linkage is declared inline in one translation
unit, it shall be declared inline in all translation units in which it
_________________________
2) The inline keyword has no effect on the linkage of a function.
appears. [Note: a static local variable in an extern inline function
always refers to the same object. ]
5 The virtual specifier shall only be used in declarations of nonstatic
class member functions that appear within a member-specification of a
class declaration; see _class.virtual_.
6 The explicit specifier shall be used only in declarations of construc
tors within a class declaration; see _class.conv.ctor_.
7.1.3 The typedef specifier [dcl.typedef]
1 Declarations containing the decl-specifier typedef declare identifiers
that can be used later for naming fundamental (_basic.fundamental_) or
compound (_basic.compound_) types. The typedef specifier shall not be
used in a function-definition (_dcl.fct.def_), and it shall not be
combined in a decl-specifier-seq with any other kind of specifier
except a type-specifier.
typedef-name:
identifier
A name declared with the typedef specifier becomes a typedef-name.
Within the scope of its declaration, a typedef-name is syntactically
equivalent to a keyword and names the type associated with the identi
fier in the way described in _dcl.decl_. A typedef-name is thus a
synonym for another type. A typedef-name does not introduce a new
type the way a class declaration (_class.name_) or enum declaration
does. [Example: after
typedef int MILES, *KLICKSP;
the constructions
MILES distance;
extern KLICKSP metricp;
are all correct declarations; the type of distance is int; that of
metricp is "pointer to int." ]
2 In a given scope, a typedef specifier can be used to redefine the name
of any type declared in that scope to refer to the type to which it
already refers. [Example:
typedef struct s { /* ... */ } s;
typedef int I;
typedef int I;
typedef I I;
--end example]
3 In a given scope, a typedef specifier shall not be used to redefine
the name of any type declared in that scope to refer to a different
type. [Example:
class complex { /* ... */ };
typedef int complex; // error: redefinition
--end example] Similarly, in a given scope, a class or enumeration
shall not be declared with the same name as a typedef-name that is
declared in that scope and refers to a type other than the class or
enumeration itself. [Example:
typedef int complex;
class complex { /* ... */ }; // error: redefinition
--end example]
4 A typedef-name that names a class is a class-name (_class.name_). The
typedef-name shall not be used after a class, struct, or union prefix
and not in the names for constructors and destructors within the class
declaration itself. [Example:
struct S {
S();
~S();
};
typedef struct S T;
S a = T(); // ok
struct T * p; // error
--end example]
5 If the typedef declaration defines an unnamed class (or enum), the
first typedef-name declared by the declaration to be that class type
(or enum type) is used to denote the class type (or enum type) for
linkage purposes only (_basic.link_). [Example:
typedef struct { } *ps, S; // 'S' is the class name for linkage purposes
--end example] If the typedef-name is used where a class-name (or
enum-name) is required, the program is ill-formed. [Example:
typedef struct {
S(); // error: requires a return type since S is
// an ordinary member function, not a constructor
} S;
--end example]
7.1.4 The friend specifier [dcl.friend]
1 The friend specifier is used to specify access to class members; see
_class.friend_.
7.1.5 Type specifiers [dcl.type]
1 The type-specifiers are
type-specifier:
simple-type-specifier
class-specifier
enum-specifier
elaborated-type-specifier
cv-qualifier
As a general rule, at most one type-specifier is allowed in the com
plete decl-specifier-seq of a declaration. The only exceptions to
this rule are the following:
2
--const or volatile can be combined with any other type-specifier.
However, redundant cv-qualifiers are prohibited except when intro
duced through the use of typedefs (_dcl.typedef_) or template type
arguments (_temp.arg_), in which case the redundant cv-qualifiers
are ignored.
--signed or unsigned can be combined with char, long, short, or int.
--short or long can be combined with int.
--long can be combined with double.
3 At least one type-specifier that is not a cv-qualifier is required in
a declaration unless it declares a constructor, destructor or type
conversion operator.3)
4 [Note: class-specifiers and enum-specifiers are discussed in _class_
and _dcl.enum_, respectively. The remaining type-specifiers are dis
cussed in the rest of this section. ]
7.1.5.1 The cv-qualifiers [dcl.type.cv]
1 There are two cv-qualifiers, const and volatile. If a cv-qualifier
appears in a decl-specifier-seq, the init-declarator-list of the dec
laration shall not be empty. [Note: _basic.type.qualifier_ describes
how cv-qualifiers affect object and function types. ]
2 An object declared with a const-qualified type has internal linkage
unless it is explicitly declared extern or unless it was previously
declared to have external linkage. A variable of const-qualified
integral or enumeration type initialized by an integral constant
expression can be used in integral constant expressions
(_expr.const_). [Note: as described in _dcl.init_, the definition of
an object or subobject of const-qualified type must specify an ini
tializer or be subject to default-initialization. ]
3 A pointer or reference to a cv-qualified type need not actually point
or refer to a cv-qualified object, but it is treated as if it does; a
const-qualified access path cannot be used to modify an object even if
the object referenced is a non-const object and can be modified
through some other access path. [Note: cv-qualifiers are supported by
the type system so that they cannot be subverted without casting
(_expr.const.cast_). ]
4 Except that any class member declared mutable (_dcl.stc_) can be modi
fied, any attempt to modify a const object during its lifetime
(_basic.life_) results in undefined behavior.
5 [Example:
const int ci = 3; // cv-qualified (initialized as required)
ci = 4; // ill-formed: attempt to modify const
int i = 2; // not cv-qualified
const int* cip; // pointer to const int
cip = &i; // okay: cv-qualified access path to unqualified
*cip = 4; // ill-formed: attempt to modify through ptr to const
_________________________
3) There is no special provision for a decl-specifier-seq that lacks a
type-specifier or that has a type-specifier that only specifies cv-
qualifiers. The "implicit int" rule of C is no longer supported.
int* ip;
ip = const_cast<int*>(cip); // cast needed to convert const int* to int*
*ip = 4; // defined: *ip points to i, a non-const object
const int* ciq = new const int (3); // initialized as required
int* iq = const_cast<int*>(ciq); // cast required
*iq = 4; // undefined: modifies a const object
6 For another example
class X {
public:
mutable int i;
int j;
};
class Y {
public:
X x;
Y();
};
const Y y;
y.x.i++; // well-formed: mutable member can be modified
y.x.j++; // ill-formed: const-qualified member modified
Y* p = const_cast<Y*>(&y); // cast away const-ness of y
p->x.i = 99; // well-formed: mutable member can be modified
p->x.j = 99; // undefined: modifies a const member
--end example]
7 [Note: volatile is a hint to the implementation to avoid aggressive
optimization involving the object because the value of the object
might be changed by means undetectable by an implementation. See
_intro.execution_ for detailed semantics. In general, the semantics
of volatile are intended to be the same in C++ as they are in C. ]
7.1.5.2 Simple type specifiers [dcl.type.simple]
1 The simple type specifiers are
simple-type-specifier:
::opt nested-name-specifieropt type-name
char
wchar_t
bool
short
int
long
signed
unsigned
float
double
void
type-name:
class-name
enum-name
typedef-name
The simple-type-specifiers specify either a previously-declared user-
defined type or one of the fundamental types (_basic.fundamental_).
Table 1 summarizes the valid combinations of simple-type-specifiers
and the types they specify.
Table 1--simple-type-specifiers and the types they specify
+-------------------+----------------------+
|Specifier(s) | Type |
+-------------------+----------------------+
|type-name | the type named |
|char | "char" |
|unsigned char | "unsigned char" |
|signed char | "signed char" |
|bool | "bool" |
|unsigned | "unsigned int" |
|unsigned int | "unsigned int" |
|signed | "int" |
|signed int | "int" |
|int | "int" |
|unsigned short int | "unsigned short int" |
|unsigned short | "unsigned short int" |
|unsigned long int | "unsigned long int" |
|unsigned long | "unsigned long int" |
|signed long int | "long int" |
|signed long | "long int" |
|long int | "long int" |
|long | "long int" |
|signed short int | "short int" |
|signed short | "short int" |
|short int | "short int" |
|short | "short int" |
|wchar_t | "wchar_t" |
|float | "float" |
|double | "double" |
|long double | "long double" |
|void | "void" |
+-------------------+----------------------+
When multiple simple-type-specifiers are allowed, they can be freely
intermixed with other decl-specifiers in any order. It is implementa
tion-defined whether bit-fields and objects of char type are repre
sented as signed or unsigned quantities. The signed specifier forces
char objects and bit-fields to be signed; it is redundant with other
integral types.
7.1.5.3 Elaborated type specifiers [dcl.type.elab]
1 elaborated-type-specifier:
class-key ::opt nested-name-specifieropt identifier
enum ::opt nested-name-specifieropt identifier
2 If an elaborated-type-specifier is the sole constituent of a declara
tion, the declaration is ill-formed unless it is an explicit
specialization (_temp.expl.spec_), an explicit instantiation
(_temp.explicit_) or it has one of the following forms:
-- class-key identifier ;
3 -- friend class-key identifier ;
4 -- friend class-key ::identifier ;
friend class-key nested-name-specifier identifier ;
5 _basic.lookup.elab_ describes how name look up proceeds for the iden
tifier in an elaborated-type-specifier. If the identifier resolves to
a class-name or enum-name, the elaborated-type-specifier introduces it
into the declaration the same way a simple-type-specifier introduces
its type-name. If the identifier resolves to a typedef-name or a tem
plate type-parameter, the elaborated-type-specifier is ill-formed. If
name look up does not find a declaration for the name, the elaborated-
type-specifier is ill-formed unless it is of the simple form class-key
identifier in which case the identifier is declared as described in
_basic.scope.pdecl_.
6 The class-key or enum keyword present in the elaborated-type-specifier
shall agree in kind with the declaration to which the name in the
elaborated-type-specifier refers. This rule also applies to the form
of elaborated-type-specifier that declares a class-name or friend
class since it can be construed as referring to the definition of the
class. Thus, in any elaborated-type-specifier, the enum keyword shall
be used to refer to an enumeration (_dcl.enum_), the union class-key
shall be used to refer to a union (_class_), and either the class or
struct class-key shall be used to refer to a class (_class_) declared
using the class or struct class-key.
7.2 Enumeration declarations [dcl.enum]
1 An enumeration is a distinct type (_basic.fundamental_) with named
constants. Its name becomes an enum-name, within its scope.
enum-name:
identifier
enum-specifier:
enum identifieropt { enumerator-listopt }
enumerator-list:
enumerator-definition
enumerator-list , enumerator-definition
enumerator-definition:
enumerator
enumerator = constant-expression
enumerator:
identifier
The identifiers in an enumerator-list are declared as constants, and
can appear wherever constants are required. If no enumerator-defini
tions with = appear, then the values of the corresponding constants
begin at zero and increase by one as the enumerator-list is read from
left to right. An enumerator-definition with = gives the associated
enumerator the value indicated by the constant-expression; subsequent
enumerators without initializers continue the progression from the
assigned value. The constant-expression shall be of integral or enu
meration type.
2 [Example:
enum { a, b, c=0 };
enum { d, e, f=e+2 };
defines a, c, and d to be zero, b and e to be 1, and f to be 3. ]
3 The point of declaration for an enumerator is immediately after its
enumerator-definition. [Example:
const int x = 12;
{ enum { x = x }; }
Here, the enumerator x is initialized with the value of the constant
x, namely 12. ]
4 Each enumeration defines a type that is different from all other
types. The type of an enumerator is its enumeration.
5 The underlying type of an enumeration is an integral type that can
represent all the enumerator values defined in the enumeration. It is
implementation-defined which integral type is used as the underlying
type for an enumeration except that the underlying type shall not be
larger than int unless the value of an enumerator cannot fit in an int
or unsigned int. If the enumerator-list is empty, the underlying type
is as if the enumeration had a single enumerator with value 0. The
value of sizeof() applied to an enumeration type, an object of enumer
ation type, or an enumerator, is the value of sizeof() applied to the
underlying type.
6 For an enumeration where emin is the smallest enumerator and emax is
the largest, the values of the enumeration are the values of the
underlying type in the range bmin to bmax, where bmin and bmax are,
respectively, the smallest and largest values of the smallest bit-
field that can store emin and emax.4) It is possible to define an enu
meration that has values not defined by any of its enumerators.
7 Two enumeration types are layout-compatible if they have the same
underlying type.
8 The value of an enumerator or an object of an enumeration type is con
verted to an integer by integral promotion (_conv.prom_). [Example:
enum color { red, yellow, green=20, blue };
color col = red;
color* cp = &col;
if (*cp == blue) // ...
makes color a type describing various colors, and then declares col as
_________________________
4) On a two's-complement machine, bmax is the smallest value greater
than or equal to max(abs(emin)-1,abs(emax)) of the form 2M-1; bmin is
zero if emin is non-negative and -(bmax+1) otherwise.
an object of that type, and cp as a pointer to an object of that type.
The possible values of an object of type color are red, yellow, green,
blue; these values can be converted to the integral values 0, 1, 20,
and 21. Since enumerations are distinct types, objects of type color
can be assigned only values of type color.
color c = 1; // error: type mismatch,
// no conversion from int to color
int i = yellow; // ok: yellow converted to integral value 1
// integral promotion
See also _diff.anac_. ]
9 An expression of arithmetic or enumeration type can be converted to an
enumeration type explicitly. The value is unchanged if it is in the
range of enumeration values of the enumeration type; otherwise the
resulting enumeration value is unspecified.
10The enum-name and each enumerator declared by an enum-specifier is
declared in the scope that immediately contains the enum-specifier.
These names obey the scope rules defined for all names in
(_basic.scope_) and (_basic.lookup_). An enumerator declared in class
scope can be referred to using the class member access operators ::, .
(dot) and -> (arrow)), see _expr.ref_. [Example:
class X {
public:
enum direction { left='l', right='r' };
int f(int i)
{ return i==left ? 0 : i==right ? 1 : 2; }
};
void g(X* p)
{
direction d; // error: `direction' not in scope
int i;
i = p->f(left); // error: `left' not in scope
i = p->f(X::right); // ok
i = p->f(p->left); // ok
// ...
}
--end example]
7.3 Namespaces [basic.namespace]
1 A namespace is an optionally-named declarative region. The name of a
namespace can be used to access entities declared in that namespace;
that is, the members of the namespace. Unlike other declarative
regions, the definition of a namespace can be split over several parts
of one or more translation units.
2 A name declared outside all named namespaces, blocks (_stmt.block_)
and classes (_class_) has global namespace scope (_basic.scope.names
pace_).
7.3.1 Namespace definition [namespace.def]
1 The grammar for a namespace-definition is
namespace-name:
original-namespace-name
namespace-alias
original-namespace-name:
identifier
namespace-definition:
named-namespace-definition
unnamed-namespace-definition
named-namespace-definition:
original-namespace-definition
extension-namespace-definition
original-namespace-definition:
namespace identifier { namespace-body }
extension-namespace-definition:
namespace original-namespace-name { namespace-body }
unnamed-namespace-definition:
namespace { namespace-body }
namespace-body:
declaration-seqopt
2 The identifier in an original-namespace-definition shall not have been
previously defined in the declarative region in which the original-
namespace-definition appears. The identifier in an original-names
pace-definition is the name of the namespace. Subsequently in that
declarative region, it is treated as an original-namespace-name.
3 The original-namespace-name in an extension-namespace-definition shall
have previously been defined in an original-namespace-definition in
the same declarative region.
4 Every namespace-definition shall appear in the global scope or in a
namespace scope (_basic.scope.namespace_).
5 Because a namespace-definition contains declarations in its namespace-
body and a namespace-definition is itself a declaration, it follows
that namespace-definitions can be nested. [Example:
namespace Outer {
int i;
namespace Inner {
void f() { i++; } // Outer::i
int i;
void g() { i++; } // Inner::i
}
}
--end example]
7.3.1.1 Unnamed namespaces [namespace.unnamed]
1 An unnamed-namespace-definition behaves as if it were replaced by
namespace unique { /* empty body */ }
using namespace unique;
namespace unique { namespace-body }
where all occurrences of unique in a translation unit are replaced by
the same identifier and this identifier differs from all other identi
fiers in the entire program.5) [Example:
namespace { int i; } // unique::i
void f() { i++; } // unique::i++
namespace A {
namespace {
int i; // A::unique::i
int j; // A::unique::j
}
void g() { i++; } // A::unique::i++
}
using namespace A;
void h() {
i++; // error: unique::i or A::unique::i
A::i++; // A::unique::i
j++; // A::unique::j
}
--end example]
2 The use of the static keyword is deprecated when declaring objects in
a namespace scope (see Annex _depr_); the unnamed-namespace provides a
superior alternative.
7.3.1.2 Namespace member definitions [namespace.memdef]
1 Members of a namespace can be defined within that namespace. [Exam
ple:
namespace X {
void f() { /* ... */ }
}
--end example]
2 Members of a named namespace can also be defined outside that names
pace by explicit qualification (_namespace.qual_) of the name being
defined, provided that the entity being defined was already declared
in the namespace and the definition appears after the point of decla
ration in a namespace that encloses the declaration's namespace.
[Example:
_________________________
5) Although entities in an unnamed namespace might have external link
age, they are effectively qualified by a name unique to their transla
tion unit and therefore can never be seen from any other translation
unit.
namespace Q {
namespace V {
void f();
}
void V::f() { /* ... */ } // fine
void V::g() { /* ... */ } // error: g() is not yet a member of V
namespace V {
void g();
}
}
namespace R {
void Q::V::g() { /* ... */ } // error: R doesn't enclose Q
}
--end example]
3 Every name first declared in a namespace is a member of that names
pace. If a friend declaration first declares a class or function, and
the name of the class or function is unqualified, the friend class or
function is a member of the innermost enclosing namespace. The name
of the friend is not found by simple name lookup in the scope of the
namespace until a matching declaration is provided in that namespace
scope (either before or after the class declaration granting friend
ship). If a friend function is called, its name may be found by the
name lookup that considers functions from namespaces associated with
the types of the function arguments (_lookup.basic.koenig_). When
looking for a prior declaration of a class or a function declared as a
friend, scopes outside the innermost enclosing namespace scope are not
considered. [Example:
// Assume f and g have not yet been defined.
friend void h(int);
namespace A {
class X {
friend void f(X); // A::f is a friend
class Y {
friend void g(); // A::g is a friend
friend void h(int); // A::h is a friend
// ::h not considered
};
};
// A::f, A::g and A::h are not visible here
void f(X) { /* ... */} // definition of A::f
X x;
void g() { f(x); } // definition of A::g
void h(int) { /* ... */ } // definition of A::h
// A::f, A::g and A::h are visible here and known to be friends
}
using A::x;
void h()
{
A::f(x);
A::X::f(x); // error: f is not a member of A::X
A::X::Y::g(); // error: g is not a member of A::X::Y
}
--end example]
4 When an entity declared with a block scope extern declaration is not
found to refer to some other declaration, then that entity is a member
of the innermost enclosing namespace. However such a declaration does
not introduce the member name in its namespace scope. [Example:
namespace X {
void p()
{
q(); // error: q not yet declared
extern void q(); // q is a member of namespace X
}
void middle()
{
q(); // error: q not yet declared
}
void q() { /* ... */ } // definition of X::q
}
void q() { /* ... */ } // some other, unrelated q
--end example]
7.3.2 Namespace alias [namespace.alias]
1 A namespace-alias-definition declares an alternate name for a names
pace according to the following grammar:
namespace-alias:
identifier
namespace-alias-definition:
namespace identifier = qualified-namespace-specifier ;
qualified-namespace-specifier:
::opt nested-name-specifieropt namespace-name
2 The identifier in a namespace-alias-definition is a synonym for the
name of the namespace denoted by the qualified-namespace-specifier and
becomes a namespace-alias. [Note: when looking up a namespace-name in
a namespace-alias-definition, only namespace names are considered, see
_basic.lookup.udir_. ]
3 In a declarative region, a namespace-alias-definition can be used to
redefine a namespace-alias declared in that declarative region to
refer to the namespace to which it already refers. [Example: the fol
lowing declarations are well-formed:
namespace Company_with_very_long_name { /* ... */ }
namespace CWVLN = Company_with_very_long_name;
namespace CWVLN = Company_with_very_long_name; // ok: duplicate
namespace CWVLN = CWVLN;
--end example]
4 A namespace-name or namespace-alias shall not be declared as the name
of any other entity in the same declarative region. A namespace-name
defined at global scope shall not be declared as the name of any other
entity in any global scope of the program. No diagnostic is required
for a violation of this rule by declarations in different translation
units.
7.3.3 The using declaration [namespace.udecl]
1 A using-declaration introduces a name into the declarative region in
which the using-declaration appears. That name is a synonym for the
name of some entity declared elsewhere. A name specified in a using-
declaration in a class or namespace scope shall not already be a mem
ber of that scope.
using-declaration:
using typenameopt ::opt nested-name-specifier unqualified-id ;
using :: unqualified-id ;
2 The member name specified in a using-declaration is declared in the
declarative region in which the using-declaration appears.
3 Every using-declaration is a declaration and a member-declaration and
so can be used in a class definition. [Example:
struct B {
void f(char);
void g(char);
enum E { e };
union { int x; };
};
struct D : B {
using B::f;
void f(int) { f('c'); } // calls B::f(char)
void g(int) { g('c'); } // recursively calls D::g(int)
};
--end example]
4 A using-declaration used as a member-declaration shall refer to a mem
ber of a base class of the class being defined, shall refer to a mem
ber of an anonymous union that is a member of a base class of the
class being defined, or shall refer to an enumerator for an enumera
tion type that is a member of a base class of the class being defined.
[Example:
class C {
int g();
};
class D2 : public B {
using B::f; // ok: B is a base of D2
using B::e; // ok: e is an enumerator of base B
using B::x; // ok: x is a union member of base B
using C::g; // error: C isn't a base of D2
};
--end example] [Note: since constructors and destructors do not have
names, a using-declaration cannot refer to a constructor or a destruc
tor for a base class. A using-declaration can refer to a base class
copy-assignment operator; however, this copy-assignment operator is
never used as the copy-assignment operator for the derived class that
contains the using-declaration (_over.ass_). ]
5 A using-declaration for a member shall be a member-declaration.
[Example:
struct X {
int i;
static int s;
};
void f()
{
using X::i; // error: X::i is a class member
// and this is not a member declaration.
using X::s; // error: X::s is a class member
// and this is not a member declaration.
}
--end example]
6 Members declared by a using-declaration can be referred to by explicit
qualification just like other member names (_namespace.qual_). In a
using-declaration, a prefix :: refers to the global namespace. [Exam
ple:
void f();
namespace A {
void g();
}
namespace X {
using ::f; // global f
using A::g; // A's g
}
void h()
{
X::f(); // calls ::f
X::g(); // calls A::g
}
--end example]
7 A using-declaration is a declaration and can therefore be used repeat
edly where (and only where) multiple declarations are allowed. [Exam
ple:
namespace A {
int i;
}
namespace A1 {
using A::i;
using A::i; // ok: double declaration
}
void f()
{
using A::i;
using A::i; // error: double declaration
}
class B {
public:
int i;
};
class X : public B {
using B::i;
using B::i; // error: double member declaration
};
--end example]
8 The entity declared by a using-declaration shall be known in the con
text using it according to its definition at the point of the using-
declaration. Definitions added to the namespace after the using-dec
laration are not considered when a use of the name is made. [Example:
namespace A {
void f(int);
}
using A::f; // f is a synonym for A::f;
// that is, for A::f(int).
namespace A {
void f(char);
}
void foo()
{
f('a'); // calls f(int),
} // even though f(char) exists.
void bar()
{
using A::f; // f is a synonym for A::f;
// that is, for A::f(int) and A::f(char).
f('a'); // calls f(char)
}
--end example]
9 A name declared by a using-declaration is an alias for its original
declarations so that the using-declaration does not affect the type,
linkage or other attributes of the members referred to.
10If the set of declarations and using-declarations for a single name
are given in a declarative region,
--they shall all refer to the same entity, or all refer to functions;
or
--exactly one declaration shall declare a class name or enumeration
name and the other declarations shall all refer to the same entity
or all refer to functions; in this case the class name or enumera
tion name is hidden (_basic.scope.hiding_).
11[Example:
namespace A {
int x;
}
namespace B {
int i;
struct g { };
struct x { };
void f(int);
void f(double);
void g(char); // OK: hides struct g
}
void func()
{
int i;
using B::i; // error: i declared twice
void f(char);
using B::f; // fine: each f is a function
f(3.5); // calls B::f(double)
using B::g;
g('a'); // calls B::g(char)
struct g g1; // g1 has class type B::g
using B::x;
using A::x; // fine: hides struct B::x
x = 99; // assigns to A::x
struct x x1; // x1 has class type B::x
}
--end example]
12If a function declaration in namespace scope or block scope has the
same name and the same parameter types as a function introduced by a
using-declaration, the program is ill-formed. [Note: two using-decla
rations may introduce functions with the same name and the same param
eter types. A call to such a function is ill-formed unless name look
up can unambiguously select the function to be called (because the
function name is qualified by its namespace name, for example). ]
[Example:
namespace B {
void f(int);
void f(double);
}
namespace C {
void f(int);
void f(double);
void f(char);
}
void h()
{
using B::f; // B::f(int) and B::f(double)
using C::f; // C::f(int), C::f(double), and C::f(char)
f('h'); // calls C::f(char)
f(1); // error: ambiguous: B::f(int) or C::f(int) ?
void f(int); // error:
// f(int) conflicts with C::f(int) and B::f(int)
}
--end example]
13When a using-declaration brings names from a base class into a derived
class scope, member functions in the derived class override and/or
hide member functions with the same name and parameter types in a base
class (rather than conflicting). [Example:
struct B {
virtual void f(int);
virtual void f(char);
void g(int);
void h(int);
};
struct D : B {
using B::f;
void f(int); // ok: D::f(int) overrides B::f(int);
using B::g;
void g(char); // ok
using B::h;
void h(int); // ok: D::h(int) hides B::h(int)
};
void k(D* p)
{
p->f(1); // calls D::f(int)
p->f('a'); // calls B::f(char)
p->g(1); // calls B::g(int)
p->g('a'); // calls D::g(char)
}
--end example] [Note: two using-declarations may introduce functions
with the same name and the same parameter types. A call to such a
function is ill-formed unless name look up can unambiguously select
the function to be called (because the function name is qualified by
its class name, for example). ]
14For the purpose of overload resolution, the functions which are intro
duced by a using-declaration into a derived class will be treated as
though they were members of the derived class. In particular, the
implicit this parameter shall be treated as if it were a pointer to
the derived class rather than to the base class. This has no effect
on the type of the function, and in all other respects the function
remains a member of the base class.
15All instances of the name mentioned in a using-declaration shall be
accessible. In particular, if a derived class uses a using-declara
tion to access a member of a base class, the member name shall be
accessible. If the name is that of an overloaded member function,
then all functions named shall be accessible. The base class members
mentioned by a using-declaration shall be visible in the scope of at
least one of the direct base classes of the class where the using-dec
laration is specified. [Note: because a using-declaration designates
a base class member (and not a member subobject or a member function
of a base class subobject), a using-declaration cannot be used to
resolve inherited member ambiguities. For example,
struct A { int x(); };
struct B : A { };
struct C : A {
using A::x;
int x(int);
};
struct D : B, C {
using C::x;
int x(double);
};
int f(D* d) {
return d->x(); // ambiguous: B::x or C::x
}
]
16The alias created by the using-declaration has the usual accessibility
for a member-declaration. [Example:
class A {
private:
void f(char);
public:
void f(int);
protected:
void g();
};
class B : public A {
using A::f; // error: A::f(char) is inaccessible
public:
using A::g; // B::g is a public synonym for A::g
};
--end example]
17[Note: use of access-declarations (_class.access.dcl_) is deprecated;
member using-declarations provide a better alternative. ]
7.3.4 Using directive [namespace.udir]
1 using-directive:
using namespace ::opt nested-name-specifieropt namespace-name ;
A using-directive shall not appear in class scope, but may appear in
namespace scope or in block scope. [Note: when looking up a names
pace-name in a using-directive, only namespace names are considered,
see _basic.lookup.udir_. ]
2 A using-directive specifies that the names in the nominated namespace
can be used in the scope in which the using-directive appears after
the using-directive. During unqualified name look up
(_basic.lookup.unqual_), the names appear as if they were declared in
the nearest enclosing namespace which contains both the using-direc
tive and the nominated namespace. [Note: in this context, "contains"
means "contains directly or indirectly". ] A using-directive does not
add any members to the declarative region in which it appears. [Exam
ple:
namespace A {
int i;
namespace B {
namespace C {
int i;
}
using namespace A::B::C;
void f1() {
i = 5; // ok, C::i visible in B and hides A::i
}
}
namespace D {
using namespace B;
using namespace C;
void f2() {
i = 5; // ambiguous , B::C::i or A::i ?
}
}
void f3() {
i = 5; // uses A::i
}
}
void f4() {
i = 5; // ill-formed; neither "i" is visible
}
]
3 The using-directive is transitive: if a scope contains a using-direc
tive that nominates a second namespace that itself contains using-
directives, the effect is as if the using-directives from the second
namespace also appeared in the first. [Example:
namespace M {
int i;
}
namespace N {
int i;
using namespace M;
}
void f()
{
using namespace N;
i = 7; // error: both M::i and N::i are visible
}
For another example,
namespace A {
int i;
}
namespace B {
int i;
int j;
namespace C {
namespace D {
using namespace A;
int j;
int k;
int a = i; // B::i hides A::i
}
using namespace D;
int k = 89; // no problem yet
int l = k; // ambiguous: C::k or D::k;
int m = i; // B::i hides A::i
int n = j; // D::j hides B::j
}
}
--end example]
4 If a namespace is extended by an extended-namespace-definition after a
using-directive for that namespace is given, the additional members of
the extended namespace and the members of namespaces nominated by
using-directives in the extended-namespace-definition can be used
after the extended-namespace-definition.
5 If name look up finds a declaration for a name in two different names
paces, and the declarations do not declare the same entity and do not
declare functions, the use of the name is ill-formed. [Note: in par
ticular, the name of an object, function or enumerator does not hide
the name of a class or enumeration declared in a different namespace.
For example,
namespace A { class X { }; }
namespace B { void X(int); }
using namespace A;
using namespace B;
void f() {
X(1); // error: name X found in two namespaces
}
--end note]
6 During overload resolution, all functions from the transitive search
are considered for argument matching. The set of declarations found
by the transitive search is unordered. [Note: in particular, the
order in which namespaces were considered and the relationships among
the namespaces implied by the using-directives do not cause preference
to be given to any of the declarations found by the search. ] An
ambiguity exists if the best match finds two functions with the same
signature, even if one is in a namespace reachable through using-
directives in the namespace of the other.6) [Example:
namespace D {
int d1;
void f(char);
}
using namespace D;
int d1; // ok: no conflict with D::d1
namespace E {
int e;
void f(int);
}
namespace D { // namespace extension
int d2;
using namespace E;
void f(int);
}
void f()
{
d1++; // error: ambiguous ::d1 or D::d1?
::d1++; // ok
D::d1++; // ok
d2++; // ok: D::d2
e++; // ok: E::e
f(1); // error: ambiguous: D::f(int) or E::f(int)?
f('a'); // ok: D::f(char)
}
--end example]
7.4 The asm declaration [dcl.asm]
1 An asm declaration has the form
asm-definition:
asm ( string-literal ) ;
The meaning of an asm declaration is implementation-defined. [Note:
Typically it is used to pass information through the implementation to
an assembler. ]
_________________________
6) During name lookup in a class hierarchy, some ambiguities may be
resolved by considering whether one member hides the other along some
paths (_class.member.lookup_). There is no such disambiguation when
considering the set of names found as a result of following using-di
rectives.
7.5 Linkage specifications [dcl.link]
1 All function types, function names, and variable names have a language
linkage, the specific semantics of which are implementation-defined.
[Note: a particular language linkage may be associated with a particu
lar form of representing names of objects and functions with external
linkage, with a particular calling convention, etc. ] The default
language linkage of all function types, function names, and variable
names is C++ language linkage. Two function types with different lan
guage linkages are distinct types even if they are otherwise identi
cal.
2 Linkage (_basic.link_) between C++ and non-C++ code fragments can be
achieved using a linkage-specification:
linkage-specification:
extern string-literal { declaration-seqopt }
extern string-literal declaration
The string-literal indicates the required language linkage. The mean
ing of the string-literal is implementation-defined. A linkage-speci
fication with a string that is unknown to the implementation is ill-
formed. When the string-literal in a linkage-specification names a
programming language, the spelling of the programming language's name
is implementation-defined. [Note: it is recommended that the spelling
be taken from the document defining that language, for example Ada
(not ADA) and Fortran or FORTRAN (depending on the vintage). ]
3 Every implementation shall provide for linkage to functions written in
the C programming language, "C", and linkage to C++ functions, "C++".
[Example:
complex sqrt(complex); // C++ linkage by default
extern "C" {
double sqrt(double); // C linkage
}
--end example]
4 Linkage specifications nest. When linkage specifications nest, the
innermost one determines the language linkage. A linkage specifica
tion does not establish a scope. A linkage-specification can occur
only in namespace scope (_basic.scope_). In a linkage-specification,
the specified language linkage applies to the function types of all
function declarators, function names, and variable names introduced by
the declaration(s). [Example:
extern "C" void f1(void(*pf)(int));
// the name f1 and its function type have C language
// linkage; pf is a pointer to a C function
extern "C" typedef void FUNC();
FUNC f2; // the name f2 has C++ language linkage and the
// function's type has C language linkage
extern "C" FUNC f3;
// the name of function f3 and the function's type
// have C language linkage
void (*pf2)(FUNC*);
// the name of the variable pf2 has C++ linkage and
// the type of pf2 is pointer to C++ function that
// takes one parameter of type pointer to C function
--end example] A non-C++ language linkage is ignored for the names of
class members and for the function type of class member function
declarators. [Example:
extern "C" typedef void FUNC_c();
class C {
void mf1(FUNC_c*);
// the name of the function mf1 and the member
// function's type have C++ language linkage; the
// parameter has type pointer to C function
FUNC_c mf2;
// the name of the function mf2 and the member
// function's type have C++ language linkage
static FUNC_c* q;
// the name of the data member q has C++ language
// linkage and the data member's type is pointer to
// C function
};
extern "C" {
class X {
void mf();
// the name of the function mf and the member
// function's type have C++ language linkage
};
}
--end example]
5 If two declarations of the same function or object specify different
linkage-specifications (that is, the linkage-specifications of these
declarations specify different string-literals), the program is ill-
formed if the declarations appear in the same translation unit, and
the one definition rule (_basic.def.odr_) applies if the declarations
appear in different translation units. Except for functions with C++
linkage, a function declaration without a linkage specification shall
not precede the first linkage specification for that function. A
function can be declared without a linkage specification after an
explicit linkage specification has been seen; the linkage explicitly
specified in the earlier declaration is not affected by such a func
tion declaration.
6 At most one of a set of overloaded functions (_over_) with a particu
lar name can have C linkage. Two declarations for a function with C
language linkage with the same function name (ignoring the namespace
names that qualify it) and the same parameter-clause that appear in
different namespace scopes refer to the same function. Two declara
tions for an object with C language linkage with the same name (ignor
ing the namespace names that qualify it) that appear in different
namespace scopes refer to the same object. [Note: because of the one
definition rule (_basic.def.odr_), only one definition for a function
or object with C linkage may appear in the program; that is, such a
function or object must not be defined in more than one namespace
scope. For example,
namespace A {
extern "C" int f();
extern "C" int g() { return 1; }
extern "C" int h();
}
namespace B {
extern "C" int f(); // A::f and B::f refer
// to the same function
extern "C" int g() { return 1; } // ill-formed, the function g
// with C language linkage
// has two definitions
}
int A::f() { return 98; } // definition for the function f
// with C language linkage
extern "C" int h() { return 97; }
// definition for the function h
// with C language linkage
// A::h and ::h refer to the same function
--end note]
7 Except for functions with internal linkage, a function first declared
in a linkage-specification behaves as a function with external link
age. [Example:
extern "C" double f();
static double f(); // error
is ill-formed (_dcl.stc_). ] An object defined within an
extern "C" { /* ... */ }
linkage-specification is still defined (and not just declared).
8 [Note: because the language linkage is part of a function type, when a
pointer to C function (for example) is dereferenced, the function to
which it refers is considered a C function. ]
9 Linkage from C++ to objects defined in other languages and to objects
defined in C++ from other languages is implementation-defined and lan
guage-dependent. Only where the object layout strategies of two lan
guage implementations are similar enough can such linkage be achieved.