11 Classes [class]

11.4 Class members [class.mem]

11.4.1 General [class.mem.general]

11.4.2 Member functions [class.mfct]

11.4.3 Non-static member functions [class.mfct.non.static]

11.4.4 Special member functions [special]

11.4.5 Constructors [class.ctor]

11.4.5.1 General [class.ctor.general]

11.4.5.2 Default constructors [class.default.ctor]

11.4.5.3 Copy/move constructors [class.copy.ctor]

11.4.6 Copy/move assignment operator [class.copy.assign]

11.4.7 Destructors [class.dtor]

11.4.8 Conversions [class.conv]

11.4.8.1 General [class.conv.general]

11.4.8.2 Conversion by constructor [class.conv.ctor]

11.4.8.3 Conversion functions [class.conv.fct]

11.4.9 Static members [class.static]

11.4.9.1 General [class.static.general]

11.4.9.2 Static member functions [class.static.mfct]

11.4.9.3 Static data members [class.static.data]

11.4.10 Bit-fields [class.bit]

11.4.11 Allocation and deallocation functions [class.free]

11.4.12 Nested class declarations [class.nest]

11.4.1 General [class.mem.general]

virt-specifier:
override
final
1
#
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]
2
#
The optional function-contract-specifier-seq ([dcl.contract.func]) in a member-declarator shall be present only if the declarator declares a function.
3
#
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]
4
#
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.
5
#
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.
6
#
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).
7
#
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.
8
#
A member shall not be declared twice in the member-specification, except that
[Note 3: 
A single name can denote several member functions provided their types are sufficiently different ([basic.scope.scope]).
— end note]
9
#
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.
10
#
A complete-class context of a class (template) is a 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]
11
#
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.
12
#
If a member-declaration matches the syntactic requirements of friend-type-declaration, it is a friend-type-declaration.
13
#
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]
14
#
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]
15
#
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.
16
#
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.
17
#
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.
18
#
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.
19
#
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]).
20
#
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]
21
#
[Note 6: 
See [expr.prim.id] for restrictions on the use of non-static data members and non-static member functions.
— end note]
22
#
[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]
23
#
[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]
24
#
[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]
25
#
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.
26
#
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.
27
#
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
[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]
28