11 Classes [class]

In the absence of a virt-specifier-seq, the token sequence = 0 is treated as a pure-specifier if the type of the declarator-id ([dcl.meaning.general]) is a function type, and is otherwise treated as a brace-or-equal-initializer.

[Note 1:

If the member declaration acquires a function type through template instantiation, the program is ill-formed; see [temp.spec.general].

— end note]

The optional function-contract-specifier-seq ([dcl.contract.func]) in a member-declarator shall be present only if the declarator declares a function.

The member-specification in a class definition declares the full set of members of the class; no member can be added elsewhere.

A direct member of a class X is a member of X that was first declared within the member-specification of X, including anonymous union members ([class.union.anon]) and direct members thereof.

Members of a class are data members, member functions ([class.mfct]), nested types, enumerators, and member templates ([temp.mem]) and specializations thereof.

[Note 2:

A specialization of a static data member template is a static data member.

A specialization of a member function template is a member function.

A specialization of a member class template is a nested class.

— end note]

A member-declaration does not itself declare new members of the class if it is

(4.1)
a friend declaration ([class.friend]),
(4.2)
a deduction-guide ([temp.deduct.guide]),
(4.3)
a template-declaration whose declaration is one of the above,
(4.4)
a static_assert-declaration,
(4.5)
a consteval-block-declaration,
(4.6)
a using-declaration ([namespace.udecl]), or
(4.7)
an empty-declaration.

For any other member-declaration, each declared entity that is not an unnamed bit-field is a member of the class, and each such member-declaration shall either declare at least one member name of the class or declare at least one unnamed bit-field.

A user-declared entity is a direct member or a friend that, in either case, is declared by a member-declaration.

A data member is either a non-function member introduced by a member-declarator or an anonymous union member.

A member function is a member that is a function.

Nested types are classes ([class.name], [class.nest]) and enumerations ([dcl.enum]) declared in the class and arbitrary types declared as members by use of a typedef declaration ([dcl.typedef]) or alias-declaration.

The enumerators of an unscoped enumeration defined in the class are members of the class.

A data member or member function may be declared static in its member-declaration, in which case it is a static member (see [class.static]) (a static data member ([class.static.data]) or static member function ([class.static.mfct]), respectively) of the class.

Any other data member or member function is a non-static member (a non-static data member or non-static member function ([class.mfct.non.static]), respectively).

Every object of class type has a unique member subobject corresponding to each of its direct non-static data members.

If any non-static data member of a class C is of reference type, then let D be an invented class that is identical to C except that each non-static member of D corresponding to a member of C of type “reference to T” instead has type “pointer to T”.

Every member subobject of a complete object of type C has the same size, alignment, and offset as that of the corresponding subobject of a complete object of type D.

The size and alignment of C are the same as the size and alignment of D.

A member shall not be declared twice in the member-specification, except that

(8.1)
a nested class or member class template can be declared and then later defined, and
(8.2)
an enumeration can be introduced with an opaque-enum-declaration and later redeclared with an enum-specifier.

[Note 3:

A single name can denote several member functions provided their types are sufficiently different ([basic.scope.scope]).

— end note]

A redeclaration of a class member outside its class definition shall be a definition, an explicit specialization, or an explicit instantiation ([temp.expl.spec], [temp.explicit]).

The member shall not be a non-static data member.

A complete-class context of a class (template) is a

(10.1)
function body ([dcl.fct.def.general]),
(10.2)
default argument ([dcl.fct.default]),
(10.3)
default template argument ([temp.param]),
(10.4)
noexcept-specifier ([except.spec]),
(10.5)
function-contract-specifier ([dcl.contract.func]), or
(10.6)
default member initializer

within the member-specification of the class or class template.

[Note 4:

A complete-class context of a nested class is also a complete-class context of any enclosing class, if the nested class is defined within the member-specification of the enclosing class.

— end note]

A class C is complete at a program point P if the definition of C is reachable from P ([module.reach]) or if P is in a complete-class context of C.

Otherwise, C is incomplete at P.

If a member-declaration matches the syntactic requirements of friend-type-declaration, it is a friend-type-declaration.

In a member-declarator, an = immediately following the declarator is interpreted as introducing a pure-specifier if the declarator-id has function type, otherwise it is interpreted as introducing a brace-or-equal-initializer.

[Example 1: struct S { using T = void(); T * p = 0; // OK, brace-or-equal-initializer virtual T f = 0; // OK, pure-specifier }; — end example]

In a member-declarator for a bit-field, the constant-expression is parsed as the longest sequence of tokens that could syntactically form a constant-expression.

[Example 2: int a; const int b = 0; struct S { int x1 : 8 = 42; // OK, "= 42" is brace-or-equal-initializer int x2 : 8 { 42 }; // OK, "{ 42 }" is brace-or-equal-initializer int y1 : true ? 8 : a = 42; // OK, brace-or-equal-initializer is absent int y2 : true ? 8 : b = 42; // error: cannot assign to const int int y3 : (true ? 8 : b) = 42; // OK, "= 42" is brace-or-equal-initializer int z : 1 || new int { 0 }; // OK, brace-or-equal-initializer is absent }; — end example]

A brace-or-equal-initializer shall appear only in the declaration of a data member.

(For static data members, see [class.static.data]; for non-static data members, see [class.base.init] and [dcl.init.aggr]).

A brace-or-equal-initializer for a non-static data member specifies a default member initializer for the member, and shall not directly or indirectly cause the implicit definition of a defaulted default constructor for the enclosing class or the exception specification of that constructor.

An immediate invocation ([expr.const.imm]) that is a potentially-evaluated subexpression ([intro.execution]) of a default member initializer is neither evaluated nor checked for whether it is a constant expression at the point where the subexpression appears.

A member shall not be declared with the extern storage-class-specifier.

Within a class definition, a member shall not be declared with the thread_local storage-class-specifier unless also declared static.

The decl-specifier-seq may be omitted in constructor, destructor, and conversion function declarations only; when declaring another kind of member the decl-specifier-seq shall contain a type-specifier that is not a cv-qualifier.

The member-declarator-list can be omitted only after a class-specifier or an enum-specifier or in a friend declaration .

A pure-specifier shall be used only in the declaration of a virtual function that is not a friend declaration.

The optional attribute-specifier-seq in a member-declaration appertains to each of the entities declared by the member-declarators; it shall not appear if the optional member-declarator-list is omitted.

A virt-specifier-seq shall contain at most one of each virt-specifier.

A virt-specifier-seq shall appear only in the first declaration of a virtual member function ([class.virtual]).

The type of a non-static data member shall not be an incomplete type ([basic.types.general]), an abstract class type ([class.abstract]), or a (possibly multidimensional) array thereof.

[Note 5:

In particular, a class C cannot contain a non-static member of class C, but it can contain a pointer or reference to an object of class C.

— end note]

[Note 6:

See [expr.prim.id] for restrictions on the use of non-static data members and non-static member functions.

— end note]

[Note 7:

The type of a non-static member function is an ordinary function type, and the type of a non-static data member is an ordinary object type.

There are no special member function types or data member types.

— end note]

[Example 3:

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 objects of the same type.

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 object to which sp points; s.left refers to the left subtree pointer of the object s; and s.right->tword[0] refers to the initial character of the tword member of the right subtree of s.

— end example]

[Note 8:

Non-variant non-static data members of non-zero size ([intro.object]) are allocated so that later members have higher addresses within a class object ([expr.rel]).

Implementation alignment requirements can cause two adjacent members not to be allocated immediately after each other; so can requirements for space for managing virtual functions ([class.virtual]) and virtual base classes ([class.mi]).

— end note]

If T is the name of a class, then each of the following shall have a name different from T:

(25.1)
every static data member of class T;
(25.2)
every member function of class T;
[Note 9:
This restriction does not apply to constructors, which do not have names ([class.ctor]).
— end note]
(25.3)
every member of class T that is itself a type;
(25.4)
every member template of class T;
(25.5)
every enumerator of every member of class T that is an unscoped enumeration type; and
(25.6)
every member of every anonymous union that is a member of class T.

In addition, if class T has a user-declared constructor, every non-static data member of class T shall have a name different from T.

The common initial sequence of two standard-layout struct ([class.prop]) types is the longest sequence of non-static data members and bit-fields in declaration order, starting with the first such entity in each of the structs, such that

(27.1)
corresponding entities have layout-compatible types ([basic.types]),
(27.2)
corresponding entities have the same alignment requirements ([basic.align]),
(27.3)
if a has-attribute-expression ([cpp.cond]) is not 0 for the no_unique_address attribute, then neither entity is declared with the no_unique_address attribute ([dcl.attr.nouniqueaddr]), and
(27.4)
either both entities are bit-fields with the same width or neither is a bit-field.

[Example 4: struct A { int a; char b; }; struct B { const int b1; volatile char b2; }; struct C { int c; unsigned : 0; char b; }; struct D { int d; char b : 4; }; struct E { unsigned int e; char b; };

The common initial sequence of A and B comprises all members of either class.

The common initial sequence of A and C and of A and D comprises the first member in each case.

The common initial sequence of A and E is empty.

— end example]

Two standard-layout struct ([class.prop]) types are layout-compatible classes if their common initial sequence comprises all members and bit-fields of both classes ([basic.types]).

Two standard-layout unions are layout-compatible if they have the same number of non-static data members and corresponding non-static data members (in any order) have layout-compatible types ([basic.types.general]).

In a standard-layout union with an active member of struct type T1, it is permitted to read a non-static data member m of another union member of struct type T2 provided m is part of the common initial sequence of T1 and T2; the behavior is as if the corresponding member of T1 were nominated.

[Example 5: struct T1 { int a, b; }; struct T2 { int c; double d; }; union U { T1 t1; T2 t2; }; int f() { U u = { { 1, 2 } }; // active member is t1 return u.t2.c; // OK, as if u.t1.a were nominated } — end example]

[Note 10:

Reading a volatile object through a glvalue of non-volatile type has undefined behavior ([dcl.type.cv]).

— end note]

If a standard-layout class object has any non-static data members, its address is the same as the address of its first non-static data member if that member is not a bit-field.

Its address is also the same as the address of each of its base class subobjects.

[Note 11:

There can therefore be unnamed padding within a standard-layout struct object inserted by an implementation, but not at its beginning, as necessary to achieve appropriate alignment.

— end note]

[Note 12:

The object and its first subobject are pointer-interconvertible ([basic.compound], [expr.static.cast]).

— end note]

A data member description is a sextuple (T, N, A, W, NUA, ANN) describing the potential declaration of a non-static data member where

(32.1)
T is a type,
(32.2)
N is an identifier or ⊥,
(32.3)
A is an alignment or ⊥,
(32.4)
W is a bit-field width or ⊥,
(32.5)
NUA is a boolean value, and
(32.6)
ANN is a sequence of reflections representing either values or template parameter objects.

Two data member descriptions are equal if each of their respective components are the same entity, the same identifier, the same value, the same sequence, or both ⊥.

[Note 13:

The components of a data member description describe a data member such that

(32.7)
its type is specified using the type given by T,
(32.8)
it is declared with the name given by N if N is not ⊥ and is otherwise unnamed,
(32.9)
it is declared with the alignment-specifier ([dcl.align]) given by alignas(A) if A is not ⊥ and is otherwise declared without an alignment-specifier,
(32.10)
it is a bit-field ([class.bit]) with the width given by W if W is not ⊥ and is otherwise not a bit-field, and
(32.11)
it is declared with the attribute [[no_unique_address]] ([dcl.attr.nouniqueaddr]) if NUA is true and is otherwise declared without that attribute.

Data member descriptions are represented by reflections ([basic.fundamental]) returned by std::meta::data_member_spec ([meta.reflection.define.aggregate]) and can be reified as data members of a class using std::meta::define_aggregate.

— end note]