[class.mem] - C++17 → C++20

Files changed (1) hide show

tmp/tmpn5839xo_/{from.md → to.md} +1491 -240

tmp/tmpn5839xo_/{from.md → to.md} RENAMED Viewed

@@ -9,14 +9,17 @@ member-specification:
 ``` bnf
 member-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
     function-definition
     using-declaration
     static_assert-declaration
     template-declaration
     deduction-guide
     alias-declaration
     empty-declaration
 ```
 ``` bnf
 member-declarator-list:
@@ -25,96 +28,108 @@ member-declarator-list:
 ```
 ``` bnf
 member-declarator:
     declarator virt-specifier-seqₒₚₜ pure-specifierₒₚₜ
     declarator brace-or-equal-initializerₒₚₜ
-    identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression
 ```
 ``` bnf
 virt-specifier-seq:
     virt-specifier
     virt-specifier-seq virt-specifier
 ```
 ``` bnf
 virt-specifier:
- 'override'
- 'final'
 ```
 ``` bnf
 pure-specifier:
-    '= 0'
 ```
 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 objects (
-[[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 1*: 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 declare new members of the class if it
 is
-- a friend declaration ([[class.friend]]),
 - a *static_assert-declaration*,
-- a *using-declaration* ([[namespace.udecl]]), or
 - an *empty-declaration*.
 For any other *member-declaration*, each declared entity that is not an
-unnamed bit-field ([[class.bit]]) 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 *data member* is a non-function member introduced by a
 *member-declarator*. 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 (
-[[dcl.enum]]) 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).
 [*Note 2*: A non-static data member of non-reference type is a member
-subobject of a class object ([[intro.object]]). — *end note*]
 A member shall not be declared twice in the *member-specification*,
 except that
 - a nested class or member class template can be declared and then later
   defined, and
 - 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 (Clause
-[[over]]). — *end note*]
-A class is considered a completely-defined object type (
-[[basic.types]]) (or complete type) at the closing `}` of the
-*class-specifier*. Within the class *member-specification*, the class is
-regarded as complete within function bodies, default arguments,
-*noexcept-specifier*s, and default member initializers (including such
-things in nested classes). Otherwise it is regarded as incomplete within
-its own class *member-specification*.
 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*.
@@ -129,10 +144,31 @@ struct S {
 };
 ```
 — *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
@@ -147,36 +183,40 @@ 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 ([[class.friend]]). A *pure-specifier* shall be used only
-in the declaration of a virtual function ([[class.virtual]]) 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-declarator*s;
 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
-declaration of a virtual member function ([[class.virtual]]).
-Non-static data members shall not have incomplete types. In particular,
-a class `C` shall not contain a non-static member of class `C`, but it
-can contain a pointer or reference to an object of class `C`.
-[*Note 4*: See  [[expr.prim]] for restrictions on the use of non-static
-data members and non-static member functions. — *end note*]
-[*Note 5*: 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 2*:
 A simple example of a class definition is
 ``` cpp
 struct tnode {
@@ -201,44 +241,47 @@ 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*]
-Non-static data members of a (non-union) class with the same access
-control (Clause  [[class.access]]) are allocated so that later members
-have higher addresses within a class object. The order of allocation of
-non-static data members with different access control is unspecified
-(Clause  [[class.access]]). Implementation alignment requirements 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]]).
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
 - every static data member of class `T`;
-- every member function of class `T` \[*Note 6*: This restriction does
-  not apply to constructors, which do not have names (
-  [[class.ctor]]) — *end note*] ;
 - every member of class `T` that is itself a type;
 - every member template of class `T`;
 - every enumerator of every member of class `T` that is an unscoped
   enumerated type; and
 - every member of every anonymous union that is a member of class `T`.
-In addition, if class `T` has a user-declared constructor (
-[[class.ctor]]), every non-static data member of class `T` shall have a
 name different from `T`.
-The *common initial sequence* of two standard-layout struct (Clause
-[[class]]) 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 corresponding entities have
-layout-compatible types and either neither entity is a bit-field or both
-are bit-fields with the same width.
-[*Example 3*:
 ``` cpp
 struct A { int a; char b; };
 struct B { const int b1; volatile char b2; };
 struct C { int c; unsigned : 0; char b; };
@@ -251,25 +294,25 @@ 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 (Clause  [[class]]) 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]]).
-In a standard-layout union with an active member ([[class.union]]) 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 4*:
 ``` cpp
 struct T1 { int a, b; };
 struct T2 { int c; double d; };
 union U { T1 t1; T2 t2; };
@@ -279,61 +322,61 @@ int f() {
 }
 ```
 — *end example*]
-[*Note 7*: Reading a volatile object through a non-volatile glvalue 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.
-Otherwise, its address is the same as the address of its first base
-class subobject (if any).
-[*Note 8*: There might therefore be unnamed padding within a
-standard-layout struct object, but not at its beginning, as necessary to
-achieve appropriate alignment. — *end note*]
-[*Note 9*: The object and its first subobject are
 pointer-interconvertible ([[basic.compound]],
 [[expr.static.cast]]). — *end note*]
 ### Member functions <a id="class.mfct">[[class.mfct]]</a>
-A member function may be defined ([[dcl.fct.def]]) in its class
-definition, in which case it is an *inline* member function (
-[[dcl.inline]]), 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 member function definitions that appear outside of a class
-definition, and except for explicit specializations of member functions
-of class templates and member function templates ([[temp.spec]])
 appearing outside of the class definition, a member function shall not
 be redeclared.
-An inline member function (whether static or non-static) may also be
-defined outside of its class definition provided either its declaration
-in the class definition or its definition outside of the class
-definition declares the function as `inline` or `constexpr`.
-[*Note 1*: Member functions of a class in namespace scope have the
-linkage of that class. Member functions of a local class (
-[[class.local]]) have no linkage. See  [[basic.link]]. — *end note*]
 [*Note 2*: There can be at most one definition of a non-inline member
-function in a program. There may be more than one `inline` member
-function definition in a program. See  [[basic.def.odr]] and
 [[dcl.inline]]. — *end note*]
 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.
-[*Note 3*: A name used in a member function definition (that is, in the
-*parameter-declaration-clause* including the default arguments (
-[[dcl.fct.default]]) or in the member function body) is looked up as
 described in  [[basic.lookup]]. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -352,21 +395,21 @@ 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`.
 — *end example*]
-[*Note 4*: A `static` local variable or local type in a member function
 always refers to the same entity, whether or not the member function is
-`inline`. — *end note*]
-Previously declared member functions may be mentioned in `friend`
 declarations.
 Member functions of a local class shall be defined inline in their class
 definition, if they are defined at all.
-[*Note 5*:
 A member function can be declared (but not defined) using a typedef for
 a function type. The resulting member function has exactly the same type
 as it would have if the function declarator were provided explicitly,
 see  [[dcl.fct]]. For example,
@@ -389,42 +432,37 @@ Also see  [[temp.arg]].
 — *end note*]
 ### Non-static member functions <a id="class.mfct.non-static">[[class.mfct.non-static]]</a>
 A non-static member function may be called for an object of its class
-type, or for an object of a class derived (Clause  [[class.derived]])
-from its class type, using the class member access syntax (
-[[expr.ref]],  [[over.match.call]]). A non-static 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.
 If a non-static 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.
-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 a member of class `X` in a
-context where `this` can be used ([[expr.prim.this]]), if name lookup (
-[[basic.lookup]]) resolves the name in the *id-expression* to a
 non-static non-type member of some class `C`, and if either the
 *id-expression* is potentially evaluated or `C` is `X` or 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.
 [*Note 1*: If `C` is not `X` or a base class of `X`, the class member
 access expression is ill-formed. — *end note*]
-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. These transformations do not
-apply in the template definition context ([[temp.dep.type]]).
 [*Example 1*:
 ``` cpp
 struct tnode {
@@ -453,55 +491,52 @@ void f(tnode n1, tnode n2) {
 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`, `perror`, and `strcpy` are
-not members of the class `tnode` and should be declared elsewhere.[^4]
 — *end example*]
 A non-static member function may be declared `const`, `volatile`, or
 `const` `volatile`. These *cv-qualifier*s affect the type of the `this`
-pointer ([[class.this]]). They also affect the function type (
-[[dcl.fct]]) 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 2*:
 ``` cpp
 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.
 — *end example*]
-A non-static member function may be declared with a *ref-qualifier* (
-[[dcl.fct]]); see  [[over.match.funcs]].
-A non-static member function may be declared *virtual* (
-[[class.virtual]]) or *pure virtual* ([[class.abstract]]).
 #### The `this` pointer <a id="class.this">[[class.this]]</a>
-In the body of a non-static ([[class.mfct]]) member function, the
-keyword `this` is a prvalue 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*`.
-[*Note 1*: Thus in a `const` member function, the object for which the
-function is called is accessed through a `const` access
 path. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -515,22 +550,23 @@ struct s {
 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` has `const` type.
 — *end example*]
-Similarly, `volatile` semantics ([[dcl.type.cv]]) apply in `volatile`
-member functions when accessing the object and its non-static data
-members.
-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 2*:
 ``` cpp
 void k(s& x, const s& y) {
@@ -540,29 +576,1253 @@ void k(s& x, const s& y) {
   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`.
 — *end example*]
-Constructors ([[class.ctor]]) and destructors ([[class.dtor]]) shall
-not be declared `const`, `volatile` or `const` `volatile`.
-[*Note 2*: However, these functions can be invoked to create and
-destroy objects with cv-qualified types, see  [[class.ctor]] and
-[[class.dtor]]. — *end note*]
 ### Static members <a id="class.static">[[class.static]]</a>
 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 evaluated.
 [*Example 1*:
 ``` cpp
 struct process {
@@ -577,15 +1837,15 @@ void f() {
 ```
 — *end example*]
 A static member may be referred to directly in the scope of its class or
-in the scope of a class derived (Clause  [[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 referenced.
 [*Example 2*:
 ``` cpp
 int g();
@@ -598,59 +1858,53 @@ struct Y : X {
 int Y::i = g();                 // equivalent to Y::g();
 ```
 — *end example*]
-If an *unqualified-id* ([[expr.prim]]) is used in the definition of a
-static member following the member’s *declarator-id*, and name lookup (
-[[basic.lookup.unqual]]) finds that the *unqualified-id* refers to a
-static member, enumerator, or nested type of the member’s class (or of a
-base class of the member’s class), the *unqualified-id* is transformed
-into a *qualified-id* expression in which the *nested-name-specifier*
-names the class scope from which the member is referenced.
-[*Note 1*: See  [[expr.prim]] for restrictions on the use of non-static
-data members and non-static member functions. — *end note*]
-Static members obey the usual class member access rules (Clause
-[[class.access]]). When used in the declaration of a class member, the
 `static` specifier shall only be used in the member declarations that
 appear within the *member-specification* of the class definition.
-[*Note 2*: It cannot be specified in member declarations that appear in
 namespace scope. — *end note*]
 #### Static member functions <a id="class.static.mfct">[[class.static.mfct]]</a>
 [*Note 1*: The rules described in  [[class.mfct]] apply to static
 member functions. — *end note*]
-[*Note 2*: A static member function does not have a `this` pointer (
-[[class.this]]). — *end note*]
 A static member function shall not be `virtual`. There shall not be a
 static and a non-static 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`.
 #### Static data members <a id="class.static.data">[[class.static.data]]</a>
 A static data member is not part of the subobjects of a class. If a
 static data member is declared `thread_local` there is one copy of the
 member per thread. If a static data member is not declared
 `thread_local` there is one copy of the data member that is shared by
 all the objects of the class.
 The declaration of a non-inline static data member in its class
 definition is not a definition and may be of an incomplete type other
 than cv `void`. The definition for a static data member that is not
 defined inline in the class definition shall appear in a namespace scope
 enclosing the member’s class definition. In the definition 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 1*:
 ``` cpp
 class process {
@@ -686,92 +1940,89 @@ of class `process` are created by the program.
 — *end note*]
 If a non-volatile non-inline `const` static data member is of integral
 or enumeration type, its declaration in the class definition can specify
 a *brace-or-equal-initializer* in which every *initializer-clause* that
-is an *assignment-expression* is a constant expression (
-[[expr.const]]). The member shall still be defined in a namespace scope
-if it is odr-used ([[basic.def.odr]]) in the program and the namespace
-scope definition shall not contain an *initializer*. An inline static
-data member may be defined in the class definition and may specify a
 *brace-or-equal-initializer*. If the member is declared with the
 `constexpr` specifier, it may be redeclared in namespace scope with no
-initializer (this usage is deprecated; see [[depr.static_constexpr]]).
 Declarations of other static data members shall not specify a
 *brace-or-equal-initializer*.
-[*Note 2*: There shall be exactly one definition of a static data
-member that is odr-used ([[basic.def.odr]]) in a program; no diagnostic
-is required. — *end note*]
-Unnamed classes and classes contained directly or indirectly within
-unnamed classes shall not contain static data members.
 [*Note 3*: Static data members of a class in namespace scope have the
-linkage of that class ([[basic.link]]). A local class cannot have
-static data members ([[class.local]]). — *end note*]
 Static data members are initialized and destroyed exactly like non-local
 variables ([[basic.start.static]], [[basic.start.dynamic]],
 [[basic.start.term]]).
-A static data member shall not be `mutable` ([[dcl.stc]]).
 ### Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
-specifies a bit-field; its length is set off from the bit-field name by
-a colon. The optional *attribute-specifier-seq* appertains to the entity
-being declared. The bit-field attribute is not part of the type of the
-class member. The *constant-expression* shall be an integral constant
-expression with a value greater than or equal to zero. The value of the
-integral constant expression may be larger than the number of bits in
-the object representation ([[basic.types]]) of the bit-field’s type; in
-such cases the extra bits are used as padding bits and do not
-participate in the value representation ([[basic.types]]) of the
-bit-field. Allocation of bit-fields within a class object is
-*implementation-defined*. Alignment of bit-fields is
-*implementation-defined*. Bit-fields are packed into some addressable
-allocation unit.
 [*Note 1*: Bit-fields straddle allocation units on some machines and
 not on others. Bit-fields are assigned right-to-left on some machines,
 left-to-right on others. — *end note*]
 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 2*: An unnamed bit-field is useful for padding to conform to
 externally-imposed layouts. — *end note*]
 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. Only
-when declaring an unnamed bit-field may the value of the
-*constant-expression* be equal to zero.
-A bit-field shall not be a static member. A bit-field shall have
-integral or enumeration type ([[basic.fundamental]]). 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. A non-const reference shall not be bound
-to a bit-field ([[dcl.init.ref]]).
 [*Note 3*: If the initializer for a reference of type `const` `T&` is
 an lvalue that refers to a bit-field, the reference is bound to a
 temporary initialized to hold the value of the bit-field; the reference
 is not bound to the bit-field directly. See
 [[dcl.init.ref]]. — *end note*]
-If the value `true` or `false` is stored into a bit-field of type `bool`
-of any size (including a one bit bit-field), the original `bool` value
-and the value of the bit-field shall compare equal. If the value of an
-enumerator is stored into a bit-field of the same enumeration type and
-the number of bits in the bit-field is large enough to hold all the
-values of that enumeration type ([[dcl.enum]]), the original enumerator
-value and the value of the bit-field shall compare equal.
 [*Example 1*:
 ``` cpp
 enum BOOL { FALSE=0, TRUE=1 };
@@ -789,16 +2040,16 @@ void f() {
 — *end example*]
 ### Nested class declarations <a id="class.nest">[[class.nest]]</a>
 A class can be declared within another class. A class declared 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.
-[*Note 1*: See  [[expr.prim]] for restrictions on the use of non-static
-data members and non-static member functions. — *end note*]
 [*Example 1*:
 ``` cpp
 int x;
@@ -863,15 +2114,15 @@ class E {
 class E::I2 { };                // definition of nested class
 ```
 — *end example*]
-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]]), but it has no special access rights to
-members of an enclosing class.
 ### Nested type names <a id="class.nested.type">[[class.nested.type]]</a>
 Type names obey exactly the same scope rules as other names. In
 particular, type names defined within a class definition cannot be used

 ``` bnf
 member-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
     function-definition
     using-declaration
+    using-enum-declaration
     static_assert-declaration
     template-declaration
+    explicit-specialization
     deduction-guide
     alias-declaration
+    opaque-enum-declaration
     empty-declaration
 ```
 ``` bnf
 member-declarator-list:
 ```
 ``` bnf
 member-declarator:
     declarator virt-specifier-seqₒₚₜ pure-specifierₒₚₜ
+    declarator requires-clause
     declarator brace-or-equal-initializerₒₚₜ
+    identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
 ```
 ``` bnf
 virt-specifier-seq:
     virt-specifier
     virt-specifier-seq virt-specifier
 ```
 ``` bnf
 virt-specifier:
+    override
+    final
 ```
 ``` bnf
 pure-specifier:
+    '=' '0'
 ```
 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 objects
+[[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 1*: 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 declare new members of the class if it
 is
+- a friend declaration [[class.friend]],
 - a *static_assert-declaration*,
+- a *using-declaration* [[namespace.udecl]], or
 - an *empty-declaration*.
 For any other *member-declaration*, each declared entity that is not an
+unnamed bit-field [[class.bit]] 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 *data member* is a non-function member introduced by a
 *member-declarator*. 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
+[[dcl.enum]] 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).
 [*Note 2*: A non-static data member of non-reference type is a member
+subobject of a class object [[intro.object]]. — *end note*]
 A member shall not be declared twice in the *member-specification*,
 except that
 - a nested class or member class template can be declared and then later
   defined, and
 - 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 [[over.load]]. — *end note*]
+A *complete-class context* of a class is a
+- function body [[dcl.fct.def.general]],
+- default argument [[dcl.fct.default]],
+- *noexcept-specifier* [[except.spec]], or
+- default member initializer
+within the *member-specification* of the class.
+[*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 is considered a completely-defined object type [[basic.types]]
+(or complete type) at the closing `}` of the *class-specifier*. The
+class is regarded as complete within its complete-class contexts;
+otherwise it is regarded as incomplete within its own class
+*member-specification*.
 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*.
 };
 ```
 — *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*:
+``` cpp
+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
 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 [[class.friend]]. A *pure-specifier* shall be used only in
+the declaration of a virtual function [[class.virtual]] 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-declarator*s;
 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]], an abstract class type [[class.abstract]], or a
+(possibly multi-dimensional) 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
 ``` cpp
 struct tnode {
 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-static data members of a (non-union) class with the
+same access control [[class.access]] and non-zero size [[intro.object]]
+are allocated so that later members have higher addresses within a class
+object. The order of allocation of non-static data members with
+different access control is unspecified. Implementation alignment
+requirements 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]]. — *end note*]
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
 - every static data member of class `T`;
+- every member function of class `T` \[*Note 9*: This restriction does
+  not apply to constructors, which do not have names
+  [[class.ctor]] — *end note*] ;
 - every member of class `T` that is itself a type;
 - every member template of class `T`;
 - every enumerator of every member of class `T` that is an unscoped
   enumerated type; and
 - every member of every anonymous union that is a member of class `T`.
+In addition, if class `T` has a user-declared constructor
+[[class.ctor]], 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 corresponding entities have
+layout-compatible types, either both entities are declared with the
+`no_unique_address` attribute [[dcl.attr.nouniqueaddr]] or neither is,
+and either both entities are bit-fields with the same width or neither
+is a bit-field.
+[*Example 4*:
 ``` cpp
 struct A { int a; char b; };
 struct B { const int b1; volatile char b2; };
 struct C { int c; unsigned : 0; char b; };
 `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]].
+In a standard-layout union with an active member [[class.union]] 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*:
 ``` cpp
 struct T1 { int a, b; };
 struct T2 { int c; double d; };
 union U { T1 t1; T2 t2; };
 }
 ```
 — *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 might 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*]
 ### Member functions <a id="class.mfct">[[class.mfct]]</a>
+A member function may be defined [[dcl.fct.def]] in its class
+definition, in which case it is an inline [[dcl.inline]] member function
+if it is attached to the global module, or it may be defined outside of
+its class definition if it has already been declared but not defined in
+its class definition.
+[*Note 1*: A member function is also inline if it is declared `inline`,
+`constexpr`, or `consteval`. — *end note*]
+A member function definition that appears outside of the class
+definition shall appear in a namespace scope enclosing the class
+definition. Except for member function definitions that appear outside
+of a class definition, and except for explicit specializations of member
+functions of class templates and member function templates [[temp.spec]]
 appearing outside of the class definition, a member function shall not
 be redeclared.
 [*Note 2*: There can be at most one definition of a non-inline member
+function in a program. There may be more than one inline member function
+definition in a program. See  [[basic.def.odr]] and
 [[dcl.inline]]. — *end note*]
+[*Note 3*: Member functions of a class have the linkage of the name of
+the class. See  [[basic.link]]. — *end note*]
 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.
+[*Note 4*: A name used in a member function definition (that is, in the
+*parameter-declaration-clause* including the default arguments
+[[dcl.fct.default]] or in the member function body) is looked up as
 described in  [[basic.lookup]]. — *end note*]
 [*Example 1*:
 ``` cpp
 default argument `count` refers to the static data member `count`
 declared in class `X`.
 — *end example*]
+[*Note 5*: A `static` local variable or local type in a member function
 always refers to the same entity, whether or not the member function is
+inline. — *end note*]
+Previously declared member functions may be mentioned in friend
 declarations.
 Member functions of a local class shall be defined inline in their class
 definition, if they are defined at all.
+[*Note 6*:
 A member function can be declared (but not defined) using a typedef for
 a function type. The resulting member function has exactly the same type
 as it would have if the function declarator were provided explicitly,
 see  [[dcl.fct]]. For example,
 — *end note*]
 ### Non-static member functions <a id="class.mfct.non-static">[[class.mfct.non-static]]</a>
 A non-static 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 non-static member function may also be called
+directly using the function call syntax ([[expr.call]],
+[[over.match.call]]) from within its class or a class derived from its
+class, or a member thereof, as described below.
 If a non-static 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.
+When an *id-expression* [[expr.prim.id]] 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 a member of class `X` in a context
+where `this` can be used [[expr.prim.this]], if name lookup
+[[basic.lookup]] resolves the name in the *id-expression* to a
 non-static non-type member of some class `C`, and if either the
 *id-expression* is potentially evaluated or `C` is `X` or 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.
 [*Note 1*: If `C` is not `X` or a base class of `X`, the class member
 access expression is ill-formed. — *end note*]
+This transformation does not apply in the template definition context
+[[temp.dep.type]].
 [*Example 1*:
 ``` cpp
 struct tnode {
 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`, `perror`, and `strcpy` are
+not members of the class `tnode` and should be declared elsewhere.[^2]
 — *end example*]
 A non-static member function may be declared `const`, `volatile`, or
 `const` `volatile`. These *cv-qualifier*s affect the type of the `this`
+pointer [[class.this]]. They also affect the function type [[dcl.fct]]
+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 2*:
 ``` cpp
 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.
 — *end example*]
+A non-static member function may be declared with a *ref-qualifier*
+[[dcl.fct]]; see  [[over.match.funcs]].
+A non-static member function may be declared virtual [[class.virtual]]
+or pure virtual [[class.abstract]].
 #### The `this` pointer <a id="class.this">[[class.this]]</a>
+In the body of a non-static [[class.mfct]] member function, the keyword
+`this` is a prvalue whose value is a pointer to the object for which the
+function is called. The type of `this` in a member function whose type
+has a *cv-qualifier-seq* cv and whose class is `X` is “pointer to cv
+`X`”.
+[*Note 1*: Thus in a const member function, the object for which the
+function is called is accessed through a const access
 path. — *end note*]
 [*Example 1*:
 ``` cpp
 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` has `const` type.
 — *end example*]
+[*Note 2*: Similarly, `volatile` semantics [[dcl.type.cv]] apply in
+volatile member functions when accessing the object and its non-static
+data members. — *end note*]
+A member function whose type has a *cv-qualifier-seq* *cv1* can be
+called on an object expression [[expr.ref]] of type *cv2* `T` only if
+*cv1* is the same as or more cv-qualified than *cv2*
+[[basic.type.qualifier]].
 [*Example 2*:
 ``` cpp
 void k(s& x, const s& y) {
   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`.
 — *end example*]
+[*Note 3*: Constructors and destructors cannot be declared `const`,
+`volatile`, or `const` `volatile`. However, these functions can be
+invoked to create and destroy objects with cv-qualified types; see
+[[class.ctor]] and  [[class.dtor]]. — *end note*]
+### Special member functions <a id="special">[[special]]</a>
+Default constructors [[class.default.ctor]], copy constructors, move
+constructors [[class.copy.ctor]], copy assignment operators, move
+assignment operators [[class.copy.assign]], and prospective destructors
+[[class.dtor]] are *special member functions*.
+[*Note 1*: The implementation will implicitly declare these member
+functions for some class types when the program does not explicitly
+declare them. The implementation will implicitly define them if they are
+odr-used [[basic.def.odr]] or needed for constant evaluation
+[[expr.const]]. — *end note*]
+An implicitly-declared special member function is declared at the
+closing `}` of the *class-specifier*. Programs shall not define
+implicitly-declared special member functions.
+Programs may explicitly refer to implicitly-declared special member
+functions.
+[*Example 1*:
+A program may explicitly call or form a pointer to member to an
+implicitly-declared special member function.
+``` cpp
+struct A { };                   // implicitly declared A::operator=
+struct B : A {
+  B& operator=(const B &);
+};
+B& B::operator=(const B& s) {
+  this->A::operator=(s);        // well-formed
+  return *this;
+}
+```
+— *end example*]
+[*Note 2*: The special member functions affect the way objects of class
+type are created, copied, moved, and destroyed, and how values can be
+converted to values of other types. Often such special member functions
+are called implicitly. — *end note*]
+Special member functions obey the usual access rules [[class.access]].
+[*Example 2*: Declaring a constructor protected ensures that only
+derived classes and friends can create objects using
+it. — *end example*]
+Two special member functions are of the same kind if:
+- they are both default constructors,
+- they are both copy or move constructors with the same first parameter
+  type, or
+- they are both copy or move assignment operators with the same first
+  parameter type and the same *cv-qualifier*s and *ref-qualifier*, if
+  any.
+An *eligible special member function* is a special member function for
+which:
+- the function is not deleted,
+- the associated constraints [[temp.constr]], if any, are satisfied, and
+- no special member function of the same kind is more constrained
+  [[temp.constr.order]].
+For a class, its non-static data members, its non-virtual direct base
+classes, and, if the class is not abstract [[class.abstract]], its
+virtual base classes are called its *potentially constructed
+subobjects*.
+A defaulted special member function is *constexpr-compatible* if the
+corresponding implicitly-declared special member function would be a
+constexpr function.
+### Constructors <a id="class.ctor">[[class.ctor]]</a>
+A *constructor* is introduced by a declaration whose *declarator* is a
+function declarator [[dcl.fct]] of the form
+``` bnf
+ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+```
+where the *ptr-declarator* consists solely of an *id-expression*, an
+optional *attribute-specifier-seq*, and optional surrounding
+parentheses, and the *id-expression* has one of the following forms:
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class or class template but is not a friend declaration
+  [[class.friend]], the *id-expression* is the injected-class-name
+  [[class.pre]] of the immediately-enclosing entity or
+- in a declaration at namespace scope or in a friend declaration, the
+  *id-expression* is a *qualified-id* that names a constructor
+  [[class.qual]].
+Constructors do not have names. In a constructor declaration, each
+*decl-specifier* in the optional *decl-specifier-seq* shall be `friend`,
+`inline`, `constexpr`, or an *explicit-specifier*.
+[*Example 1*:
+``` cpp
+struct S {
+  S();              // declares the constructor
+};
+S::S() { }          // defines the constructor
+```
+— *end example*]
+A constructor is used to initialize objects of its class type. Because
+constructors do not have names, they are never found during name lookup;
+however an explicit type conversion using the functional notation
+[[expr.type.conv]] will cause a constructor to be called to initialize
+an object.
+[*Note 1*: The syntax looks like an explicit call of the
+constructor. — *end note*]
+[*Example 2*:
+``` cpp
+complex zz = complex(1,2.3);
+cprint( complex(7.8,1.2) );
+```
+— *end example*]
+[*Note 2*: For initialization of objects of class type see
+[[class.init]]. — *end note*]
+An object created in this way is unnamed.
+[*Note 3*:  [[class.temporary]] describes the lifetime of temporary
+objects. — *end note*]
+[*Note 4*: Explicit constructor calls do not yield lvalues, see
+[[basic.lval]]. — *end note*]
+[*Note 5*:  Some language constructs have special semantics when used
+during construction; see  [[class.base.init]] and
+[[class.cdtor]]. — *end note*]
+A constructor can be invoked for a `const`, `volatile` or `const`
+`volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
+not applied on an object under construction. They come into effect when
+the constructor for the most derived object [[intro.object]] ends.
+A `return` statement in the body of a constructor shall not specify a
+return value. The address of a constructor shall not be taken.
+A constructor shall not be a coroutine.
+#### Default constructors <a id="class.default.ctor">[[class.default.ctor]]</a>
+A *default constructor* for a class `X` is a constructor of class `X`
+for which each parameter that is not a function parameter pack has a
+default argument (including the case of a constructor with no
+parameters). If there is no user-declared constructor for class `X`, a
+non-explicit constructor having no parameters is implicitly declared as
+defaulted [[dcl.fct.def]]. An implicitly-declared default constructor is
+an inline public member of its class.
+A defaulted default constructor for class `X` is defined as deleted if:
+- `X` is a union that has a variant member with a non-trivial default
+  constructor and no variant member of `X` has a default member
+  initializer,
+- `X` is a non-union class that has a variant member `M` with a
+  non-trivial default constructor and no variant member of the anonymous
+  union containing `M` has a default member initializer,
+- any non-static data member with no default member initializer
+  [[class.mem]] is of reference type,
+- any non-variant non-static data member of const-qualified type (or
+  array thereof) with no *brace-or-equal-initializer* is not
+  const-default-constructible [[dcl.init]],
+- `X` is a union and all of its variant members are of const-qualified
+  type (or array thereof),
+- `X` is a non-union class and all members of any anonymous union member
+  are of const-qualified type (or array thereof),
+- any potentially constructed subobject, except for a non-static data
+  member with a *brace-or-equal-initializer*, has class type `M` (or
+  array thereof) and either `M` has no default constructor or overload
+  resolution [[over.match]] as applied to find `M`’s corresponding
+  constructor results in an ambiguity or in a function that is deleted
+  or inaccessible from the defaulted default constructor, or
+- any potentially constructed subobject has a type with a destructor
+  that is deleted or inaccessible from the defaulted default
+  constructor.
+A default constructor is *trivial* if it is not user-provided and if:
+- its class has no virtual functions [[class.virtual]] and no virtual
+  base classes [[class.mi]], and
+- no non-static data member of its class has a default member
+  initializer [[class.mem]], and
+- all the direct base classes of its class have trivial default
+  constructors, and
+- for all the non-static data members of its class that are of class
+  type (or array thereof), each such class has a trivial default
+  constructor.
+Otherwise, the default constructor is *non-trivial*.
+A default constructor that is defaulted and not defined as deleted is
+*implicitly defined* when it is odr-used [[basic.def.odr]] to create an
+object of its class type [[intro.object]], when it is needed for
+constant evaluation [[expr.const]], or when it is explicitly defaulted
+after its first declaration. The implicitly-defined default constructor
+performs the set of initializations of the class that would be performed
+by a user-written default constructor for that class with no
+*ctor-initializer* [[class.base.init]] and an empty
+*compound-statement*. If that user-written default constructor would be
+ill-formed, the program is ill-formed. If that user-written default
+constructor would satisfy the requirements of a constexpr constructor
+[[dcl.constexpr]], the implicitly-defined default constructor is
+`constexpr`. Before the defaulted default constructor for a class is
+implicitly defined, all the non-user-provided default constructors for
+its base classes and its non-static data members are implicitly defined.
+[*Note 1*: An implicitly-declared default constructor has an exception
+specification [[except.spec]]. An explicitly-defaulted definition might
+have an implicit exception specification, see
+[[dcl.fct.def]]. — *end note*]
+Default constructors are called implicitly to create class objects of
+static, thread, or automatic storage duration ([[basic.stc.static]],
+[[basic.stc.thread]], [[basic.stc.auto]]) defined without an initializer
+[[dcl.init]], are called to create class objects of dynamic storage
+duration [[basic.stc.dynamic]] created by a *new-expression* in which
+the *new-initializer* is omitted [[expr.new]], or are called when the
+explicit type conversion syntax [[expr.type.conv]] is used. A program is
+ill-formed if the default constructor for an object is implicitly used
+and the constructor is not accessible [[class.access]].
+[*Note 2*:  [[class.base.init]] describes the order in which
+constructors for base classes and non-static data members are called and
+describes how arguments can be specified for the calls to these
+constructors. — *end note*]
+#### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
+A non-template constructor for class `X` is a copy constructor if its
+first parameter is of type `X&`, `const X&`, `volatile X&` or
+`const volatile X&`, and either there are no other parameters or else
+all other parameters have default arguments [[dcl.fct.default]].
+[*Example 1*:
+`X::X(const X&)`
+and `X::X(X&,int=1)` are copy constructors.
+``` cpp
+struct X {
+  X(int);
+  X(const X&, int = 1);
+};
+X a(1);             // calls X(int);
+X b(a, 0);          // calls X(const X&, int);
+X c = b;            // calls X(const X&, int);
+```
+— *end example*]
+A non-template constructor for class `X` is a move constructor if its
+first parameter is of type `X&&`, `const X&&`, `volatile X&&`, or
+`const volatile X&&`, and either there are no other parameters or else
+all other parameters have default arguments [[dcl.fct.default]].
+[*Example 2*:
+`Y::Y(Y&&)` is a move constructor.
+``` cpp
+struct Y {
+  Y(const Y&);
+  Y(Y&&);
+};
+extern Y f(int);
+Y d(f(1));          // calls Y(Y&&)
+Y e = d;            // calls Y(const Y&)
+```
+— *end example*]
+[*Note 1*:
+All forms of copy/move constructor may be declared for a class.
+[*Example 3*:
+``` cpp
+struct X {
+  X(const X&);
+  X(X&);            // OK
+  X(X&&);
+  X(const X&&);     // OK, but possibly not sensible
+};
+```
+— *end example*]
+— *end note*]
+[*Note 2*:
+If a class `X` only has a copy constructor with a parameter of type
+`X&`, an initializer of type `const` `X` or `volatile` `X` cannot
+initialize an object of type cv `X`.
+[*Example 4*:
+``` cpp
+struct X {
+  X();              // default constructor
+  X(X&);            // copy constructor with a non-const parameter
+};
+const X cx;
+X x = cx;           // error: X::X(X&) cannot copy cx into x
+```
+— *end example*]
+— *end note*]
+A declaration of a constructor for a class `X` is ill-formed if its
+first parameter is of type cv `X` and either there are no other
+parameters or else all other parameters have default arguments. A member
+function template is never instantiated to produce such a constructor
+signature.
+[*Example 5*:
+``` cpp
+struct S {
+  template<typename T> S(T);
+  S();
+};
+S g;
+void h() {
+  S a(g);           // does not instantiate the member template to produce S::S<S>(S);
+                    // uses the implicitly declared copy constructor
+}
+```
+— *end example*]
+If the class definition does not explicitly declare a copy constructor,
+a non-explicit one is declared *implicitly*. If the class definition
+declares a move constructor or move assignment operator, the implicitly
+declared copy constructor is defined as deleted; otherwise, it is
+defined as defaulted [[dcl.fct.def]]. The latter case is deprecated if
+the class has a user-declared copy assignment operator or a
+user-declared destructor [[depr.impldec]].
+The implicitly-declared copy constructor for a class `X` will have the
+form
+``` cpp
+X::X(const X&)
+```
+if each potentially constructed subobject of a class type `M` (or array
+thereof) has a copy constructor whose first parameter is of type `const`
+`M&` or `const` `volatile` `M&`.[^3] Otherwise, the implicitly-declared
+copy constructor will have the form
+``` cpp
+X::X(X&)
+```
+If the definition of a class `X` does not explicitly declare a move
+constructor, a non-explicit one will be implicitly declared as defaulted
+if and only if
+- `X` does not have a user-declared copy constructor,
+- `X` does not have a user-declared copy assignment operator,
+- `X` does not have a user-declared move assignment operator, and
+- `X` does not have a user-declared destructor.
+[*Note 3*: When the move constructor is not implicitly declared or
+explicitly supplied, expressions that otherwise would have invoked the
+move constructor may instead invoke a copy constructor. — *end note*]
+The implicitly-declared move constructor for class `X` will have the
+form
+``` cpp
+X::X(X&&)
+```
+An implicitly-declared copy/move constructor is an inline public member
+of its class. A defaulted copy/move constructor for a class `X` is
+defined as deleted [[dcl.fct.def.delete]] if `X` has:
+- a potentially constructed subobject type `M` (or array thereof) that
+  cannot be copied/moved because overload resolution [[over.match]], as
+  applied to find `M`’s corresponding constructor, results in an
+  ambiguity or a function that is deleted or inaccessible from the
+  defaulted constructor,
+- a variant member whose corresponding constructor as selected by
+  overload resolution is non-trivial,
+- any potentially constructed subobject of a type with a destructor that
+  is deleted or inaccessible from the defaulted constructor, or,
+- for the copy constructor, a non-static data member of rvalue reference
+  type.
+[*Note 4*: A defaulted move constructor that is defined as deleted is
+ignored by overload resolution ([[over.match]], [[over.over]]). Such a
+constructor would otherwise interfere with initialization from an rvalue
+which can use the copy constructor instead. — *end note*]
+A copy/move constructor for class `X` is trivial if it is not
+user-provided and if:
+- class `X` has no virtual functions [[class.virtual]] and no virtual
+  base classes [[class.mi]], and
+- the constructor selected to copy/move each direct base class subobject
+  is trivial, and
+- for each non-static data member of `X` that is of class type (or array
+  thereof), the constructor selected to copy/move that member is
+  trivial;
+otherwise the copy/move constructor is *non-trivial*.
+A copy/move constructor that is defaulted and not defined as deleted is
+*implicitly defined* when it is odr-used [[basic.def.odr]], when it is
+needed for constant evaluation [[expr.const]], or when it is explicitly
+defaulted after its first declaration.
+[*Note 5*: The copy/move constructor is implicitly defined even if the
+implementation elided its odr-use ([[basic.def.odr]],
+[[class.temporary]]). — *end note*]
+If the implicitly-defined constructor would satisfy the requirements of
+a constexpr constructor [[dcl.constexpr]], the implicitly-defined
+constructor is `constexpr`.
+Before the defaulted copy/move constructor for a class is implicitly
+defined, all non-user-provided copy/move constructors for its
+potentially constructed subobjects are implicitly defined.
+[*Note 6*: An implicitly-declared copy/move constructor has an implied
+exception specification [[except.spec]]. — *end note*]
+The implicitly-defined copy/move constructor for a non-union class `X`
+performs a memberwise copy/move of its bases and members.
+[*Note 7*: Default member initializers of non-static data members are
+ignored. See also the example in  [[class.base.init]]. — *end note*]
+The order of initialization is the same as the order of initialization
+of bases and members in a user-defined constructor (see
+[[class.base.init]]). Let `x` be either the parameter of the constructor
+or, for the move constructor, an xvalue referring to the parameter. Each
+base or non-static data member is copied/moved in the manner appropriate
+to its type:
+- if the member is an array, each element is direct-initialized with the
+  corresponding subobject of `x`;
+- if a member `m` has rvalue reference type `T&&`, it is
+  direct-initialized with `static_cast<T&&>(x.m)`;
+- otherwise, the base or member is direct-initialized with the
+  corresponding base or member of `x`.
+Virtual base class subobjects shall be initialized only once by the
+implicitly-defined copy/move constructor (see  [[class.base.init]]).
+The implicitly-defined copy/move constructor for a union `X` copies the
+object representation [[basic.types]] of `X`. For each object nested
+within [[intro.object]] the object that is the source of the copy, a
+corresponding object o nested within the destination is identified (if
+the object is a subobject) or created (otherwise), and the lifetime of o
+begins before the copy is performed.
+### Copy/move assignment operator <a id="class.copy.assign">[[class.copy.assign]]</a>
+A user-declared *copy* assignment operator `X::operator=` is a
+non-static non-template member function of class `X` with exactly one
+parameter of type `X`, `X&`, `const X&`, `volatile X&`, or
+`const volatile X&`.[^4]
+[*Note 1*: An overloaded assignment operator must be declared to have
+only one parameter; see  [[over.ass]]. — *end note*]
+[*Note 2*: More than one form of copy assignment operator may be
+declared for a class. — *end note*]
+[*Note 3*:
+If a class `X` only has a copy assignment operator with a parameter of
+type `X&`, an expression of type const `X` cannot be assigned to an
+object of type `X`.
+[*Example 1*:
+``` cpp
+struct X {
+  X();
+  X& operator=(X&);
+};
+const X cx;
+X x;
+void f() {
+  x = cx;           // error: X::operator=(X&) cannot assign cx into x
+}
+```
+— *end example*]
+— *end note*]
+If the class definition does not explicitly declare a copy assignment
+operator, one is declared *implicitly*. If the class definition declares
+a move constructor or move assignment operator, the implicitly declared
+copy assignment operator is defined as deleted; otherwise, it is defined
+as defaulted [[dcl.fct.def]]. The latter case is deprecated if the class
+has a user-declared copy constructor or a user-declared destructor
+[[depr.impldec]]. The implicitly-declared copy assignment operator for a
+class `X` will have the form
+``` cpp
+X& X::operator=(const X&)
+```
+if
+- each direct base class `B` of `X` has a copy assignment operator whose
+  parameter is of type `const B&`, `const volatile B&`, or `B`, and
+- for all the non-static data members of `X` that are of a class type
+  `M` (or array thereof), each such class type has a copy assignment
+  operator whose parameter is of type `const M&`, `const volatile M&`,
+  or `M`.[^5]
+Otherwise, the implicitly-declared copy assignment operator will have
+the form
+``` cpp
+X& X::operator=(X&)
+```
+A user-declared move assignment operator `X::operator=` is a non-static
+non-template member function of class `X` with exactly one parameter of
+type `X&&`, `const X&&`, `volatile X&&`, or `const volatile X&&`.
+[*Note 4*: An overloaded assignment operator must be declared to have
+only one parameter; see  [[over.ass]]. — *end note*]
+[*Note 5*: More than one form of move assignment operator may be
+declared for a class. — *end note*]
+If the definition of a class `X` does not explicitly declare a move
+assignment operator, one will be implicitly declared as defaulted if and
+only if
+- `X` does not have a user-declared copy constructor,
+- `X` does not have a user-declared move constructor,
+- `X` does not have a user-declared copy assignment operator, and
+- `X` does not have a user-declared destructor.
+[*Example 2*:
+The class definition
+``` cpp
+struct S {
+  int a;
+  S& operator=(const S&) = default;
+};
+```
+will not have a default move assignment operator implicitly declared
+because the copy assignment operator has been user-declared. The move
+assignment operator may be explicitly defaulted.
+``` cpp
+struct S {
+  int a;
+  S& operator=(const S&) = default;
+  S& operator=(S&&) = default;
+};
+```
+— *end example*]
+The implicitly-declared move assignment operator for a class `X` will
+have the form
+``` cpp
+X& X::operator=(X&&)
+```
+The implicitly-declared copy/move assignment operator for class `X` has
+the return type `X&`; it returns the object for which the assignment
+operator is invoked, that is, the object assigned to. An
+implicitly-declared copy/move assignment operator is an inline public
+member of its class.
+A defaulted copy/move assignment operator for class `X` is defined as
+deleted if `X` has:
+- a variant member with a non-trivial corresponding assignment operator
+  and `X` is a union-like class, or
+- a non-static data member of `const` non-class type (or array thereof),
+  or
+- a non-static data member of reference type, or
+- a direct non-static data member of class type `M` (or array thereof)
+  or a direct base class `M` that cannot be copied/moved because
+  overload resolution [[over.match]], as applied to find `M`’s
+  corresponding assignment operator, results in an ambiguity or a
+  function that is deleted or inaccessible from the defaulted assignment
+  operator.
+[*Note 6*: A defaulted move assignment operator that is defined as
+deleted is ignored by overload resolution ([[over.match]],
+[[over.over]]). — *end note*]
+Because a copy/move assignment operator is implicitly declared for a
+class if not declared by the user, a base class copy/move assignment
+operator is always hidden by the corresponding assignment operator of a
+derived class [[over.ass]]. A *using-declaration* [[namespace.udecl]]
+that brings in from a base class an assignment operator with a parameter
+type that could be that of a copy/move assignment operator for the
+derived class is not considered an explicit declaration of such an
+operator and does not suppress the implicit declaration of the derived
+class operator; the operator introduced by the *using-declaration* is
+hidden by the implicitly-declared operator in the derived class.
+A copy/move assignment operator for class `X` is trivial if it is not
+user-provided and if:
+- class `X` has no virtual functions [[class.virtual]] and no virtual
+  base classes [[class.mi]], and
+- the assignment operator selected to copy/move each direct base class
+  subobject is trivial, and
+- for each non-static data member of `X` that is of class type (or array
+  thereof), the assignment operator selected to copy/move that member is
+  trivial;
+otherwise the copy/move assignment operator is *non-trivial*.
+A copy/move assignment operator for a class `X` that is defaulted and
+not defined as deleted is *implicitly defined* when it is odr-used
+[[basic.def.odr]] (e.g., when it is selected by overload resolution to
+assign to an object of its class type), when it is needed for constant
+evaluation [[expr.const]], or when it is explicitly defaulted after its
+first declaration. The implicitly-defined copy/move assignment operator
+is `constexpr` if
+- `X` is a literal type, and
+- the assignment operator selected to copy/move each direct base class
+  subobject is a constexpr function, and
+- for each non-static data member of `X` that is of class type (or array
+  thereof), the assignment operator selected to copy/move that member is
+  a constexpr function.
+Before the defaulted copy/move assignment operator for a class is
+implicitly defined, all non-user-provided copy/move assignment operators
+for its direct base classes and its non-static data members are
+implicitly defined.
+[*Note 7*: An implicitly-declared copy/move assignment operator has an
+implied exception specification [[except.spec]]. — *end note*]
+The implicitly-defined copy/move assignment operator for a non-union
+class `X` performs memberwise copy/move assignment of its subobjects.
+The direct base classes of `X` are assigned first, in the order of their
+declaration in the *base-specifier-list*, and then the immediate
+non-static data members of `X` are assigned, in the order in which they
+were declared in the class definition. Let `x` be either the parameter
+of the function or, for the move operator, an xvalue referring to the
+parameter. Each subobject is assigned in the manner appropriate to its
+type:
+- if the subobject is of class type, as if by a call to `operator=` with
+  the subobject as the object expression and the corresponding subobject
+  of `x` as a single function argument (as if by explicit qualification;
+  that is, ignoring any possible virtual overriding functions in more
+  derived classes);
+- if the subobject is an array, each element is assigned, in the manner
+  appropriate to the element type;
+- if the subobject is of scalar type, the built-in assignment operator
+  is used.
+It is unspecified whether subobjects representing virtual base classes
+are assigned more than once by the implicitly-defined copy/move
+assignment operator.
+[*Example 3*:
+``` cpp
+struct V { };
+struct A : virtual V { };
+struct B : virtual V { };
+struct C : B, A { };
+```
+It is unspecified whether the virtual base class subobject `V` is
+assigned twice by the implicitly-defined copy/move assignment operator
+for `C`.
+— *end example*]
+The implicitly-defined copy assignment operator for a union `X` copies
+the object representation [[basic.types]] of `X`. If the source and
+destination of the assignment are not the same object, then for each
+object nested within [[intro.object]] the object that is the source of
+the copy, a corresponding object o nested within the destination is
+created, and the lifetime of o begins before the copy is performed.
+### Destructors <a id="class.dtor">[[class.dtor]]</a>
+A *prospective destructor* is introduced by a declaration whose
+*declarator* is a function declarator [[dcl.fct]] of the form
+``` bnf
+ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+```
+where the *ptr-declarator* consists solely of an *id-expression*, an
+optional *attribute-specifier-seq*, and optional surrounding
+parentheses, and the *id-expression* has one of the following forms:
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class or class template but is not a friend declaration
+  [[class.friend]], the *id-expression* is `~`*class-name* and the
+  *class-name* is the injected-class-name [[class.pre]] of the
+  immediately-enclosing entity or
+- in a declaration at namespace scope or in a friend declaration, the
+  *id-expression* is *nested-name-specifier* `~`*class-name* and the
+  *class-name* names the same class as the *nested-name-specifier*.
+A prospective destructor shall take no arguments [[dcl.fct]]. Each
+*decl-specifier* of the *decl-specifier-seq* of a prospective destructor
+declaration (if any) shall be `friend`, `inline`, `virtual`,
+`constexpr`, or `consteval`.
+If a class has no user-declared prospective destructor, a prospective
+destructor is implicitly declared as defaulted [[dcl.fct.def]]. An
+implicitly-declared prospective destructor is an inline public member of
+its class.
+An implicitly-declared prospective destructor for a class `X` will have
+the form
+``` cpp
+~X()
+```
+At the end of the definition of a class, overload resolution is
+performed among the prospective destructors declared in that class with
+an empty argument list to select the *destructor* for the class, also
+known as the *selected destructor*. The program is ill-formed if
+overload resolution fails. Destructor selection does not constitute a
+reference to, or odr-use [[basic.def.odr]] of, the selected destructor,
+and in particular, the selected destructor may be deleted
+[[dcl.fct.def.delete]].
+The address of a destructor shall not be taken. A destructor can be
+invoked for a `const`, `volatile` or `const` `volatile` object. `const`
+and `volatile` semantics [[dcl.type.cv]] are not applied on an object
+under destruction. They stop being in effect when the destructor for the
+most derived object [[intro.object]] starts.
+[*Note 1*: A declaration of a destructor that does not have a
+*noexcept-specifier* has the same exception specification as if it had
+been implicitly declared [[except.spec]]. — *end note*]
+A defaulted destructor for a class `X` is defined as deleted if:
+- `X` is a union-like class that has a variant member with a non-trivial
+  destructor,
+- any potentially constructed subobject has class type `M` (or array
+  thereof) and `M` has a deleted destructor or a destructor that is
+  inaccessible from the defaulted destructor,
+- or, for a virtual destructor, lookup of the non-array deallocation
+  function results in an ambiguity or in a function that is deleted or
+  inaccessible from the defaulted destructor.
+A destructor is trivial if it is not user-provided and if:
+- the destructor is not `virtual`,
+- all of the direct base classes of its class have trivial destructors,
+  and
+- for all of the non-static data members of its class that are of class
+  type (or array thereof), each such class has a trivial destructor.
+Otherwise, the destructor is *non-trivial*.
+A defaulted destructor is a constexpr destructor if it satisfies the
+requirements for a constexpr destructor [[dcl.constexpr]].
+A destructor that is defaulted and not defined as deleted is *implicitly
+defined* when it is odr-used [[basic.def.odr]] or when it is explicitly
+defaulted after its first declaration.
+Before a defaulted destructor for a class is implicitly defined, all the
+non-user-provided destructors for its base classes and its non-static
+data members are implicitly defined.
+A prospective destructor can be declared `virtual` [[class.virtual]] or
+pure `virtual` [[class.abstract]]. If the destructor of a class is
+virtual and any objects of that class or any derived class are created
+in the program, the destructor shall be defined. If a class has a base
+class with a virtual destructor, its destructor (whether user- or
+implicitly-declared) is virtual.
+[*Note 2*:  Some language constructs have special semantics when used
+during destruction; see  [[class.cdtor]]. — *end note*]
+After executing the body of the destructor and destroying any objects
+with automatic storage duration allocated within the body, a destructor
+for class `X` calls the destructors for `X`’s direct non-variant
+non-static data members, the destructors for `X`’s non-virtual direct
+base classes and, if `X` is the most derived class [[class.base.init]],
+its destructor calls the destructors for `X`’s virtual base classes. All
+destructors are called as if they were referenced with a qualified name,
+that is, ignoring any possible virtual overriding destructors in more
+derived classes. Bases and members are destroyed in the reverse order of
+the completion of their constructor (see  [[class.base.init]]). A
+`return` statement [[stmt.return]] in a destructor might not directly
+return to the caller; before transferring control to the caller, the
+destructors for the members and bases are called. Destructors for
+elements of an array are called in reverse order of their construction
+(see  [[class.init]]).
+A destructor is invoked implicitly
+- for a constructed object with static storage duration
+  [[basic.stc.static]] at program termination [[basic.start.term]],
+- for a constructed object with thread storage duration
+  [[basic.stc.thread]] at thread exit,
+- for a constructed object with automatic storage duration
+  [[basic.stc.auto]] when the block in which an object is created exits
+  [[stmt.dcl]],
+- for a constructed temporary object when its lifetime ends (
+  [[conv.rval]], [[class.temporary]]).
+In each case, the context of the invocation is the context of the
+construction of the object. A destructor may also be invoked implicitly
+through use of a *delete-expression* [[expr.delete]] for a constructed
+object allocated by a *new-expression* [[expr.new]]; the context of the
+invocation is the *delete-expression*.
+[*Note 3*: An array of class type contains several subobjects for each
+of which the destructor is invoked. — *end note*]
+A destructor can also be invoked explicitly. A destructor is
+*potentially invoked* if it is invoked or as specified in  [[expr.new]],
+[[stmt.return]], [[dcl.init.aggr]], [[class.base.init]], and
+[[except.throw]]. A program is ill-formed if a destructor that is
+potentially invoked is deleted or not accessible from the context of the
+invocation.
+At the point of definition of a virtual destructor (including an
+implicit definition [[class.dtor]]), the non-array deallocation function
+is determined as if for the expression `delete this` appearing in a
+non-virtual destructor of the destructor’s class (see  [[expr.delete]]).
+If the lookup fails or if the deallocation function has a deleted
+definition [[dcl.fct.def]], the program is ill-formed.
+[*Note 4*: This assures that a deallocation function corresponding to
+the dynamic type of an object is available for the *delete-expression*
+[[class.free]]. — *end note*]
+In an explicit destructor call, the destructor is specified by a `~`
+followed by a *type-name* or *decltype-specifier* that denotes the
+destructor’s class type. The invocation of a destructor is subject to
+the usual rules for member functions [[class.mfct]]; that is, if the
+object is not of the destructor’s class type and not of a class derived
+from the destructor’s class type (including when the destructor is
+invoked via a null pointer value), the program has undefined behavior.
+[*Note 5*: Invoking `delete` on a null pointer does not call the
+destructor; see [[expr.delete]]. — *end note*]
+[*Example 1*:
+``` cpp
+struct B {
+  virtual ~B() { }
+};
+struct D : B {
+  ~D() { }
+};
+D D_object;
+typedef B B_alias;
+B* B_ptr = &D_object;
+void f() {
+  D_object.B::~B();             // calls B's destructor
+  B_ptr->~B();                  // calls D's destructor
+  B_ptr->~B_alias();            // calls D's destructor
+  B_ptr->B_alias::~B();         // calls B's destructor
+  B_ptr->B_alias::~B_alias();   // calls B's destructor
+}
+```
+— *end example*]
+[*Note 6*: An explicit destructor call must always be written using a
+member access operator [[expr.ref]] or a *qualified-id*
+[[expr.prim.id.qual]]; in particular, the *unary-expression* `~X()` in a
+member function is not an explicit destructor call
+[[expr.unary.op]]. — *end note*]
+[*Note 7*:
+Explicit calls of destructors are rarely needed. One use of such calls
+is for objects placed at specific addresses using a placement
+*new-expression*. Such use of explicit placement and destruction of
+objects can be necessary to cope with dedicated hardware resources and
+for writing memory management facilities. For example,
+``` cpp
+void* operator new(std::size_t, void* p) { return p; }
+struct X {
+  X(int);
+  ~X();
+};
+void f(X* p);
+void g() {                      // rare, specialized use:
+  char* buf = new char[sizeof(X)];
+  X* p = new(buf) X(222);       // use buf[] and initialize
+  f(p);
+  p->X::~X();                   // cleanup
+}
+```
+— *end note*]
+Once a destructor is invoked for an object, the object no longer exists;
+the behavior is undefined if the destructor is invoked for an object
+whose lifetime has ended [[basic.life]].
+[*Example 2*: If the destructor for an object with automatic storage
+duration is explicitly invoked, and the block is subsequently left in a
+manner that would ordinarily invoke implicit destruction of the object,
+the behavior is undefined. — *end example*]
+[*Note 8*:
+The notation for explicit call of a destructor can be used for any
+scalar type name [[expr.prim.id.dtor]]. Allowing this makes it possible
+to write code without having to know if a destructor exists for a given
+type. For example:
+``` cpp
+typedef int I;
+I* p;
+p->I::~I();
+```
+— *end note*]
+A destructor shall not be a coroutine.
+### Conversions <a id="class.conv">[[class.conv]]</a>
+Type conversions of class objects can be specified by constructors and
+by conversion functions. These conversions are called *user-defined
+conversions* and are used for implicit type conversions [[conv]], for
+initialization [[dcl.init]], and for explicit type conversions (
+[[expr.type.conv]], [[expr.cast]], [[expr.static.cast]]).
+User-defined conversions are applied only where they are unambiguous (
+[[class.member.lookup]], [[class.conv.fct]]). Conversions obey the
+access control rules [[class.access]]. Access control is applied after
+ambiguity resolution [[basic.lookup]].
+[*Note 1*: See  [[over.match]] for a discussion of the use of
+conversions in function calls as well as examples below. — *end note*]
+At most one user-defined conversion (constructor or conversion function)
+is implicitly applied to a single value.
+[*Example 1*:
+``` cpp
+struct X {
+  operator int();
+};
+struct Y {
+  operator X();
+};
+Y a;
+int b = a;          // error: no viable conversion (a.operator X().operator int() not considered)
+int c = X(a);       // OK: a.operator X().operator int()
+```
+— *end example*]
+User-defined conversions are used implicitly only if they are
+unambiguous. A conversion function in a derived class does not hide a
+conversion function in a base class unless the two functions convert to
+the same type. Function overload resolution [[over.match.best]] selects
+the best conversion function to perform the conversion.
+[*Example 2*:
+``` cpp
+struct X {
+  operator int();
+};
+struct Y : X {
+    operator char();
+};
+void f(Y& a) {
+  if (a) {          // error: ambiguous between X::operator int() and Y::operator char()
+  }
+}
+```
+— *end example*]
+#### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
+A constructor that is not explicit [[dcl.fct.spec]] specifies a
+conversion from the types of its parameters (if any) to the type of its
+class. Such a constructor is called a *converting constructor*.
+[*Example 1*:
+``` cpp
+struct X {
+    X(int);
+    X(const char*, int =0);
+    X(int, int);
+};
+void f(X arg) {
+  X a = 1;          // a = X(1)
+  X b = "Jessie";   // b = X("Jessie",0)
+  a = 2;            // a = X(2)
+  f(3);             // f(X(3))
+  f({1, 2});        // f(X(1,2))
+}
+```
+— *end example*]
+[*Note 1*:
+An explicit constructor constructs objects just like non-explicit
+constructors, but does so only where the direct-initialization syntax
+[[dcl.init]] or where casts ([[expr.static.cast]], [[expr.cast]]) are
+explicitly used; see also  [[over.match.copy]]. A default constructor
+may be an explicit constructor; such a constructor will be used to
+perform default-initialization or value-initialization [[dcl.init]].
+[*Example 2*:
+``` cpp
+struct Z {
+  explicit Z();
+  explicit Z(int);
+  explicit Z(int, int);
+};
+Z a;                            // OK: default-initialization performed
+Z b{};                          // OK: direct initialization syntax used
+Z c = {};                       // error: copy-list-initialization
+Z a1 = 1;                       // error: no implicit conversion
+Z a3 = Z(1);                    // OK: direct initialization syntax used
+Z a2(1);                        // OK: direct initialization syntax used
+Z* p = new Z(1);                // OK: direct initialization syntax used
+Z a4 = (Z)1;                    // OK: explicit cast used
+Z a5 = static_cast<Z>(1);       // OK: explicit cast used
+Z a6 = { 3, 4 };                // error: no implicit conversion
+```
+— *end example*]
+— *end note*]
+A non-explicit copy/move constructor [[class.copy.ctor]] is a converting
+constructor.
+[*Note 2*: An implicitly-declared copy/move constructor is not an
+explicit constructor; it may be called for implicit type
+conversions. — *end note*]
+#### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
+A member function of a class `X` having no parameters with a name of the
+form
+``` bnf
+conversion-function-id:
+    operator conversion-type-id
+```
+``` bnf
+conversion-type-id:
+    type-specifier-seq conversion-declaratorₒₚₜ
+```
+``` bnf
+conversion-declarator:
+    ptr-operator conversion-declaratorₒₚₜ
+```
+specifies a conversion from `X` to the type specified by the
+*conversion-type-id*. Such functions are called *conversion functions*.
+A *decl-specifier* in the *decl-specifier-seq* of a conversion function
+(if any) shall be neither a *defining-type-specifier* nor `static`. The
+type of the conversion function [[dcl.fct]] is “function taking no
+parameter returning *conversion-type-id*”. A conversion function is
+never used to convert a (possibly cv-qualified) object to the (possibly
+cv-qualified) same object type (or a reference to it), to a (possibly
+cv-qualified) base class of that type (or a reference to it), or to
+cv `void`.[^6]
+[*Example 1*:
+``` cpp
+struct X {
+  operator int();
+  operator auto() -> short;     // error: trailing return type
+};
+void f(X a) {
+  int i = int(a);
+  i = (int)a;
+  i = a;
+}
+```
+In all three cases the value assigned will be converted by
+`X::operator int()`.
+— *end example*]
+A conversion function may be explicit [[dcl.fct.spec]], in which case it
+is only considered as a user-defined conversion for
+direct-initialization [[dcl.init]]. Otherwise, user-defined conversions
+are not restricted to use in assignments and initializations.
+[*Example 2*:
+``` cpp
+class Y { };
+struct Z {
+  explicit operator Y() const;
+};
+void h(Z z) {
+  Y y1(z);          // OK: direct-initialization
+  Y y2 = z;         // error: no conversion function candidate for copy-initialization
+  Y y3 = (Y)z;      // OK: cast notation
+}
+void g(X a, X b) {
+  int i = (a) ? 1+a : 0;
+  int j = (a&&b) ? a+b : i;
+  if (a) {
+  }
+}
+```
+— *end example*]
+The *conversion-type-id* shall not represent a function type nor an
+array type. The *conversion-type-id* in a *conversion-function-id* is
+the longest sequence of tokens that could possibly form a
+*conversion-type-id*.
+[*Note 1*:
+This prevents ambiguities between the declarator operator `*` and its
+expression counterparts.
+[*Example 3*:
+``` cpp
+&ac.operator int*i; // syntax error:
+                    // parsed as: &(ac.operator int *)i
+                    // not as: &(ac.operator int)*i
+```
+The `*` is the pointer declarator and not the multiplication operator.
+— *end example*]
+This rule also prevents ambiguities for attributes.
+[*Example 4*:
+``` cpp
+operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
+```
+— *end example*]
+— *end note*]
+Conversion functions are inherited.
+Conversion functions can be virtual.
+A conversion function template shall not have a deduced return type
+[[dcl.spec.auto]].
+[*Example 5*:
+``` cpp
+struct S {
+  operator auto() const { return 10; }      // OK
+  template<class T>
+  operator auto() const { return 1.2; }     // error: conversion function template
+};
+```
+— *end example*]
 ### Static members <a id="class.static">[[class.static]]</a>
 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 evaluated.
 [*Example 1*:
 ``` cpp
 struct process {
 ```
 — *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
+referenced.
 [*Example 2*:
 ``` cpp
 int g();
 int Y::i = g();                 // equivalent to Y::g();
 ```
 — *end example*]
+Static members obey the usual class member access rules
+[[class.access]]. When used in the declaration of a class member, the
 `static` specifier shall only be used in the member declarations that
 appear within the *member-specification* of the class definition.
+[*Note 1*: It cannot be specified in member declarations that appear in
 namespace scope. — *end note*]
 #### Static member functions <a id="class.static.mfct">[[class.static.mfct]]</a>
 [*Note 1*: The rules described in  [[class.mfct]] apply to static
 member functions. — *end note*]
+[*Note 2*: A static member function does not have a `this` pointer
+[[class.this]]. — *end note*]
 A static member function shall not be `virtual`. There shall not be a
 static and a non-static 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`.
 #### Static data members <a id="class.static.data">[[class.static.data]]</a>
 A static data member is not part of the subobjects of a class. If a
 static data member is declared `thread_local` there is one copy of the
 member per thread. If a static data member is not declared
 `thread_local` there is one copy of the data member that is shared by
 all the objects of the class.
+A static data member shall not be `mutable` [[dcl.stc]]. A static data
+member shall not be a direct member [[class.mem]] of an unnamed
+[[class.pre]] or local [[class.local]] class or of a (possibly
+indirectly) nested class [[class.nest]] thereof.
 The declaration of a non-inline static data member in its class
 definition is not a definition and may be of an incomplete type other
 than cv `void`. The definition for a static data member that is not
 defined inline in the class definition shall appear in a namespace scope
 enclosing the member’s class definition. In the definition 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 1*:
 ``` cpp
 class process {
 — *end note*]
 If a non-volatile non-inline `const` static data member is of integral
 or enumeration type, its declaration in the class definition can specify
 a *brace-or-equal-initializer* in which every *initializer-clause* that
+is an *assignment-expression* is a constant expression [[expr.const]].
+The member shall still be defined in a namespace scope if it is odr-used
+[[basic.def.odr]] in the program and the namespace scope definition
+shall not contain an *initializer*. An inline static data member may be
+defined in the class definition and may specify a
 *brace-or-equal-initializer*. If the member is declared with the
 `constexpr` specifier, it may be redeclared in namespace scope with no
+initializer (this usage is deprecated; see [[depr.static.constexpr]]).
 Declarations of other static data members shall not specify a
 *brace-or-equal-initializer*.
+[*Note 2*: There is exactly one definition of a static data member that
+is odr-used [[basic.def.odr]] in a valid program. — *end note*]
 [*Note 3*: Static data members of a class in namespace scope have the
+linkage of the name of the class [[basic.link]]. — *end note*]
 Static data members are initialized and destroyed exactly like non-local
 variables ([[basic.start.static]], [[basic.start.dynamic]],
 [[basic.start.term]]).
 ### Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
+``` bnf
+identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
+```
+specifies a bit-field. The optional *attribute-specifier-seq* appertains
+to the entity being declared. A bit-field shall not be a static member.
+A bit-field shall have integral or enumeration type; the bit-field
+semantic property is not part of the type of the class member. The
+*constant-expression* shall be an integral constant expression with a
+value greater than or equal to zero and is called the *width* of the
+bit-field. If the width of a bit-field is larger than the width of the
+bit-field’s type (or, in case of an enumeration type, of its underlying
+type), the extra bits are padding bits [[basic.types]]. Allocation of
+bit-fields within a class object is *implementation-defined*. Alignment
+of bit-fields is *implementation-defined*. Bit-fields are packed into
+some addressable allocation unit.
 [*Note 1*: Bit-fields straddle allocation units on some machines and
 not on others. Bit-fields are assigned right-to-left on some machines,
 left-to-right on others. — *end note*]
 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. An unnamed bit-field shall not be declared with a
+cv-qualified type.
 [*Note 2*: An unnamed bit-field is useful for padding to conform to
 externally-imposed layouts. — *end note*]
 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. Only
+when declaring an unnamed bit-field may the width be zero.
+The address-of operator `&` shall not be applied to a bit-field, so
+there are no pointers to bit-fields. A non-const reference shall not be
+bound to a bit-field [[dcl.init.ref]].
 [*Note 3*: If the initializer for a reference of type `const` `T&` is
 an lvalue that refers to a bit-field, the reference is bound to a
 temporary initialized to hold the value of the bit-field; the reference
 is not bound to the bit-field directly. See
 [[dcl.init.ref]]. — *end note*]
+If a value of integral type (other than `bool`) is stored into a
+bit-field of width N and the value would be representable in a
+hypothetical signed or unsigned integer type with width N and the same
+signedness as the bit-field’s type, the original value and the value of
+the bit-field compare equal. If the value `true` or `false` is stored
+into a bit-field of type `bool` of any size (including a one bit
+bit-field), the original `bool` value and the value of the bit-field
+compare equal. If a value of an enumeration type is stored into a
+bit-field of the same type and the width is large enough to hold all the
+values of that enumeration type [[dcl.enum]], the original value and the
+value of the bit-field compare equal.
 [*Example 1*:
 ``` cpp
 enum BOOL { FALSE=0, TRUE=1 };
 — *end example*]
 ### Nested class declarations <a id="class.nest">[[class.nest]]</a>
 A class can be declared within another class. A class declared 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.
+[*Note 1*: See  [[expr.prim.id]] for restrictions on the use of
+non-static data members and non-static member functions. — *end note*]
 [*Example 1*:
 ``` cpp
 int x;
 class E::I2 { };                // definition of nested class
 ```
 — *end example*]
+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]], but it has no special access rights to members
+of an enclosing class.
 ### Nested type names <a id="class.nested.type">[[class.nested.type]]</a>
 Type names obey exactly the same scope rules as other names. In
 particular, type names defined within a class definition cannot be used

Diff to HTML by rtfpessoa