______________________________________________________________________
9 Classes [class]
______________________________________________________________________
1 A class is a type. Its name becomes a class-name (_class.name_)
within its scope.
class-name:
identifier
template-id
Class-specifiers and elaborated-type-specifiers (_dcl.type.elab_) are
used to make class-names. An object of a class consists of a (possi
bly empty) sequence of members and base class objects.
class-specifier:
class-head { member-specificationopt }
class-head:
class-key identifieropt base-clauseopt
class-key nested-name-specifier identifier base-clauseopt
class-key:
class
struct
union
2 A class-name is inserted into the scope in which it is declared imme
diately after the class-name is seen. The class-name is also inserted
into the scope of the class itself. For purposes of access checking,
the inserted class name is treated as if it were a public member name.
A class-specifier is commonly referred to as a class definition. A
class is considered defined after the closing brace of its class-
specifier has been seen even though its member functions are in gen
eral not yet defined.
3 A class with an empty sequence of members and base class objects is an
empty class. Objects of an empty class have a nonzero size.
+------- BEGIN BOX 1 -------+
Bill Gibbons suggest that a base class subobject should be allowed to
occupy zero bytes of the complete object. This would permit two base
class subobjects to have the same address, for example.
+------- END BOX 1 -------+
[Note: Class objects can be assigned, passed as arguments to func
tions, and returned by functions (except objects of classes for which
copying has been restricted; see _class.copy_). Other plausible oper
ators, such as equality comparison, can be defined by the user; see
_over.oper_. ]
4 A structure is a class defined with the class-key struct; its members
and base classes (_class.derived_) are public by default
(_class.access_). A union is a class defined with the class-key
union; its members are public by default and it holds only one member
at a time (_class.union_). [Note: Aggregates of class type are
described in _dcl.init.aggr_. ] A POD-struct1) is an aggregate class
that has no members of type pointer to member, non-POD-struct, non-
POD-union (or array of such types) or reference, and has no user-
defined copy assignment operator and no user-defined destructor. Sim
ilarly, a POD-union is an aggregate union that has no members of type
pointer to member, non-POD-struct, non-POD-union (or array of such
types) or reference, and has no user-defined copy assignment operator
and no user-defined destructor.
+------- BEGIN BOX 2 -------+
Change: To complete Monterey motion 2d), user-declared destructors
were added to the list of members that a POD struct/union cannot have.
+------- END BOX 2 -------+
9.1 Class names [class.name]
1 A class definition introduces a new type. [Example:
struct X { int a; };
struct Y { int a; };
X a1;
Y a2;
int a3;
declares three variables of three different types. This implies that
a1 = a2; // error: Y assigned to X
a1 = a3; // error: int assigned to X
are type mismatches, and that
int f(X);
int f(Y);
declare an overloaded (_over_) function f() and not simply a single
function f() twice. For the same reason,
struct S { int a; };
struct S { int a; }; // error, double definition
is ill-formed because it defines S twice. ]
2 A class definition introduces the class name into the scope where it
is defined and hides any class, object, function, or other declaration
of that name in an enclosing scope (_basic.scope_). If a class name
is declared in a scope where an object, function, or enumerator of the
same name is also declared, then when both declarations are in scope,
the class can be referred to only using an elaborated-type-specifier
(_basic.lookup.elab_). [Example:
struct stat {
// ...
};
_________________________
1) The acronym POD stands for "plain ol' data."
stat gstat; // use plain `stat' to
// define variable
int stat(struct stat*); // redeclare `stat' as function
void f()
{
struct stat* ps; // `struct' prefix needed
// to name struct stat
// ...
stat(ps); // call stat()
// ...
}
--end example] A declaration consisting solely of
class-key identifier ; is either a redeclaration of the name in the
current scope or a forward declaration of the identifier as a class
name. It introduces the class name into the current scope. [Example:
struct s { int a; };
void g()
{
struct s; // hide global struct `s'
// with a local declaration
s* p; // refer to local struct `s'
struct s { char* p; }; // define local struct `s'
struct s; // redeclaration, has no effect
}
--end example] [Note: Such declarations allow definition of classes
that refer to each other. [Example:
class Vector;
class Matrix {
// ...
friend Vector operator*(Matrix&, Vector&);
};
class Vector {
// ...
friend Vector operator*(Matrix&, Vector&);
};
Declaration of friends is described in _class.friend_, operator func
tions in _over.oper_. ] ]
3 An elaborated-type-specifier (_dcl.type.elab_) can also be used in the
declarations of objects and functions. It differs from a class decla
ration in that if a class of the elaborated name is in scope the elab
orated name will refer to it. [Example:
struct s { int a; };
void g(int s)
{
struct s* p = new struct s; // global `s'
p->a = s; // local `s'
}
--end example]
4 [Note: A name declaration takes effect immediately after the identi
fier is seen. For example,
class A * A;
first specifies A to be the name of a class and then redefines it as
the name of a pointer to an object of that class. This means that the
elaborated form class A must be used to refer to the class. Such
artistry with names can be confusing and is best avoided. ]
5 A typedef-name (_dcl.typedef_) that names a class is a class-name, but
shall not be used in an elaborated-type-specifier; see also
_dcl.typedef_.
9.2 Class members [class.mem]
member-specification:
member-declaration member-specificationopt
access-specifier : member-specificationopt
member-declaration:
decl-specifier-seqopt member-declarator-listopt ;
function-definition ;opt
qualified-id ;
using-declaration
member-declarator-list:
member-declarator
member-declarator-list , member-declarator
member-declarator:
declarator pure-specifieropt
declarator constant-initializeropt
identifieropt : constant-expression
pure-specifier:
= 0
constant-initializer:
= constant-expression
1 The member-specification in a class definition declares the full set
of members of the class; no member can be added elsewhere. Members of
a class are data members, member functions (_class.mfct_), nested
types, and enumerators. Data members and member functions are static
or nonstatic; see _class.static_. Nested types are classes
(_class.name_, _class.nest_) and enumerations (_dcl.enum_) defined in
the class, and arbitrary types declared as members by use of a typedef
declaration (_dcl.typedef_). The enumerators of an enumeration
(_dcl.enum_) defined in the class are member of the class. Except
when used to declare friends (_class.friend_) or to adjust the access
to a member of a base class (_class.access.dcl_), member-declarations
declare members of the class, and each such member-declaration shall
declare at least one member name of the class. A member shall not be
declared twice in the member-specification, except that a nested class
can be declared and then later defined.
2 [Note: a single name can denote several function members provided
their types are sufficiently different (_over_). ]
3 A member-declarator can contain a constant-initializer only if it
declares a static member (_class.static_) of integral or enumeration
type, see _class.static.data_.
4 A member can be initialized using a constructor; see _class.ctor_.
[Note: see clause _special_ for a description of constructors and
other special member functions. ]
5 A member shall not be auto, extern, or register.
6 The decl-specifier-seq can be omitted in constructor, destructor, and
conversion function declarations only. The member-declarator-list can
be omitted only after a class-specifier, an enum-specifier, or a decl-
specifier-seq of the form friend elaborated-type-specifier. A pure-
specifier shall be used only in the declaration of a virtual function
(_class.virtual_).
7 Non-static (_class.static_) members that are class objects shall be
objects of previously defined classes. In particular, a class cl
shall not contain an object of class cl, but it can contain a pointer
or reference to an object of class cl. When an array is used as the
type of a nonstatic member all dimensions shall be specified.
8 Except when used to form a pointer to member (_expr.unary.op_), when
used in the body of a nonstatic member function of its class or of a
class derived from its class (_class.mfct.nonstatic_), or when used in
a mem-initializer for a constructor for its class or for a class
derived from its class (_class.base.init_), a nonstatic data or func
tion member of a class shall only be referred to with the class member
access syntax (_expr.ref_).
9 [Example: A simple example of a class definition is
struct tnode {
char tword[20];
int count;
tnode *left;
tnode *right;
};
which contains an array of twenty characters, an integer, and two
pointers to similar structures. Once this definition has been given,
the declaration
tnode s, *sp;
declares s to be a tnode and sp to be a pointer to a tnode. With
these declarations, sp->count refers to the count member of the struc
ture to which sp points; s.left refers to the left subtree pointer of
the structure s; and s.right->tword[0] refers to the initial character
of the tword member of the right subtree of s. ]
10The type of a nonstatic data member is data member type, not object
type; the type of a nonstatic member function is member function type,
not function type; see _expr.unary.op_ and _class.mfct_. [Example:
the type of the qualified-id expression tnode::count is data member
type and the type of &tnode::count is pointer to data member (that is,
int (tnode::*); see _expr.unary.op_). ] [Note: the type of static
members is described in _class.static_. ]
11Nonstatic data members of a (non-union) class declared without an
intervening access-specifier are allocated so that later members have
higher addresses within a class object. The order of allocation of
nonstatic data members separated by an access-specifier is implementa
tion-defined (_class.access.spec_). Implementation alignment require
ments might cause two adjacent members not to be allocated immediately
after each other; so might requirements for space for managing virtual
functions (_class.virtual_) and virtual base classes (_class.mi_).
12A static data member, enumerator, member of an anonymous union, or
nested type shall not have the same name as its class.
13Two POD-struct (_class_) types are layout-compatible if they have the
same number of members, and corresponding members (in order) have lay
out-compatible types (_basic.types_).
14Two POD-union (_class_) types are layout-compatible if they have the
same number of members, and corresponding members (in any order) have
layout-compatible types (_basic.types_).
+------- BEGIN BOX 3 -------+
Shouldn't this be the same set of types?
+------- END BOX 3 -------+
15If a POD-union contains two or more POD-structs that share a common
initial sequence, and if the POD-union object currently contains one
of these POD-structs, it is permitted to inspect the common initial
part of any of them. Two POD-structs share a common initial sequence
if corresponding members have layout-compatible types (and, for bit-
fields, the same widths) for a sequence of one or more initial mem
bers.
16A pointer to a POD-struct object, suitably converted, points to its
initial member (or if that member is a bit-field, then to the unit in
which it resides) and vice versa. [Note: There might therefore be
unnamed padding within a POD-struct object, but not at its beginning,
as necessary to achieve appropriate alignment. ]
+------- BEGIN BOX 4 -------+
What was subclause 9.3 (Scope rules for classes) in the April 28th
1995 version of the working paper was merged with _basic.scope.class_.
+------- END BOX 4 -------+
9.3 Member functions [class.mfct]
1 Functions declared in the definition of a class, excluding those
declared with a friend specifier (_class.friend_), are called member
functions of that class. A member function may be declared static in
which case it is a static member function of its class
(_class.static_); otherwise it is a nonstatic member function of its
class (_class.mfct.nonstatic_, _class.this_).
2 A member function may be defined (_dcl.fct.def_) in its class defini
tion, in which case it is an inline member function, or it may be
defined outside of its class definition if it has already been
declared but not defined in its class definition. A member function
definition that appears outside of the class definition shall appear
in a namespace scope enclosing the class definition. Except for mem
ber function definitions that appear outside of a class definition,
and except for explicit specializations of template member functions
(_temp.spec_) appearing outside of the class definition, a member
function shall not be redeclared.
3 An inline member function (whether static or nonstatic) may also be
defined outside of its class definition provided either its declara
tion in the class definition or its definition outside of the class
definition declares the function as inline (_dcl.fct.spec_). [Note:
member functions of a class in namespace scope have external linkage.
Member functions of a local class (_class.local_) have no linkage.
See _basic.link_. ]
4 There shall be at most one definition of a non-inline member function
in a program; no diagnostic is required. There may be more than one
inline member function definition in a program. See _basic.def.odr_
and _dcl.fct.spec_.
5 If the definition of a member function is lexically outside its class
definition, the member function name shall be qualified by its class
name using the :: operator. A member function definition (that is,
the parameter-declaration-clause including the default arguments
(_dcl.fct.default_), the member function body and, for a constructor
function (_class.ctor_), the ctor-initializer (_class.base.init_)) is
in the scope of the member function's class (_basic.scope.class_).
[Example:
struct X {
typedef int T;
static T count;
void f(T);
};
void X::f(T t = count) { }
The member function f of class X is defined in global scope; the nota
tion X::f specifies that the function f is a member of class X and in
the scope of class X. In the function definition, the parameter type
T refers to the typedef member T declared in class X and the default
argument count refers to the static data member count declared in
class X. ]
6 A static local variable in a member function always refers to the same
object, whether or not the member function is inline.
7 Member functions may be mentioned in friend declarations after their
class has been defined.
8 Member functions of a local class shall be defined inline in their
class definition, if they are defined at all.
9.3.1 Nonstatic member functions [class.mfct.nonstatic]
1 A nonstatic member function may be called for an object of its class
type, or for an object of a class derived (_class.derived_) from its
class type, using the class member access syntax (_expr.ref_,
_over.match.call_). A nonstatic member function may also be called
directly using the function call syntax (_expr.call_,
_over.match.call_)
--from within the body of a member function of its class or of a class
derived from its class, or
--from a mem-initializer (_class.base.init_) for a constructor for its
class or for a class derived from its class.
If a nonstatic member function of a class X is called for an object
that is not of type X, or of a type derived from X, the behavior is
undefined.
2 When an id-expression (_expr.prim_) that is not part of a class member
access syntax (_expr.ref_) and not used to form a pointer to member
(_expr.unary.op_) is used in the body of a nonstatic member function
of class X or used in the mem-initializer for a constructor of class
X, if name lookup (_basic.lookup.unqual_) resolves the name in the id-
expression to a nonstatic nontype member of class X or of a base class
of X, the id-expression is transformed into a class member access
expression (_expr.ref_) using (*this) (_class.this_) as the postfix-
expression to the left of the . operator. The member name then
refers to the member of the object for which the function is called.
Similarly during name lookup, when an unqualified-id (_expr.prim_)
used in the definition of a member function for class X resolves to a
static member, an enumerator or a nested type of class X or of a base
class of X, the unqualified-id is transformed into a qualified-id
(_expr.prim_) in which the nested-name-specifier names the class of
the member function. [Example:
struct tnode {
char tword[20];
int count;
tnode *left;
tnode *right;
void set(char*, tnode* l, tnode* r);
};
void tnode::set(char* w, tnode* l, tnode* r)
{
count = strlen(w)+1;
if (sizeof(tword)<=count)
error("tnode string too long");
strcpy(tword,w);
left = l;
right = r;
}
void f(tnode n1, tnode n2)
{
n1.set("abc",&n2,0);
n2.set("def",0,0);
}
In the body of the member function tnode::set, the member names tword,
count, left, and right refer to members of the object for which the
function is called. Thus, in the call n1.set("abc",&n2,0), tword
refers to n1.tword, and in the call n2.set("def",0,0), it refers to
n2.tword. The functions strlen, error, and strcpy are not members of
the class tnode and should be declared elsewhere.2)
3 The type of a nonstatic member function involves its class name; thus
the type of the qualified-id expression tnode::set is member function
type and the type of &tnode::set is pointer to member function (that
is, void (tnode::*)(char*,tnote*,tnode*), see _expr.unary.op_). ]
4 A nonstatic member function may be declared const, volatile, or const
volatile. These cv-qualifiers affect the type of the this pointer
(_class.this_). They also affect the type of the member function; a
member function declared const is a const member function, a member
function declared volatile is a volatile member function and a member
function declared const volatile is a const volatile member function.
[Example:
struct X {
void g() const;
void h() const volatile;
};
X::g is a const member function and X::h is a const volatile member
function. ]
5 A nonstatic member function may be declared virtual (_class.virtual_)
or pure virtual (_class.abstract_).
9.3.2 The this pointer [class.this]
1 In the body of a nonstatic (_class.mfct_) member function, the keyword
this is a non-lvalue expression whose value is the address of the
object for which the function is called. The type of this in a member
function of a class X is X*. If the member function is declared
const, the type of this is const X*, if the member function is
declared volatile, the type of this is volatile X*, and if the member
function is declared const volatile, the type of this is const
volatile X*.
2 In a const member function, the object for which the function is
called is accessed through a const access path; therefore, a const
member function shall not modify the object and its non-static data
members. [Example:
_________________________
2) See, for example, <cstring> (_lib.c.strings_).
struct s {
int a;
int f() const;
int g() { return a++; }
int h() const { return a++; } // error
};
int s::f() const { return a; }
The a++ in the body of s::h is ill-formed because it tries to modify
(a part of) the object for which s::h() is called. This is not
allowed in a const member function because this is a pointer to const;
that is, *this is a const. ]
3 Similarly, volatile semantics (_dcl.type.cv_) apply in volatile member
functions when accessing the object and its non-static data members.
4 A cv-qualified member function can be called on an object-expression
(_expr.ref_) only if the object-expression is as cv-qualified or less-
cv-qualified than the member function. [Example:
void k(s& x, const s& y)
{
x.f();
x.g();
y.f();
y.g(); // error
}
The call y.g() is ill-formed because y is const and s::g() is a non-
const member function, that is, s::g() is less-qualified than the
object-expression y. ]
5 Constructors (_class.ctor_) and destructors (_class.dtor_) shall not
be declared const, volatile or const volatile. [Note: However, these
functions can be invoked to create and destroy objects with cv-
qualified types, see (_class.ctor_) and (_class.dtor_). ]
9.4 Static members [class.static]
1 A data or function member of a class may be declared static in a class
definition, in which case it is a static member of the class.
2 A static member s of class X may be referred to using the qualified-id
expression X::s; it is not necessary to use the class member access
syntax (_expr.ref_) to refer to a static member. A static member may
be referred to using the class member access syntax, in which case the
object-expression is always evaluated. [Example:
class process {
public:
static void reschedule();
};
process& g();
void f()
{
process::reschedule(); // ok: no object necessary
g().reschedule(); // g() is called
}
--end example] A static member may be referred to directly in the
scope of its class or in the scope of a class derived
(_class.derived_) from its class; in this case, the static member is
referred to as if a qualified-id expression was used, with the nested-
name-specifier of the qualified-id naming the class scope from which
the static member is referred. [Example:
int g();
struct X {
static int g();
};
struct Y : X {
static int i;
}
int Y::i = g(); // equivalent to Y::g();
--end example]
3 The definition of a static member function or the initializer expres
sion for a static data member may directly use the names of the static
members, enumerators, and nested types of its class or of a base class
of its class; during name lookup (_basic.lookup.unqual_), when an
unqualified-id (_expr.prim_) used in one of these contexts resolves to
the declaration for one of these members, the unqualified-id is trans
formed into a qualified-id expression in which the nested-name-
specifier names the class scope from which the the member is referred.
The definition of a static member shall not use directly the names of
the nonstatic members of its class or of a base class of its class
(including as operands of the sizeof operator). The definition of a
static member may only refer to these members to form pointer to mem
bers (_expr.unary.op_) or with the class member access syntax
(_expr.ref_).
4 Static members obey the usual class member access rules
(_class.access_).
5 The type of a static member does not involve its class name. [Exam
ple: Thus, in the example above, the type of the qualified-id expres
sion X::g is a function type and the type of &X::g is pointer to func
tion type (that is, void(*)(), see _expr.unary.op_). ]
9.4.1 Static member functions [class.static.mfct]
1 [Note: the rules described in _class.mfct_ apply to static member
functions. ]
2 [Note: a static member function does not have a this pointer
(_class.this_). ] A static member function shall not be virtual.
There shall not be a static and a nonstatic member function with the
same name and the same parameter types (_over.load_). A static member
function shall not be declared const, volatile, or const volatile.
9.4.2 Static data members [class.static.data]
1 A static data member is not part of the subobjects of a class. There
is only one copy of a static data member shared by all the objects of
the class.
2 The declaration of a static data member in its class definition is not
a definition and may be of an incomplete type other than cv-qualified
void. A definition shall be provided for the static data member in a
namespace scope enclosing the member's class definition. In the defi
nition at namespace scope, the name of the static data member shall be
qualified by its class name using the :: operator. The initializer
expression in the definition of a static data member is in the scope
of its class (_basic.scope.class_). [Example:
class process {
static process* run_chain;
static process* running;
};
process* process::running = get_main();
process* process::run_chain = running;
The static data member run_chain of class process is defined in global
scope; the notation process::run_chain specifies that the member
run_chain is a member of class process and in the scope of class pro
cess. In the static data member definition, the initializer expres
sion refers to the static data member running of class process. ]
3 [Note: once the static data member has been defined, it exists even if
no objects of its class have been created. [Example: in the example
above, run_chain and running exist even if no objects of class process
are created by the program. ] ]
4 If a static data member is of const integral or const enumeration
type, its declaration in the class definition can specify a constant-
initializer which shall be an integral constant expression
(_expr.const_). In that case, the member can appear in integral con
stant expressions within its scope. The member shall still be defined
in a namespace scope and the definition of the member in namespace
scope shall not contain an initializer.
5 There shall be exactly one definition of a static data member in a
program; no diagnostic is required; see _basic.def.odr_.
6 Static data members of a class in namespace scope have external link
age (_basic.link_). A local class shall not have static data members.
7 Static data members are initialized and destroyed exactly like non-
local objects (_basic.start.init_, _basic.start.term_).
8 A static data member shall not be mutable (_dcl.stc_).
9.5 Unions [class.union]
1 In a union, at most one of the data members can be active at any time,
that is, the value of at most one of the data members can be stored in
a union at any time. The size of a union is sufficient to contain the
largest of its data members. Each data member is allocated as if it
were the sole member of a struct. A union can have member functions
(including constructors and destructors), but not virtual
(_class.virtual_) functions. A union shall not have base classes. A
union shall not be used as a base class. An object of a class with a
non-trivial default constructor (_class.ctor_), a non-trivial copy
constructor (_class.copy_), a non-trivial destructor (_class.dtor_),
or a non-trivial copy assignment operator (_over.ass_, _class.copy_)
cannot be a member of a union, nor can an array of such objects. If a
union contains a static data member, or a member of reference type,
the program is ill-formed.
2 A union of the form
union { member-specification } ;
is called an anonymous union; it defines an unnamed object (and not a
type). The names of the members of an anonymous union shall be dis
tinct from other names in the scope in which the union is declared;
they are used directly in that scope without the usual member access
syntax (_expr.ref_). [Example:
void f()
{
union { int a; char* p; };
a = 1;
// ...
p = "Jennifer";
// ...
}
Here a and p are used like ordinary (nonmember) variables, but since
they are union members they have the same address. ]
3 Anonymous unions declared at namespace scope shall be declared static.
All other anonymous unions shall not be declared static. An anonymous
union shall not have private or protected members (_class.access_).
An anonymous union shall not have function members.
4 A union for which objects or pointers are declared is not an anonymous
union. [Example:
union { int aa; char* p; } obj, *ptr = &obj;
aa = 1; // error
ptr->aa = 1; // ok
The assignment to plain aa is ill formed since the member name is not
visible outside the union, and even if it were visible, it is not
associated with any particular object. ] [Note: Initialization of
unions with no user-declared constructors is described in
(_dcl.init.aggr_). ]
9.6 Bit-fields [class.bit]
1 A member-declarator of the form
identifieropt : constant-expression
specifies a bit-field; its length is set off from the bit-field name
by a colon. Allocation of bit-fields within a class object is imple
mentation-defined. Alignment of bit-fields is implementation-defined.
Bit-fields are packed into some addressable allocation unit. [Note:
bit-fields straddle allocation units on some machines and not on oth
ers. Bit-fields are assigned right-to-left on some machines, left-to-
right on others. ]
2 A declaration for a bit-field that omits the identifier declares an
unnamed bit-field. Unnamed bit-fields are not members and cannot be
initialized. [Note: an unnamed bit-field is useful for padding to
conform to externally-imposed layouts. ] As a special case, an
unnamed bit-field with a width of zero specifies alignment of the next
bit-field at an allocation unit boundary.
3 A bit-field shall not be a static member. A bit-field shall have
integral or enumeration type (_basic.fundamental_). It is implementa
tion-defined whether a plain (neither explicitly signed nor unsigned)
char, wchar_t, short, int or long bit-field is signed or unsigned.
+------- BEGIN BOX 5 -------+
Change: The types char, wchar_t, short and long were added to the list
above.
+------- END BOX 5 -------+
A bool value can successfully be stored in a bit-field of any nonzero
size. The address-of operator & shall not be applied to a bit-field,
so there are no pointers to bit-fields. Nor are there references to
bit-fields.
9.7 Nested class declarations [class.nest]
1 A class can be defined within another class. A class defined within
another is called a nested class. The name of a nested class is local
to its enclosing class. The nested class is in the scope of its
enclosing class. Except by using explicit pointers, references, and
object names, declarations in a nested class can use only type names,
static members, and enumerators from the enclosing class. [Example:
int x;
int y;
class enclose {
public:
int x;
static int s;
class inner {
void f(int i)
{
int a = sizeof(x); // error: refers to enclose::x
x = i; // error: assign to enclose::x
s = i; // ok: assign to enclose::s
::x = i; // ok: assign to global x
y = i; // ok: assign to global y
}
void g(enclose* p, int i)
{
p->x = i; // ok: assign to enclose::x
}
};
};
inner* p = 0; // error `inner' not in scope
--end example]
2 The scope of a nested class has no special access to members of an
enclosing class; the usual access rules (_class.access_) shall be
obeyed. The scope of an enclosing class has no special access to mem
bers of a nested class; the usual access rules (_class.access_) shall
be obeyed. [Example:
class E {
int x;
class I {
int y;
void f(E* p, int i)
{
p->x = i; // error: E::x is private
}
};
int g(I* p)
{
return p->y; // error: I::y is private
}
};
--end example]
3 Member functions and static data members of a nested class can be
defined in a namespace scope enclosing the definition of their class.
[Example:
class enclose {
public:
class inner {
static int x;
void f(int i);
};
};
int enclose::inner::x = 1;
void enclose::inner::f(int i) { /* ... */ }
--end example]
4 If class X is defined in a namespace scope, a nested class Y may be
declared in class X and later defined in the definition of class X or
be later defined in a namespace scope enclosing the definition of
class X. [Example:
class E {
class I1; // forward declaration of nested class
class I2;
class I1 {}; // definition of nested class
};
class E::I2 {}; // definition of nested class
--end example]
5 Like a member function, a friend function (_class.friend_) defined
within a nested class is in the lexical scope of that class; it obeys
the same rules for name binding as a static member function of that
class (_class.static_) and has no special access rights to members of
an enclosing class.
9.8 Local class declarations [class.local]
1 A class can be defined within a function definition; such a class is
called a local class. The name of a local class is local to its
enclosing scope. The local class is in the scope of the enclosing
scope. Declarations in a local class can use only type names, static
variables, extern variables and functions, and enumerators from the
enclosing scope. [Example:
int x;
void f()
{
static int s ;
int x;
extern int g();
struct local {
int g() { return x; } // error: `x' is auto
int h() { return s; } // ok
int k() { return ::x; } // ok
int l() { return g(); } // ok
};
// ...
}
local* p = 0; // error: `local' not in scope
--end example]
2 An enclosing function has no special access to members of the local
class; it obeys the usual access rules (_class.access_). Member func
tions of a local class shall be defined within their class definition,
if they are defined at all.
3 If class X is a local class a nested class Y may be declared in class
X and later defined in the definition of class X or be later defined
in the same scope as the definition of class X. A local class shall
not have static data members.
9.9 Nested type names [class.nested.type]
1 Type names obey exactly the same scope rules as other names. In par
ticular, type names defined within a class definition cannot be used
outside their class without qualification. [Example:
class X {
public:
typedef int I;
class Y { /* ... */ };
I a;
};
I b; // error
Y c; // error
X::Y d; // ok
X::I e; // ok
--end example]