[class] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp2twctpz_/{from.md → to.md} +655 -480

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

@@ -20,22 +20,29 @@ class-specifier:
     class-head '{' member-specificationₒₚₜ '}'
 ```
 ``` bnf
 class-head:
-    class-key attribute-specifier-seqₒₚₜ class-head-name class-virt-specifierₒₚₜ base-clauseₒₚₜ
     class-key attribute-specifier-seqₒₚₜ base-clauseₒₚₜ
 ```
 ``` bnf
 class-head-name:
     nested-name-specifierₒₚₜ class-name
 ```
 ``` bnf
-class-virt-specifier:
     final
 ```
 ``` bnf
 class-key:
     class
@@ -45,22 +52,22 @@ class-key:
 A class declaration where the *class-name* in the *class-head-name* is a
 *simple-template-id* shall be an explicit specialization
 [[temp.expl.spec]] or a partial specialization [[temp.spec.partial]]. A
 *class-specifier* whose *class-head* omits the *class-head-name* defines
-an unnamed class.
 [*Note 1*: An unnamed class thus can’t be `final`. — *end note*]
 Otherwise, the *class-name* is an *identifier*; it is not looked up, and
 the *class-specifier* introduces it.
-The *class-name* is also bound in the scope of the class (template)
-itself; this is known as the *injected-class-name*. For purposes of
-access checking, the injected-class-name is treated as if it were a
-public member name. A *class-specifier* is commonly referred to as a
-*class definition*. A class is considered defined after the closing
 brace of its *class-specifier* has been seen even though its member
 functions are in general not yet defined. The optional
 *attribute-specifier-seq* appertains to the class; the attributes in the
 *attribute-specifier-seq* are thereafter considered attributes of the
 class whenever it is named.
@@ -92,38 +99,45 @@ template<> struct A<void> {};           // OK
 [*Note 2*: The *class-key* determines whether the class is a union
 [[class.union]] and whether access is public or private by default
 [[class.access]]. A union holds the value of at most one data member at
 a time. — *end note*]
-If a class is marked with the *class-virt-specifier* `final` and it
-appears as a *class-or-decltype* in a *base-clause* [[class.derived]],
-the program is ill-formed. Whenever a *class-key* is followed by a
-*class-head-name*, the *identifier* `final`, and a colon or left brace,
-`final` is interpreted as a *class-virt-specifier*.
 [*Example 2*:
 ``` cpp
 struct A;
 struct A final {};      // OK, definition of struct A,
                         // not value-initialization of variable final
 struct X {
  struct C { constexpr operator int() { return 5; } };
- struct B final : C{};  // OK, definition of nested class B,
-                        // not declaration of a bit-field member final
 };
 ```
 — *end example*]
 [*Note 3*: Complete objects of class type have nonzero size. Base class
 subobjects and members declared with the `no_unique_address` attribute
 [[dcl.attr.nouniqueaddr]] are not so constrained. — *end note*]
 [*Note 4*: Class objects can be assigned
-[[over.ass]], [[class.copy.assign]], passed as arguments to functions
 [[dcl.init]], [[class.copy.ctor]], and returned by functions (except
 objects of classes for which copying or moving has been restricted; see
 [[dcl.fct.def.delete]] and [[class.access]]). Other plausible operators,
 such as equality comparison, can be defined by the user; see
 [[over.oper]]. — *end note*]
@@ -137,16 +151,68 @@ A *trivially copyable class* is a class:
   [[special]], [[class.copy.ctor]], [[class.copy.assign]],
 - where each eligible copy constructor, move constructor, copy
   assignment operator, and move assignment operator is trivial, and
 - that has a trivial, non-deleted destructor [[class.dtor]].
-A *trivial class* is a class that is trivially copyable and has one or
-more eligible default constructors [[class.default.ctor]], all of which
-are trivial.
-[*Note 1*: In particular, a trivially copyable or trivial class does
-not have virtual functions or virtual base classes. — *end note*]
 A class `S` is a *standard-layout class* if it:
 - has no non-static data members of type non-standard-layout class (or
   array of such types) or reference,
@@ -158,11 +224,11 @@ A class `S` is a *standard-layout class* if it:
 - has at most one base class subobject of any given type,
 - has all non-static data members and bit-fields in the class and its
   base classes first declared in the same class, and
 - has no element of the set M(S) of types as a base class, where for any
   type `X`, M(X) is defined as follows.[^1]
-  \[*Note 2*: M(X) is the set of the types of all non-base-class
   subobjects that can be at a zero offset in `X`. — *end note*]
   - If `X` is a non-union class type with no non-static data members,
     the set M(X) is empty.
   - If `X` is a non-union class type with a non-static data member of
     type X₀ that is either of zero size or is the first non-static data
@@ -194,44 +260,44 @@ struct U : S, T { };            // not a standard-layout class
 A *standard-layout struct* is a standard-layout class defined with the
 *class-key* `struct` or the *class-key* `class`. A
 *standard-layout union* is a standard-layout class defined with the
 *class-key* `union`.
-[*Note 3*: Standard-layout classes are useful for communicating with
 code written in other programming languages. Their layout is specified
-in  [[class.mem]]. — *end note*]
 [*Example 2*:
 ``` cpp
-struct N {          // neither trivial nor standard-layout
   int i;
   int j;
   virtual ~N();
 };
-struct T {          // trivial but not standard-layout
   int i;
 private:
   int j;
 };
-struct SL {         // standard-layout but not trivial
   int i;
   int j;
   ~SL();
 };
-struct POD {        // both trivial and standard-layout
   int i;
   int j;
 };
 ```
 — *end example*]
-[*Note 4*: Aggregates of class type are described in
 [[dcl.init.aggr]]. — *end note*]
 A class `S` is an *implicit-lifetime class* if
 - it is an aggregate whose destructor is not user-provided or
@@ -366,21 +432,25 @@ void g(int s) {
 [*Note 3*:
 The declaration of a class name takes effect immediately after the
 *identifier* is seen in the class definition or
-*elaborated-type-specifier*. For example,
 ``` cpp
 class A * A;
 ```
 first specifies `A` to be the name of a class and then redefines it as
 the name of a pointer to an object of that class. This means that the
 elaborated form `class` `A` must be used to refer to the class. Such
 artistry with names can be confusing and is best avoided.
 — *end note*]
 A *simple-template-id* is only a *class-name* if its *template-name*
 names a class template.
@@ -396,13 +466,15 @@ member-specification:
 ``` 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
@@ -415,20 +487,19 @@ member-declarator-list:
     member-declarator-list ',' member-declarator
 ```
 ``` 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
@@ -438,57 +509,97 @@ virt-specifier:
 ``` 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 members [[class.union.anon]] and direct members thereof. Members
 of a class are data members, member functions [[class.mfct]], nested
 types, enumerators, and member templates [[temp.mem]] and
 specializations thereof.
-[*Note 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 *deduction-guide* [[temp.deduct.guide]],
 - a *template-declaration* whose *declaration* is one of the above,
 - 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
@@ -508,23 +619,27 @@ non-static data member.
 A *complete-class context* of a class (template) is a
 - function body [[dcl.fct.def.general]],
 - default argument [[dcl.fct.default]],
 - default template argument [[temp.param]],
-- *noexcept-specifier* [[except.spec]], or
 - default member initializer
 within the *member-specification* of the class or class template.
 [*Note 4*: A complete-class context of a nested class is also a
 complete-class context of any enclosing class, if the nested class is
 defined within the *member-specification* of the enclosing
 class. — *end note*]
-A class is regarded as complete where its definition is reachable and
-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*.
@@ -654,11 +769,11 @@ 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
   enumeration type; and
 - every member of every anonymous union that is a member of class `T`.
@@ -673,12 +788,13 @@ 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 [[basic.types]],
 - corresponding entities have the same alignment requirements
   [[basic.align]],
-- 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*:
@@ -741,10 +857,47 @@ 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>
 If a member function is attached to the global module and is defined
 [[dcl.fct.def]] in its class definition, it is inline [[dcl.inline]].
@@ -777,11 +930,13 @@ definition, if they are defined at all.
 [*Note 2*:
 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,
 ``` cpp
 typedef void fv();
 typedef void fvc() const;
 struct S {
@@ -792,11 +947,11 @@ struct S {
 fv  S::* pmfv1 = &S::memfunc1;
 fv  S::* pmfv2 = &S::memfunc2;
 fvc S::* pmfv3 = &S::memfunc3;
 ```
-Also see  [[temp.arg]].
 — *end note*]
 ### Non-static member functions <a id="class.mfct.non.static">[[class.mfct.non.static]]</a>
@@ -806,65 +961,14 @@ 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.
-When an *id-expression* [[expr.prim.id]] that is neither part of a class
-member access syntax [[expr.ref]] nor the unparenthesized operand of the
-unary `&` operator [[expr.unary.op]] is used where the current class is
-`X` [[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)` 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 {
-  char tword[20];
-  int count;
-  tnode* left;
-  tnode* right;
-  void set(const char*, tnode* l, tnode* r);
-};
-void tnode::set(const char* w, tnode* l, tnode* r) {
-  count = strlen(w)+1;
-  if (sizeof(tword)<=count)
-      perror("tnode string too long");
-  strcpy(tword,w);
-  left = l;
-  right = r;
-}
-void f(tnode n1, tnode n2) {
-  n1.set("abc",&n2,0);
-  n2.set("def",0,0);
-}
-```
-In the body of the member function `tnode::set`, the member names
-`tword`, `count`, `left`, and `right` refer to members of the object for
-which the function is called. Thus, in the call `n1.set("abc",&n2,0)`,
-`tword` refers to `n1.tword`, and in the call `n2.set("def",0,0)`, it
-refers to `n2.tword`. The functions `strlen`, `perror`, and `strcpy` are
-not members of the class `tnode` and should be declared elsewhere.[^2]
-— *end example*]
-[*Note 2*: An implicit object member function can be declared with
 *cv-qualifier*s, which affect the type of the `this` pointer
 [[expr.prim.this]], and/or a *ref-qualifier* [[dcl.fct]]; both affect
-overload resolution [[over.match.funcs]] — *end note*]
 An implicit object member function may be declared virtual
 [[class.virtual]] or pure virtual [[class.abstract]].
 ### Special member functions <a id="special">[[special]]</a>
@@ -913,11 +1017,11 @@ 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
@@ -927,15 +1031,16 @@ Two special member functions are of the same kind if:
 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*.
 ### Constructors <a id="class.ctor">[[class.ctor]]</a>
@@ -995,12 +1100,10 @@ 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*]
@@ -1026,79 +1129,81 @@ A constructor shall not have an explicit object parameter [[dcl.fct]].
 #### 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*.
-An implicitly-defined [[dcl.fct.def.default]] 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 be constexpr-suitable [[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*]
-[*Note 2*:  A default constructor is implicitly invoked to initialize a
 class object when no initializer is specified [[dcl.init.general]]. Such
-a default constructor is required to be accessible
 [[class.access]]. — *end note*]
-[*Note 3*:  [[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>
@@ -1226,11 +1331,11 @@ form
 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&)
@@ -1258,29 +1363,28 @@ 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 of 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
@@ -1292,13 +1396,12 @@ otherwise the copy/move constructor is *non-trivial*.
 [*Note 5*: The copy/move constructor is implicitly defined even if the
 implementation elided its odr-use
 [[term.odr.use]], [[class.temporary]]. — *end note*]
-If an implicitly-defined [[dcl.fct.def.default]] constructor would be
-constexpr-suitable [[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.
@@ -1307,11 +1410,11 @@ 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
@@ -1338,23 +1441,20 @@ 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
 non-object 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 can 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 {
@@ -1386,15 +1486,16 @@ 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
@@ -1404,14 +1505,11 @@ 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 non-object
 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 can 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
@@ -1458,39 +1556,37 @@ the return type `X&`. 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]].
-[*Note 7*: A *using-declaration* in a derived class `C` that names an
 assignment operator from a base class never suppresses the implicit
 declaration of an assignment operator of `C`, even if the base class
 assignment operator would be a copy or move assignment operator if
 declared as a member of `C`. — *end note*]
 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
@@ -1506,11 +1602,11 @@ operator is `constexpr`.
 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 8*: 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
@@ -1585,12 +1681,12 @@ parentheses, and the *id-expression* has one of the following forms:
   `~`*class-name* and the *class-name* is the injected-class-name of the
   class nominated by 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.
@@ -1623,33 +1719,39 @@ when the destructor for the most derived object [[intro.object]] starts.
 [*Note 2*: 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 is
-constexpr-suitable [[dcl.constexpr]].
 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.
@@ -1662,17 +1764,18 @@ created in the program, the destructor shall be defined.
 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]]).
 [*Note 4*: 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. — *end note*]
@@ -1718,11 +1821,11 @@ lookup fails or if the deallocation function has a deleted definition
 [*Note 6*: 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.
@@ -1765,11 +1868,13 @@ member function is not an explicit destructor call
 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);
@@ -1783,17 +1888,19 @@ void g() {                      // rare, specialized use:
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
 — *end note*]
 Once a destructor is invoked for an object, the object’s lifetime ends;
 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 10*:
@@ -1827,11 +1934,11 @@ 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*:
@@ -1854,11 +1961,11 @@ int c = X(a);       // OK, a.operator X().operator int()
 #### 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 {
@@ -1910,17 +2017,10 @@ 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 can be called for implicit type
-conversions. — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
@@ -1939,39 +2039,38 @@ conversion-declarator:
 A declaration whose *declarator-id* has an *unqualified-id* that is a
 *conversion-function-id* declares a *conversion function*; its
 *declarator* shall be a function declarator [[dcl.fct]] of the form
 ``` bnf
-ptr-declarator '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-   ref-qualifier-seqₒₚₜ 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 a *conversion-function-id*;
 - otherwise, the *id-expression* is a *qualified-id* whose
   *unqualified-id* is a *conversion-function-id*.
 A conversion function shall have no non-object parameters and shall be a
-non-static member function of a class or class template `X`; it
-specifies a conversion from `X` to the type specified by the
-*conversion-type-id*, interpreted as a *type-id* [[dcl.name]]. A
-*decl-specifier* in the *decl-specifier-seq* of a conversion function
-(if any) shall not be a *defining-type-specifier*.
-The type of the conversion function is “`noexcept`ₒₚₜ  function taking
-no parameter *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  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 {
@@ -2023,11 +2122,11 @@ void g(X a, X b) {
 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*:
@@ -2052,11 +2151,11 @@ operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
 — *end example*]
 — *end note*]
-[*Note 2*:
 A conversion function in a derived class hides only conversion functions
 in base classes that convert to the same type. A conversion function
 template with a dependent return type hides only templates in base
 classes that correspond to it [[class.member.lookup]]; otherwise, it
@@ -2351,11 +2450,13 @@ cannot be virtual.
 [*Note 1*:
 However, when the *cast-expression* of a *delete-expression* refers to
 an object of class type with a virtual destructor, because the
 deallocation function is chosen by the destructor of the dynamic type of
-the object, the effect is the same in that case. For example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete(void*, std::size_t);
@@ -2385,17 +2486,21 @@ void f() {
 Here, storage for the object of class `D` is deallocated by
 `D::operator delete()`, and the object of class `E` is destroyed and its
 storage is deallocated by `E::operator delete()`, due to the virtual
 destructor.
 — *end note*]
 [*Note 2*:
 Virtual destructors have no effect on the deallocation function actually
 called when the *cast-expression* of a *delete-expression* refers to an
-array of objects of class type. For example,
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete[](void*, std::size_t);
@@ -2411,16 +2516,18 @@ void f(int i) {
   B* bp = new D[i];
   delete[] bp;      // undefined behavior
 }
 ```
 — *end note*]
 Access to the deallocation function is checked statically, even if a
 different one is actually executed.
-[*Example 3*: For the call on line “// 1” above, if
 `B::operator delete()` had been private, the delete expression would
 have been ill-formed. — *end example*]
 [*Note 3*: If a deallocation function has no explicit
 *noexcept-specifier*, it has a non-throwing exception specification
@@ -2513,13 +2620,13 @@ non-static data members can be stored in a union at any time.
 [*Note 1*: One special guarantee is made in order to simplify the use
 of unions: If a standard-layout union contains several standard-layout
 structs that share a common initial sequence [[class.mem]], and if a
 non-static data member of an object of this standard-layout union type
-is active and is one of the standard-layout structs, it is permitted to
-inspect the common initial sequence of any of the standard-layout struct
-members; see  [[class.mem]]. — *end note*]
 The size of a union is sufficient to contain the largest of its
 non-static data members. Each non-static data member is allocated as if
 it were the sole member of a non-union class.
@@ -2529,22 +2636,20 @@ consequence, all non-static data members of a union object have the same
 address. — *end note*]
 A union can have member functions (including constructors and
 destructors), but it shall not have virtual [[class.virtual]] functions.
 A union shall not have base classes. A union shall not be used as a base
-class. If a union contains a non-static data member of reference type
 the program is ill-formed.
 [*Note 3*:
-Absent default member initializers [[class.mem]], if any non-static data
-member of a union has a non-trivial default constructor
-[[class.default.ctor]], copy constructor, move constructor
-[[class.copy.ctor]], copy assignment operator, move assignment operator
-[[class.copy.assign]], or destructor [[class.dtor]], the corresponding
-member function of the union must be user-provided or it will be
-implicitly deleted [[dcl.fct.def.delete]] for the union.
 [*Example 1*:
 Consider the following union:
@@ -2556,13 +2661,14 @@ union U {
 };
 ```
 Since `std::string` [[string.classes]] declares non-trivial versions of
 all of the special member functions, `U` will have an implicitly deleted
-default constructor, copy/move constructor, copy/move assignment
-operator, and destructor. To use `U`, some or all of these member
-functions must be user-provided.
 — *end example*]
 — *end note*]
@@ -2579,17 +2685,19 @@ lifetime of that union member, as described below. For an expression
   subscripting operator, S(E) is S(A) if `A` is of array type, S(B) if
   `B` is of array type, and empty otherwise.
 - Otherwise, S(E) is empty.
 In an assignment expression of the form `E1 = E2` that uses either the
-built-in assignment operator [[expr.ass]] or a trivial assignment
-operator [[class.copy.assign]], for each element `X` of S(`E1`), if
-modification of `X` would have undefined behavior under  [[basic.life]],
-an object of the type of `X` is implicitly created in the nominated
-storage; no initialization is performed and the beginning of its
-lifetime is sequenced after the value computation of the left and right
-operands and before the assignment.
 [*Note 4*: This ends the lifetime of the previously-active member of
 the union, if any [[basic.life]]. — *end note*]
 [*Example 2*:
@@ -2670,15 +2778,16 @@ void f() {
 Here `a` and `p` are used like ordinary (non-member) variables, but
 since they are union members they have the same address.
 — *end example*]
-Anonymous unions declared in the scope of a namespace with external
-linkage shall be declared `static`. Anonymous unions declared at block
-scope shall be declared with any storage class allowed for a block
-variable, or with no storage class. A storage class is not allowed in a
-declaration of an anonymous union in a class scope.
 [*Note 1*:
 A union for which objects, pointers, or references are declared is not
 an anonymous union.
@@ -2768,14 +2877,14 @@ local* p = 0;                   // error: local not found
 An enclosing function has no special access to members of the local
 class; it obeys the usual access rules [[class.access]]. Member
 functions of a local class shall be defined within their class
 definition, if they are defined at all.
-If class `X` is a local class a nested class `Y` may be declared in
-class `X` and later defined in the definition of class `X` or be later
-defined in the same scope as the definition of class `X`. A class nested
-within a local class is a local class.
 [*Note 2*: A local class cannot have static data members
 [[class.static.data]]. — *end note*]
 ## Derived classes <a id="class.derived">[[class.derived]]</a>
@@ -2805,11 +2914,11 @@ base-specifier:
 ``` bnf
 class-or-decltype:
     nested-name-specifierₒₚₜ type-name
     nested-name-specifier template simple-template-id
- decltype-specifier
 ```
 ``` bnf
 access-specifier:
     private
@@ -2824,17 +2933,20 @@ The component names of a *class-or-decltype* are those of its
 *nested-name-specifier*, *type-name*, and/or *simple-template-id*. A
 *class-or-decltype* shall denote a (possibly cv-qualified) class type
 that is not an incompletely defined class [[class.mem]]; any
 cv-qualifiers are ignored. The class denoted by the *class-or-decltype*
 of a *base-specifier* is called a *direct base class* for the class
-being defined. The lookup for the component name of the *type-name* or
-*simple-template-id* is type-only [[basic.lookup]]. A class `B` is a
-base class of a class `D` if it is a direct base class of `D` or a
-direct base class of one of `D`’s base classes. A class is an
-*indirect base class* of another if it is a base class but not a direct
-base class. A class is said to be (directly or indirectly) *derived*
-from its (direct or indirect) base classes.
 [*Note 1*: See [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
 Members of a base class are also members of the derived class.
@@ -3045,29 +3157,29 @@ a distinct `B` subobject within the object of type `AA`. Given the class
 ### Virtual functions <a id="class.virtual">[[class.virtual]]</a>
 A non-static member function is a *virtual function* if it is first
 declared with the keyword `virtual` or if it overrides a virtual member
-function declared in a base class (see below).[^7]
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
 A class with a virtual member function is called a
-*polymorphic class*.[^8]
 If a virtual member function F is declared in a class B, and, in a class
 D derived (directly or indirectly) from B, a declaration of a member
 function G corresponds [[basic.scope.scope]] to a declaration of F,
-ignoring trailing *requires-clause*s, then G *overrides*[^9]
-F. For convenience we say that any virtual function overrides itself. A
 virtual member function V of a class object S is a *final overrider*
 unless the most derived class [[intro.object]] of which S is a base
 class subobject (if any) has another member function that overrides V.
 In a derived class, if a virtual member function of a base class
-subobject has more than one final overrider the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
@@ -3185,11 +3297,11 @@ the return type of the overridden function or *covariant* with the
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
 the following criteria:
 - both are pointers to classes, both are lvalue references to classes,
-  or both are rvalue references to classes[^10]
 - the class in the return type of `B::f` is the same class as the class
   in the return type of `D::f`, or is an unambiguous and accessible
   direct or indirect base class of the class in the return type of
   `D::f`
 - both pointers or references have the same cv-qualification and the
@@ -3505,13 +3617,13 @@ A member of a class can be
 [*Note 1*: A constructor or destructor can be named by an expression
 [[basic.def.odr]] even though it has no name. — *end note*]
 A member of a class can also access all the members to which the class
 has access. A local class of a member function may access the same
-members that the member function itself may access.[^11]
-Members of a class defined with the keyword `class` are `private` by
 default. Members of a class defined with the keywords `struct` or
 `union` are public by default.
 [*Example 1*:
@@ -3554,14 +3666,15 @@ void g(S* sp) {
 — *end example*]
 [*Note 3*:
 Because access control applies to the declarations named, if access
-control is applied to a *typedef-name*, only the accessibility of the
 typedef or alias declaration itself is considered. The accessibility of
-the entity referred to by the *typedef-name* is not considered. For
-example,
 ``` cpp
 class A {
   class B { };
 public:
@@ -3572,10 +3685,12 @@ void f() {
   A::BB x;          // OK, typedef A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
 — *end note*]
 [*Note 4*: Access control does not prevent members from being found by
 name lookup or implicit conversions to base classes from being
 considered. — *end note*]
@@ -3591,26 +3706,26 @@ and, if the entity is a class, the definitions of members of the class
 appearing outside the class’s *member-specification*.
 [*Note 5*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
-[*Example 3*:
 ``` cpp
 class A {
   typedef int I;    // private member
-  I f();
-  friend I g(I);
   static I x;
   template<int> struct Q;
   template<int> friend struct R;
 protected:
     struct B { };
 };
-A::I A::f() { return 0; }
-A::I g(A::I p = A::x);
 A::I g(A::I p) { return 0; }
 A::I A::x = 0;
 template<A::I> struct A::Q { };
 template<A::I> struct R { };
@@ -3635,11 +3750,11 @@ and in member functions of class templates is performed as described in
 [[temp.inst]].
 Access for a default *template-argument* [[temp.param]] is checked in
 the context in which it appears rather than at any points of use of it.
-[*Example 4*:
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
@@ -3746,11 +3861,11 @@ of the derived class. If a class is declared to be a base class for
 another class using the `protected` access specifier, the public and
 protected members of the base class are accessible as protected members
 of the derived class. If a class is declared to be a base class for
 another class using the `private` access specifier, the public and
 protected members of the base class are accessible as private members of
-the derived class.[^12]
 In the absence of an *access-specifier* for a base class, `public` is
 assumed when the derived class is defined with the *class-key* `struct`
 and `private` is assumed when the class is defined with the *class-key*
 `class`.
@@ -3780,11 +3895,13 @@ A member of a private base class can be inaccessible as inherited, but
 accessible directly. Because of the rules on pointer conversions
 [[conv.ptr]] and explicit casts
 [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]], a conversion
 from a pointer to a derived class to a pointer to an inaccessible base
 class can be ill-formed if an implicit conversion is used, but
-well-formed if an explicit cast is used. For example,
 ``` cpp
 class B {
 public:
   int mi;                       // non-static member
@@ -3807,10 +3924,12 @@ void DD::f() {
   ::B* bp2 = (::B*)this;        // OK with cast
   bp2->mi = 3;                  // OK, access through a pointer to B.
 }
 ```
 — *end note*]
 A base class `B` of `N` is *accessible* at *R*, if
 - an invented public member of `B` would be a public member of `N`, or
@@ -3820,11 +3939,11 @@ A base class `B` of `N` is *accessible* at *R*, if
   `N`, and an invented public member of `B` would be a private or
   protected member of `P`, or
 - there exists a class `S` such that `B` is a base class of `S`
   accessible at *R* and `S` is a base class of `N` accessible at *R*.
-[*Example 2*:
 ``` cpp
 class B {
 public:
   int m;
@@ -3851,33 +3970,39 @@ derived class to a pointer to that base class
 [*Note 2*: It follows that members and friends of a class `X` can
 implicitly convert an `X*` to a pointer to a private or protected
 immediate base class of `X`. — *end note*]
-The access to a member is affected by the class in which the member is
-named. This naming class is the class in whose scope name lookup
-performed a search that found the member.
 [*Note 3*: This class can be explicit, e.g., when a *qualified-id* is
 used, or implicit, e.g., when a class member access operator
 [[expr.ref]] is used (including cases where an implicit “`this->`” is
 added). If both a class member access operator and a *qualified-id* are
-used to name the member (as in `p->T::m`), the class naming the member
-is the class denoted by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
-A member `m` is accessible at the point *R* when named in class `N` if
 - `m` as a member of `N` is public, or
 - `m` as a member of `N` is private, and *R* occurs in a direct member
   or friend of class `N`, or
 - `m` as a member of `N` is protected, and *R* occurs in a direct member
   or friend of class `N`, or in a member of a class `P` derived from
   `N`, where `m` as a member of `P` is public, private, or protected, or
 - there exists a base class `B` of `N` that is accessible at *R*, and
-  `m` is accessible at *R* when named in class `B`.
-  \[*Example 3*:
   ``` cpp
   class B;
   class A {
   private:
     int i;
@@ -3893,14 +4018,14 @@ A member `m` is accessible at the point *R* when named in class `N` if
 If a class member access operator, including an implicit “`this->`”, is
 used to access a non-static data member or non-static member function,
 the reference is ill-formed if the left operand (considered as a pointer
 in the “`.`” operator case) cannot be implicitly converted to a pointer
-to the naming class of the right operand.
 [*Note 4*: This requirement is in addition to the requirement that the
-member be accessible as named. — *end note*]
 ### Friends <a id="class.friend">[[class.friend]]</a>
 A friend of a class is a function or class that is given permission to
 name the private and protected members of the class. A class specifies
@@ -3972,31 +4097,26 @@ class Z {
 };
 ```
 — *end example*]
-A friend declaration that does not declare a function shall have one of
-the following forms:
-``` bnf
-friend elaborated-type-specifier ';'
-friend simple-type-specifier ';'
-friend typename-specifier ';'
-```
 [*Note 1*: A friend declaration can be the *declaration* in a
 *template-declaration* [[temp.pre]], [[temp.friend]]. — *end note*]
-If the type specifier in a `friend` declaration designates a (possibly
-cv-qualified) class type, that class is declared as a friend; otherwise,
-the friend declaration is ignored.
 [*Example 4*:
 ``` cpp
 class C;
 typedef C Ct;
 class X1 {
   friend C;                     // OK, class C is a friend
 };
@@ -4004,24 +4124,30 @@ class X2 {
   friend Ct;                    // OK, class C is a friend
   friend D;                     // error: D not found
   friend class D;               // OK, elaborated-type-specifier declares new class
 };
-template <typename T> class R {
-  friend T;
 };
 R<C> rc;                        // class C is a friend of R<C>
-R<int> Ri; // OK, "friend int;" is ignored
 ```
 — *end example*]
-A function first declared in a friend declaration has the linkage of the
-namespace of which it is a member [[basic.link]]. Otherwise, the
-function retains its previous linkage [[dcl.stc]].
 [*Note 2*:
 A friend declaration refers to an entity, not (all overloads of) a name.
 A member function of a class `X` can be a friend of a class `Y`.
@@ -4162,12 +4288,12 @@ void f() {
 ### Protected member access <a id="class.protected">[[class.protected]]</a>
 An additional access check beyond those described earlier in
 [[class.access]] is applied when a non-static data member or non-static
-member function is a protected member of its naming class
-[[class.access.base]].[^13]
 As described earlier, access to a protected member is granted because
 the reference occurs in a friend or direct member of some class `C`. If
 the access is to form a pointer to member [[expr.unary.op]], the
 *nested-name-specifier* shall denote `C` or a class derived from `C`.
@@ -4194,14 +4320,14 @@ class D2 : public B {
 void fr(B* pb, D1* p1, D2* p2) {
   pb->i = 1;                    // error
   p1->i = 2;                    // error
   p2->i = 3;                    // OK (access through a D2)
-  p2->B::i = 4;                 // OK (access through a D2, even though naming class is B)
   int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK (type of &D2::i is int B::*)
-  B::j = 5;                     // error: not a friend of naming class B
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
   pb->i = 1;                    // error
@@ -4360,12 +4486,12 @@ complex f = 3;                  // initialized by calling complex(double) with a
 complex g = { 1, 2 };           // initialized by calling complex(double, double) with arguments 1 and 2
 ```
 — *end example*]
-[*Note 1*:  Overloading of the assignment operator [[over.ass]] has no
-effect on initialization. — *end note*]
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
@@ -4396,13 +4522,13 @@ Here, `x.i` is initialized with 99, `x.f` is initialized with 88.8, and
 [*Note 2*: Braces can be elided in the *initializer-list* for any
 aggregate, even if the aggregate has members of a class type with
 user-defined type conversions; see  [[dcl.init.aggr]]. — *end note*]
 [*Note 3*: If `T` is a class type with no default constructor, any
-declaration of an object of type `T` (or array thereof) is ill-formed if
-no *initializer* is explicitly specified (see  [[class.init]] and
-[[dcl.init]]). — *end note*]
 [*Note 4*:  The order in which objects with static or thread storage
 duration are initialized is described in  [[basic.start.dynamic]] and
 [[stmt.dcl]]. — *end note*]
@@ -4443,11 +4569,11 @@ name as a direct or virtual base class of the class, a
 *mem-initializer-id* naming the member or base class and composed of a
 single identifier refers to the class member. A *mem-initializer-id* for
 the hidden base class can be specified using a qualified
 name. — *end note*]
-Unless the *mem-initializer-id* names the constructor’s class, a
 non-static data member of the constructor’s class, or a direct or
 virtual base of that class, the *mem-initializer* is ill-formed.
 A *mem-initializer-list* can initialize a base class using any
 *class-or-decltype* that denotes that base class type.
@@ -4585,11 +4711,11 @@ renders the program ill-formed.
 [*Note 4*: After the call to a constructor for class `X` for an object
 with automatic or dynamic storage duration has completed, if the
 constructor was not invoked as part of value-initialization and a member
 of `X` is neither initialized nor given a value during execution of the
 *compound-statement* of the body of the constructor, the member has an
-indeterminate value. — *end note*]
 [*Example 6*:
 ``` cpp
 struct A {
@@ -4602,11 +4728,11 @@ struct B {
 struct C {
   C() { }               // initializes members as follows:
   A a;                  // OK, calls A::A()
   const B b;            // error: B has no default constructor
-  int i;                // OK, i has indeterminate value
   int j = 5;            // OK, j has the value 5
 };
 ```
 — *end example*]
@@ -4740,17 +4866,23 @@ the constructor parameter `i`, and initializes `X::j` with the value of
 `X::i`; this takes place each time an object of class `X` is created.
 — *end example*]
 Member functions (including virtual member functions, [[class.virtual]])
-can be called for an object under construction. Similarly, an object
-under construction can be the operand of the `typeid` operator
-[[expr.typeid]] or of a `dynamic_cast` [[expr.dynamic.cast]]. However,
-if these operations are performed in a *ctor-initializer* (or in a
-function called directly or indirectly from a *ctor-initializer*) before
-all the *mem-initializer*s for base classes have completed, the program
-has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
@@ -4807,15 +4939,19 @@ public:
 When a constructor for type `B` is invoked to initialize an object of a
 different type `D` (that is, when the constructor was inherited
 [[namespace.udecl]]), initialization proceeds as if a defaulted default
 constructor were used to initialize the `D` object and each base class
 subobject from which the constructor was inherited, except that the `B`
-subobject is initialized by the invocation of the inherited constructor.
-The complete initialization is considered to be a single function call;
-in particular, the initialization of the inherited constructor’s
-parameters is sequenced before the initialization of any part of the `D`
-object.
 [*Example 1*:
 ``` cpp
 struct B1 {
@@ -4864,14 +5000,33 @@ Class template `Log` wraps any class and forwards all of its
 constructors, while writing a message to the standard log whenever an
 object of class `Log` is destroyed.
 — *end example*]
 If the constructor was inherited from multiple base class subobjects of
 type `B`, the program is ill-formed.
-[*Example 2*:
 ``` cpp
 struct A { A(int); };
 struct B : A { using A::A; };
@@ -4933,11 +5088,11 @@ int* p2 = &bobj.y.i;                    // undefined behavior: refers to member'
 A* pa = &bobj;                          // undefined behavior: upcast to a base class type
 B bobj;                                 // definition of bobj
 extern X xobj;
-int* p3 = &xobj.i;                      // OK, X is a trivial class
 X xobj;
 ```
 For another example,
@@ -4952,14 +5107,14 @@ struct Y {
 };
 ```
 — *end example*]
-During the construction of an object, if the value of the object or any
-of its subobjects is accessed through a glvalue that is not obtained,
-directly or indirectly, from the constructor’s `this` pointer, the value
-of the object or subobject thus obtained is unspecified.
 [*Example 2*:
 ``` cpp
 struct C;
@@ -5025,11 +5180,13 @@ struct E : C, D, X {
 Member functions, including virtual functions [[class.virtual]], can be
 called during construction or destruction [[class.base.init]]. When a
 virtual function is called directly or indirectly from a constructor or
 from a destructor, including during the construction or destruction of
-the class’s non-static data members, and the object to which the call
 applies is the object (call it `x`) under construction or destruction,
 the function called is the final overrider in the constructor’s or
 destructor’s class and not one overriding it in a more-derived class. If
 the virtual function call uses an explicit class member access
 [[expr.ref]] and the object expression refers to the complete object of
@@ -5123,59 +5280,62 @@ B::B(V* v, A* a) {
 — *end example*]
 ### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
 When certain criteria are met, an implementation is allowed to omit the
-copy/move construction of a class object, even if the constructor
-selected for the copy/move operation and/or the destructor for the
-object have side effects. In such cases, the implementation treats the
-source and target of the omitted copy/move operation as simply two
-different ways of referring to the same object. If the first parameter
-of the selected constructor is an rvalue reference to the object’s type,
-the destruction of that object occurs when the target would have been
-destroyed; otherwise, the destruction occurs at the later of the times
-when the two objects would have been destroyed without the
-optimization.[^14]
-This elision of copy/move operations, called *copy elision*, is
-permitted in the following circumstances (which may be combined to
-eliminate multiple copies):
-- in a `return` statement in a function with a class return type, when
- the *expression* is the name of a non-volatile object with automatic
-  storage duration (other than a function parameter or a variable
-  introduced by the *exception-declaration* of a *handler*
- [[except.handle]]) with the same type (ignoring cv-qualification) as
- the function return type, the copy/move operation can be omitted by
- constructing the object directly into the function call’s return
- object
 - in a *throw-expression* [[expr.throw]], when the operand is the name
-  of a non-volatile object with automatic storage duration (other than a
-  function or catch-clause parameter) that belongs to a scope that does
- not contain the innermost enclosing *compound-statement* associated
- with a *try-block* (if there is one), the copy/move operation can be
- omitted by constructing the object directly into the exception object
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
-  and destructor for the parameter copy object
-- when the *exception-declaration* of an exception handler
- [[except.pre]] declares an object of the same type (except for
- cv-qualification) as the exception object [[except.throw]], the copy
- operation can be omitted by treating the *exception-declaration* as an
- alias for the exception object if the meaning of the program will be
- unchanged except for the execution of constructors and destructors for
-  the object declared by the *exception-declaration*. \[*Note 1*: There
-  cannot be a move from the exception object because it is always an
-  lvalue. — *end note*]
 Copy elision is not permitted where an expression is evaluated in a
 context requiring a constant expression [[expr.const]] and in constant
 initialization [[basic.start.static]].
-[*Note 2*: It is possible that copy elision is performed if the same
 expression is evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -5303,22 +5463,40 @@ template<class T> void f() {
 ## Comparisons <a id="class.compare">[[class.compare]]</a>
 ### Defaulted comparison operator functions <a id="class.compare.default">[[class.compare.default]]</a>
-A defaulted comparison operator function [[over.binary]] for some class
-`C` shall be a non-template function that is
-- a non-static member or friend of `C` and
 - either has two parameters of type `const C&` or two parameters of type
   `C`, where the implicit object parameter (if any) is considered to be
   the first parameter.
-Name lookups in the implicit definition [[dcl.fct.def.default]] of a
-comparison operator function are performed from a context equivalent to
-its *function-body*. A definition of a comparison operator as defaulted
-that appears in a class shall be the first declaration of that function.
 A defaulted `<=>` or `==` operator function for class `C` is defined as
 deleted if any non-static data member of `C` is of reference type or `C`
 has variant members [[class.union.anon]].
@@ -5348,11 +5526,11 @@ function has no *noexcept-specifier*, the implicitly-declared `==`
 operator function has an implicit exception specification
 [[except.spec]] that can differ from the implicit exception
 specification of the three-way comparison operator
 function. — *end note*]
-[*Example 1*:
 ``` cpp
 template<typename T> struct X {
   friend constexpr std::partial_ordering operator<=>(X, X) requires (sizeof(T) != 1) = default;
   // implicitly declares: friend constexpr bool operator==(X, X) requires (sizeof(T) != 1) = default;
@@ -5387,17 +5565,17 @@ declared return type `bool`.
 A defaulted `==` operator function for a class `C` is defined as deleted
 unless, for each `xᵢ` in the expanded list of subobjects for an object
 `x` of type `C`, `xᵢ`` == ``xᵢ` is usable [[class.compare.default]].
-The return value `V` of a defaulted `==` operator function with
-parameters `x` and `y` is determined by comparing corresponding elements
-`xᵢ` and `yᵢ` in the expanded lists of subobjects for `x` and `y` (in
-increasing index order) until the first index i where `xᵢ`` == ``yᵢ`
-yields a result value which, when contextually converted to `bool`,
-yields `false`. If no such index exists, `V` is `true`. Otherwise, `V`
-is `false`.
 [*Example 1*:
 ``` cpp
 struct D {
@@ -5414,13 +5592,13 @@ struct D {
 The *synthesized three-way comparison* of type `R` [[cmp.categories]] of
 glvalues `a` and `b` of the same type is defined as follows:
 - If `a <=> b` is usable [[class.compare.default]] and can be explicitly
   converted to `R` using `static_cast`, `static_cast<R>(a <=> b)`.
-- Otherwise, if overload resolution for `a <=> b` is performed and finds
-  at least one viable candidate, the synthesized three-way comparison is
-  not defined.
 - Otherwise, if `R` is not a comparison category type, or either the
   expression `a == b` or the expression `a < b` is not usable, the
   synthesized three-way comparison is not defined.
 - Otherwise, if `R` is `strong_ordering`, then
   ``` cpp
@@ -5457,19 +5635,19 @@ subobjects for an object `x` of type `C`.
   common comparison type (see below) of `R₀`, `R₁`, …, `R_n-1`.
 - Otherwise, `R` shall not contain a placeholder type. If the
   synthesized three-way comparison of type `R` between any objects `xᵢ`
   and `xᵢ` is not defined, the operator function is defined as deleted.
-The return value `V` of type `R` of the defaulted three-way comparison
 operator function with parameters `x` and `y` of the same type is
 determined by comparing corresponding elements `xᵢ` and `yᵢ` in the
 expanded lists of subobjects for `x` and `y` (in increasing index order)
 until the first index i where the synthesized three-way comparison of
 type `R` between `xᵢ` and `yᵢ` yields a result value `vᵢ` where
-`vᵢ` `!=` 0, contextually converted to `bool`, yields `true`; `V` is a
-copy of `vᵢ`. If no such index exists, `V` is
-`static_cast<R>(std::strong_ordering::equal)`.
 The *common comparison type* `U` of a possibly-empty list of n
 comparison category types `T₀`, `T₁`, …, `T_n-1` is defined as follows:
 - If at least one `Tᵢ` is `std::partial_ordering`, `U` is
@@ -5488,18 +5666,22 @@ a secondary comparison operator `@` shall have a declared return type
 `bool`.
 The operator function with parameters `x` and `y` is defined as deleted
 if
-- overload resolution [[over.match]], as applied to `x @ y`, does not
-  result in a usable candidate, or
-- the candidate selected by overload resolution is not a rewritten
-  candidate.
-Otherwise, the operator function yields `x @ y`. The defaulted operator
-function is not considered as a candidate in the overload resolution for
-the `@` operator.
 [*Example 1*:
 ``` cpp
 struct HasNoLessThan { };
@@ -5515,10 +5697,12 @@ struct C {
 <!-- Link reference definitions -->
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lval]: expr.md#basic.lval
@@ -5530,10 +5714,11 @@ struct C {
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
 [class]: #class
 [class.abstract]: #class.abstract
 [class.access]: #class.access
 [class.access.base]: #class.access.base
 [class.access.general]: #class.access.general
@@ -5597,13 +5782,15 @@ struct C {
 [cmp.weakord]: support.md#cmp.weakord
 [conv]: expr.md#conv
 [conv.mem]: expr.md#conv.mem
 [conv.ptr]: expr.md#conv.ptr
 [conv.rval]: expr.md#conv.rval
 [dcl.array]: dcl.md#dcl.array
 [dcl.attr.nouniqueaddr]: dcl.md#dcl.attr.nouniqueaddr
-[dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
@@ -5617,10 +5804,11 @@ struct C {
 [dcl.init.general]: dcl.md#dcl.init.general
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.name]: dcl.md#dcl.name
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.elab]: dcl.md#dcl.type.elab
@@ -5629,14 +5817,13 @@ struct C {
 [depr.impldec]: future.md#depr.impldec
 [depr.static.constexpr]: future.md#depr.static.constexpr
 [diff.class]: compatibility.md#diff.class
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
-[except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
-[expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.delete]: expr.md#expr.delete
@@ -5656,39 +5843,42 @@ struct C {
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.typeid]: expr.md#expr.typeid
 [expr.unary.op]: expr.md#expr.unary.op
 [intro.execution]: basic.md#intro.execution
 [intro.object]: basic.md#intro.object
 [namespace.udecl]: dcl.md#namespace.udecl
 [over]: over.md#over
-[over.ass]: over.md#over.ass
 [over.best.ics]: over.md#over.best.ics
 [over.binary]: over.md#over.binary
-[over.ics.ref]: over.md#over.ics.ref
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
 [over.match.call]: over.md#over.match.call
 [over.match.copy]: over.md#over.match.copy
 [over.match.funcs]: over.md#over.match.funcs
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [special]: #special
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.return]: stmt.md#stmt.return
 [string.classes]: strings.md#string.classes
 [temp.arg]: temp.md#temp.arg
 [temp.constr]: temp.md#temp.constr
 [temp.constr.order]: temp.md#temp.constr.order
 [temp.deduct.guide]: temp.md#temp.deduct.guide
-[temp.dep.type]: temp.md#temp.dep.type
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.friend]: temp.md#temp.friend
 [temp.inst]: temp.md#temp.inst
 [temp.mem]: temp.md#temp.mem
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.layout.compatible.type]: basic.md#term.layout.compatible.type
 [term.object.representation]: basic.md#term.object.representation
@@ -5697,61 +5887,46 @@ struct C {
 [^1]: This ensures that two subobjects that have the same class type and
     that belong to the same most derived object are not allocated at the
     same address [[expr.eq]].
-[^2]: See, for example, `<cstring>`.
-[^3]: This implies that the reference parameter of the
     implicitly-declared copy constructor cannot bind to a `volatile`
     lvalue; see  [[diff.class]].
-[^4]: Because a template assignment operator or an assignment operator
     taking an rvalue reference parameter is never a copy assignment
     operator, the presence of such an assignment operator does not
     suppress the implicit declaration of a copy assignment operator.
     Such assignment operators participate in overload resolution with
     other assignment operators, including copy assignment operators,
     and, if selected, will be used to assign an object.
-[^5]: This implies that the reference parameter of the
     implicitly-declared copy assignment operator cannot bind to a
     `volatile` lvalue; see  [[diff.class]].
-[^6]: These conversions are considered as standard conversions for the
-    purposes of overload resolution [[over.best.ics]], [[over.ics.ref]]
-    and therefore initialization [[dcl.init]] and explicit casts
-    [[expr.static.cast]]. A conversion to `void` does not invoke any
-    conversion function [[expr.static.cast]]. Even though never directly
-    called to perform a conversion, such conversion functions can be
-    declared and can potentially be reached through a call to a virtual
-    conversion function in a base class.
-[^7]: The use of the `virtual` specifier in the declaration of an
     overriding function is valid but redundant (has empty semantics).
-[^8]: If all virtual functions are immediate functions, the class is
     still polymorphic even if its internal representation does not
     otherwise require any additions for that polymorphic behavior.
-[^9]: A function with the same name but a different parameter list
     [[over]] as a virtual function is not necessarily virtual and does
     not override. Access control [[class.access]] is not considered in
     determining overriding.
-[^10]: Multi-level pointers to classes or references to multi-level
     pointers to classes are not allowed.
-[^11]: Access permissions are thus transitive and cumulative to nested
     and local classes.
-[^12]: As specified previously in [[class.access]], private members of a
     base class remain inaccessible even to derived classes unless friend
     declarations within the base class definition are used to grant
     access explicitly.
-[^13]: This additional check does not apply to other members, e.g.,
     static data members or enumerator member constants.
-[^14]: Because only one object is destroyed instead of two, and one
-    copy/move constructor is not executed, there is still one object
-    destroyed for each one constructed.

     class-head '{' member-specificationₒₚₜ '}'
 ```
 ``` bnf
 class-head:
+    class-key attribute-specifier-seqₒₚₜ class-head-name class-property-specifier-seqₒₚₜ base-clauseₒₚₜ
     class-key attribute-specifier-seqₒₚₜ base-clauseₒₚₜ
 ```
 ``` bnf
 class-head-name:
     nested-name-specifierₒₚₜ class-name
 ```
 ``` bnf
+class-property-specifier-seq:
+    class-property-specifier class-property-specifier-seqₒₚₜ
+```
+``` bnf
+class-property-specifier:
     final
+    trivially_relocatable_if_eligible
+    replaceable_if_eligible
 ```
 ``` bnf
 class-key:
     class
 A class declaration where the *class-name* in the *class-head-name* is a
 *simple-template-id* shall be an explicit specialization
 [[temp.expl.spec]] or a partial specialization [[temp.spec.partial]]. A
 *class-specifier* whose *class-head* omits the *class-head-name* defines
+an *unnamed class*.
 [*Note 1*: An unnamed class thus can’t be `final`. — *end note*]
 Otherwise, the *class-name* is an *identifier*; it is not looked up, and
 the *class-specifier* introduces it.
+The component name of the *class-name* is also bound in the scope of the
+class (template) itself; this is known as the *injected-class-name*. For
+purposes of access checking, the injected-class-name is treated as if it
+were a public member name. A *class-specifier* is commonly referred to
+as a *class definition*. A class is considered defined after the closing
 brace of its *class-specifier* has been seen even though its member
 functions are in general not yet defined. The optional
 *attribute-specifier-seq* appertains to the class; the attributes in the
 *attribute-specifier-seq* are thereafter considered attributes of the
 class whenever it is named.
 [*Note 2*: The *class-key* determines whether the class is a union
 [[class.union]] and whether access is public or private by default
 [[class.access]]. A union holds the value of at most one data member at
 a time. — *end note*]
+Each *class-property-specifier* shall appear at most once within a
+single *class-property-specifier-seq*. Whenever a *class-key* is
+followed by a *class-head-name*, one of the identifiers `final`,
+`trivially_relocatable_if_eligible`, or `replaceable_if_eligible`, and a
+colon or left brace, the identifier is interpreted as a
+*class-property-specifier*.
 [*Example 2*:
 ``` cpp
 struct A;
 struct A final {};      // OK, definition of struct A,
                         // not value-initialization of variable final
 struct X {
  struct C { constexpr operator int() { return 5; } };
+ struct B trivially_relocatable_if_eligible : C{};
+                        // OK, definition of nested class B,
+                        // not declaration of a bit-field member
+                        // trivially_relocatable_if_eligible
 };
 ```
 — *end example*]
+If a class is marked with the *class-property-specifier* `final` and
+that class appears as a *class-or-decltype* in a *base-clause*
+[[class.derived]], the program is ill-formed.
 [*Note 3*: Complete objects of class type have nonzero size. Base class
 subobjects and members declared with the `no_unique_address` attribute
 [[dcl.attr.nouniqueaddr]] are not so constrained. — *end note*]
 [*Note 4*: Class objects can be assigned
+[[over.assign]], [[class.copy.assign]], passed as arguments to functions
 [[dcl.init]], [[class.copy.ctor]], and returned by functions (except
 objects of classes for which copying or moving has been restricted; see
 [[dcl.fct.def.delete]] and [[class.access]]). Other plausible operators,
 such as equality comparison, can be defined by the user; see
 [[over.oper]]. — *end note*]
   [[special]], [[class.copy.ctor]], [[class.copy.assign]],
 - where each eligible copy constructor, move constructor, copy
   assignment operator, and move assignment operator is trivial, and
 - that has a trivial, non-deleted destructor [[class.dtor]].
+A class `C` is *default-movable* if
+- overload resolution for direct-initializing an object of type `C` from
+  an xvalue of type `C` selects a constructor that is a direct member of
+  `C` and is neither user-provided nor deleted,
+- overload resolution for assigning to an lvalue of type `C` from an
+  xvalue of type `C` selects an assignment operator function that is a
+  direct member of `C` and is neither user-provided nor deleted, and
+- `C` has a destructor that is neither user-provided nor deleted.
+A class is *eligible for trivial relocation* unless it
+- has any virtual base classes,
+- has a base class that is not a trivially relocatable class,
+- has a non-static data member of an object type that is not of a
+  trivially relocatable type, or
+- has a deleted destructor,
+except that it is *implementation-defined* whether an otherwise-eligible
+union having one or more subobjects of polymorphic class type is
+eligible for trivial relocation.
+A class `C` is a *trivially relocatable class* if it is eligible for
+trivial relocation and
+- has the `trivially_relocatable_if_eligible`
+  *class-property-specifier*,
+- is a union with no user-declared special member functions, or
+- is default-movable.
+[*Note 1*: A class with const-qualified or reference non-static data
+members can be trivially relocatable. — *end note*]
+A class `C` is *eligible for replacement* unless
+- it has a base class that is not a replaceable class,
+- it has a non-static data member that is not of a replaceable type,
+- overload resolution fails or selects a deleted constructor when
+  direct-initializing an object of type `C` from an xvalue of type `C`
+  [[dcl.init.general]],
+- overload resolution fails or selects a deleted assignment operator
+  function when assigning to an lvalue of type `C` from an xvalue of
+  type `C` [[expr.assign]], [[over.assign]], or
+- it has a deleted destructor.
+A class `C` is a *replaceable class* if it is eligible for replacement
+and
+- has the `replaceable_if_eligible` *class-property-specifier*,
+- is a union with no user-declared special member functions, or
+- is default-movable.
+[*Note 2*: Accessibility of the special member functions is not
+considered when establishing trivial relocatability or
+replaceability. — *end note*]
+[*Note 3*: Not all trivially copyable classes are trivially relocatable
+or replaceable. — *end note*]
 A class `S` is a *standard-layout class* if it:
 - has no non-static data members of type non-standard-layout class (or
   array of such types) or reference,
 - has at most one base class subobject of any given type,
 - has all non-static data members and bit-fields in the class and its
   base classes first declared in the same class, and
 - has no element of the set M(S) of types as a base class, where for any
   type `X`, M(X) is defined as follows.[^1]
+  \[*Note 4*: M(X) is the set of the types of all non-base-class
   subobjects that can be at a zero offset in `X`. — *end note*]
   - If `X` is a non-union class type with no non-static data members,
     the set M(X) is empty.
   - If `X` is a non-union class type with a non-static data member of
     type X₀ that is either of zero size or is the first non-static data
 A *standard-layout struct* is a standard-layout class defined with the
 *class-key* `struct` or the *class-key* `class`. A
 *standard-layout union* is a standard-layout class defined with the
 *class-key* `union`.
+[*Note 5*: Standard-layout classes are useful for communicating with
 code written in other programming languages. Their layout is specified
+in  [[class.mem.general]] and  [[expr.rel]]. — *end note*]
 [*Example 2*:
 ``` cpp
+struct N {          // neither trivially copyable nor standard-layout
   int i;
   int j;
   virtual ~N();
 };
+struct T {          // trivially copyable but not standard-layout
   int i;
 private:
   int j;
 };
+struct SL {         // standard-layout but not trivially copyable
   int i;
   int j;
   ~SL();
 };
+struct POD {        // both trivially copyable and standard-layout
   int i;
   int j;
 };
 ```
 — *end example*]
+[*Note 6*: Aggregates of class type are described in
 [[dcl.init.aggr]]. — *end note*]
 A class `S` is an *implicit-lifetime class* if
 - it is an aggregate whose destructor is not user-provided or
 [*Note 3*:
 The declaration of a class name takes effect immediately after the
 *identifier* is seen in the class definition or
+*elaborated-type-specifier*.
+[*Example 6*:
 ``` cpp
 class A * A;
 ```
 first specifies `A` to be the name of a class and then redefines it as
 the name of a pointer to an object of that class. This means that the
 elaborated form `class` `A` must be used to refer to the class. Such
 artistry with names can be confusing and is best avoided.
+— *end example*]
 — *end note*]
 A *simple-template-id* is only a *class-name* if its *template-name*
 names a class template.
 ``` bnf
 member-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ member-declarator-listₒₚₜ ';'
     function-definition
+    friend-type-declaration
     using-declaration
     using-enum-declaration
     static_assert-declaration
+    consteval-block-declaration
     template-declaration
     explicit-specialization
     deduction-guide
     alias-declaration
     opaque-enum-declaration
     member-declarator-list ',' member-declarator
 ```
 ``` bnf
 member-declarator:
+    declarator virt-specifier-seqₒₚₜ function-contract-specifier-seqₒₚₜ pure-specifierₒₚₜ
+    declarator requires-clause function-contract-specifier-seqₒₚₜ
+    declarator brace-or-equal-initializer
     identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
 ```
 ``` bnf
 virt-specifier-seq:
+    virt-specifier virt-specifier-seqₒₚₜ
 ```
 ``` bnf
 virt-specifier:
     override
 ``` bnf
 pure-specifier:
     '=' '0'
 ```
+``` bnf
+friend-type-declaration:
+    friend friend-type-specifier-list ';'
+```
+``` bnf
+friend-type-specifier-list:
+    friend-type-specifier '...'ₒₚₜ
+    friend-type-specifier-list ',' friend-type-specifier '...'ₒₚₜ
+```
+``` bnf
+friend-type-specifier:
+    simple-type-specifier
+    elaborated-type-specifier
+    typename-specifier
+```
+In the absence of a *virt-specifier-seq*, the token sequence `= 0` is
+treated as a *pure-specifier* if the type of the *declarator-id*
+[[dcl.meaning.general]] is a function type, and is otherwise treated as
+a *brace-or-equal-initializer*.
+[*Note 1*: If the member declaration acquires a function type through
+template instantiation, the program is ill-formed; see
+[[temp.spec.general]]. — *end note*]
+The optional *function-contract-specifier-seq* [[dcl.contract.func]] in
+a *member-declarator* shall be present only if the *declarator* declares
+a function.
 The *member-specification* in a class definition declares the full set
 of members of the class; no member can be added elsewhere. A
 *direct member* of a class `X` is a member of `X` that was first
 declared within the *member-specification* of `X`, including anonymous
 union members [[class.union.anon]] and direct members thereof. Members
 of a class are data members, member functions [[class.mfct]], nested
 types, enumerators, and member templates [[temp.mem]] and
 specializations thereof.
+[*Note 2*: A specialization of a static data member template is a
 static data member. A specialization of a member function template is a
 member function. A specialization of a member class template is a nested
 class. — *end note*]
+A *member-declaration* does not itself declare new members of the class
+if it is
 - a friend declaration [[class.friend]],
 - a *deduction-guide* [[temp.deduct.guide]],
 - a *template-declaration* whose *declaration* is one of the above,
 - a *static_assert-declaration*,
+- a *consteval-block-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 either a non-function member introduced by a
+*member-declarator* or an anonymous union member. A *member function* is
+a member that is a function. Nested types are classes
+[[class.name]], [[class.nest]] and enumerations [[dcl.enum]] declared in
+the class and arbitrary types declared as members by use of a typedef
+declaration [[dcl.typedef]] or *alias-declaration*. The enumerators of
+an unscoped enumeration [[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).
+Every object of class type has a unique member subobject corresponding
+to each of its direct non-static data members. If any non-static data
+member of a class `C` is of reference type, then let `D` be an invented
+class that is identical to `C` except that each non-static member of `D`
+corresponding to a member of `C` of type “reference to `T`” instead has
+type “pointer to `T`”. Every member subobject of a complete object of
+type `C` has the same size, alignment, and offset as that of the
+corresponding subobject of a complete object of type `D`. The size and
+alignment of `C` are the same as the size and alignment of `D`.
 A member shall not be declared twice in the *member-specification*,
 except that
 - a nested class or member class template can be declared and then later
 A *complete-class context* of a class (template) is a
 - function body [[dcl.fct.def.general]],
 - default argument [[dcl.fct.default]],
 - default template argument [[temp.param]],
+- *noexcept-specifier* [[except.spec]],
+- *function-contract-specifier* [[dcl.contract.func]], or
 - default member initializer
 within the *member-specification* of the class or class template.
 [*Note 4*: A complete-class context of a nested class is also a
 complete-class context of any enclosing class, if the nested class is
 defined within the *member-specification* of the enclosing
 class. — *end note*]
+A class `C` is complete at a program point P if the definition of `C` is
+reachable from P [[module.reach]] or if P is in a complete-class context
+of `C`. Otherwise, `C` is incomplete at P.
+If a *member-declaration* matches the syntactic requirements of
+*friend-type-declaration*, it is a *friend-type-declaration*.
 In a *member-declarator*, an `=` immediately following the *declarator*
 is interpreted as introducing a *pure-specifier* if the *declarator-id*
 has function type, otherwise it is interpreted as introducing a
 *brace-or-equal-initializer*.
 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
   enumeration type; and
 - every member of every anonymous union that is a member of class `T`.
 in each of the structs, such that
 - corresponding entities have layout-compatible types [[basic.types]],
 - corresponding entities have the same alignment requirements
   [[basic.align]],
+- if a *has-attribute-expression* [[cpp.cond]] is not `0` for the
+ `no_unique_address` attribute, then neither entity is declared with
+  the `no_unique_address` attribute [[dcl.attr.nouniqueaddr]], and
 - either both entities are bit-fields with the same width or neither is
   a bit-field.
 [*Example 4*:
 [*Note 12*: The object and its first subobject are
 pointer-interconvertible
 [[basic.compound]], [[expr.static.cast]]. — *end note*]
+A *data member description* is a quintuple (T, N, A, W, NUA) describing
+the potential declaration of a non-static data member where
+- T is a type,
+- N is an *identifier* or $\bot$,
+- A is an alignment or $\bot$,
+- W is a bit-field width or $\bot$, and
+- NUA is a boolean value.
+Two data member descriptions are equal if each of their respective
+components are the same entities, are the same identifiers, have equal
+values, or are both $\bot$.
+[*Note 13*:
+The components of a data member description describe a data member such
+that
+- its type is specified using the type given by T,
+- it is declared with the name given by N if N is not $\bot$ and is
+  otherwise unnamed,
+- it is declared with the *alignment-specifier* [[dcl.align]] given by
+  `alignas(A)` if A is not $\bot$ and is otherwise declared without an
+  *alignment-specifier*,
+- it is a bit-field [[class.bit]] with the width given by W if W is not
+  $\bot$ and is otherwise not a bit-field, and
+- it is declared with the attribute `[[no_unique_address]]`
+  [[dcl.attr.nouniqueaddr]] if NUA is true and is otherwise declared
+  without that attribute.
+Data member descriptions are represented by reflections
+[[basic.fundamental]] returned by `std::meta::data_member_spec`
+[[meta.reflection.define.aggregate]] and can be reified as data members
+of a class using `std::meta::define_aggregate`.
+— *end note*]
 ### Member functions <a id="class.mfct">[[class.mfct]]</a>
 If a member function is attached to the global module and is defined
 [[dcl.fct.def]] in its class definition, it is inline [[dcl.inline]].
 [*Note 2*:
 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]] and [[temp.arg]].
+[*Example 2*:
 ``` cpp
 typedef void fv();
 typedef void fvc() const;
 struct S {
 fv  S::* pmfv1 = &S::memfunc1;
 fv  S::* pmfv2 = &S::memfunc2;
 fvc S::* pmfv3 = &S::memfunc3;
 ```
+— *end example*]
 — *end note*]
 ### Non-static member functions <a id="class.mfct.non.static">[[class.mfct.non.static]]</a>
 [[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.
+[*Note 1*: An implicit object member function can be declared with
 *cv-qualifier*s, which affect the type of the `this` pointer
 [[expr.prim.this]], and/or a *ref-qualifier* [[dcl.fct]]; both affect
+overload resolution [[over.match.funcs]]. — *end note*]
 An implicit object member function may be declared virtual
 [[class.virtual]] or pure virtual [[class.abstract]].
 ### Special member functions <a id="special">[[special]]</a>
 [*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
 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 whose associated
+  constraints, if any, are satisfied is more constrained
   [[temp.constr.order]].
+For a class, its direct 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*.
 ### Constructors <a id="class.ctor">[[class.ctor]]</a>
 — *end example*]
 [*Note 2*: For initialization of objects of class type see
 [[class.init]]. — *end note*]
 [*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*]
 #### 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 or constructor
+template 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
 - any non-static data member with no default member initializer
   [[class.mem]] is of reference type,
+- `X` is a non-union class and any non-variant non-static data member of
+ const-qualified type (or possibly multidimensional array thereof) with
+ no *brace-or-equal-initializer* is not const-default-constructible
+  [[dcl.init]],
+- any non-variant potentially constructed subobject, except for a
+  non-static data member with a *brace-or-equal-initializer*, has class
+  type `M` (or possibly multidimensional array thereof) and overload
   resolution [[over.match]] as applied to find `M`’s corresponding
+  constructor does not result in a usable candidate
+ [[over.match.general]], or
+- any potentially constructed subobject S has class type `M` (or
+ possibly multidimensional array thereof), `M` has a destructor that is
+ deleted or inaccessible from the defaulted default constructor, and
+  either S is non-variant or S has a default member initializer.
+A default constructor for a class `X` is *trivial* if it is not
+user-provided and if
+- `X` has no virtual functions [[class.virtual]] and no virtual base
+  classes [[class.mi]], and
+- no non-static data member of `X` has a default member initializer
+  [[class.mem]], and
+- all the direct base classes of `X` have trivial default constructors,
+  and
+- either `X` is a union or for all the non-variant non-static data
+ members of `X` that are of class type (or array thereof), each such
+ class has a trivial default constructor.
 Otherwise, the default constructor is *non-trivial*.
+If a default constructor of a union-like class `X` is trivial, then for
+each union `U` that is either `X` or an anonymous union member of `X`,
+if the first variant member, if any, of `U` has implicit-lifetime type
+[[basic.types.general]], the default constructor of `X` begins the
+lifetime of that member if it is not the active member of its union.
+[*Note 1*: It is already the active member if `U` was
+value-initialized. — *end note*]
+Otherwise, an implicitly-defined [[dcl.fct.def.default]] 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. 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 2*: 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*]
+[*Note 3*:  A default constructor is implicitly invoked to initialize a
 class object when no initializer is specified [[dcl.init.general]]. Such
+a default constructor needs to be accessible
 [[class.access]]. — *end note*]
+[*Note 4*:  [[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>
 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&`.[^2]
 Otherwise, the implicitly-declared copy constructor 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 of type `M` (or possibly
+ multidimensional array thereof) for which overload resolution
   [[over.match]], as applied to find `M`’s corresponding constructor,
+ either does not result in a usable candidate [[over.match.general]]
+ or, in the case of a variant member, selects a non-trivial function,
+- any potentially constructed subobject of class type `M` (or possibly
+ multidimensional array thereof) where `M` has 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
 [*Note 5*: The copy/move constructor is implicitly defined even if the
 implementation elided its odr-use
 [[term.odr.use]], [[class.temporary]]. — *end note*]
+The implicitly-defined [[dcl.fct.def.default]] 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.
 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. — *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
 ### 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
 non-object parameter of type `X`, `X&`, `const X&`, `volatile X&`, or
+`const volatile X&`.[^3]
+[*Note 1*: More than one form of copy assignment operator can be
 declared for a class. — *end note*]
+[*Note 2*:
+If a class `X` only has a copy assignment operator with a non-object
+parameter of type `X&`, an expression of type const `X` cannot be
+assigned to an object of type `X`.
 [*Example 1*:
 ``` cpp
 struct X {
 ```
 if
 - each direct base class `B` of `X` has a copy assignment operator whose
+ non-object 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 non-object parameter is of type `const M&`,
+ `const volatile M&`, or `M`.[^4]
 Otherwise, the implicitly-declared copy assignment operator will have
 the form
 ``` cpp
 A user-declared move assignment operator `X::operator=` is a non-static
 non-template member function of class `X` with exactly one non-object
 parameter of type `X&&`, `const X&&`, `volatile X&&`, or
 `const volatile X&&`.
+[*Note 3*: More than one form of move assignment operator can 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
 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 non-static data member of `const` non-class type (or possibly
+ multidimensional array thereof), or
 - a non-static data member of reference type, or
+- a direct non-static data member of class type `M` (or possibly
+ multidimensional 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, either does not
+ result in a usable candidate [[over.match.general]] or, in the case of
+ a variant member, selects a non-trivial function.
+[*Note 4*: 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.assign]].
+[*Note 5*: A *using-declaration* in a derived class `C` that names an
 assignment operator from a base class never suppresses the implicit
 declaration of an assignment operator of `C`, even if the base class
 assignment operator would be a copy or move assignment operator if
 declared as a member of `C`. — *end note*]
 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
 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 6*: 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
   `~`*class-name* and the *class-name* is the injected-class-name of the
   class nominated by 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`, or
+`constexpr`.
 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.
 [*Note 2*: 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 non-union class and any non-variant potentially constructed
+ subobject has class type `M` (or possibly multidimensional array
+  thereof) where `M` has a destructor that is deleted or is inaccessible
+ from the defaulted destructor,
+- `X` is a union and
+ - overload resolution to select a constructor to default-initialize an
+    object of type `X` either fails or selects a constructor that is
+    either deleted or not trivial, or
+  - `X` has a variant member `V` of class type `M` (or possibly
+    multi-dimensional array thereof) where `V` has a default member
+    initializer and `M` has a destructor that is non-trivial, 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 for a class `X` is trivial if it is not user-provided and
+if
 - the destructor is not virtual,
+- all of the direct base classes of `X` have trivial destructors, and
+- either `X` is a union or for all of the non-variant non-static data
+  members of `X` 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.
 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.
 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 other than anonymous unions, 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]]).
 [*Note 4*: 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. — *end note*]
 [*Note 6*: 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 *computed-type-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.
 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.
+[*Example 2*:
 ``` cpp
 void* operator new(std::size_t, void* p) { return p; }
 struct X {
   X(int);
   f(p);
   p->X::~X();                   // cleanup
 }
 ```
+— *end example*]
 — *end note*]
 Once a destructor is invoked for an object, the object’s lifetime ends;
 the behavior is undefined if the destructor is invoked for an object
 whose lifetime has ended [[basic.life]].
+[*Example 3*: 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 10*:
 [[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. — *end note*]
 At most one user-defined conversion (constructor or conversion function)
 is implicitly applied to a single value.
 [*Example 1*:
 #### 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.
 [*Example 1*:
 ``` cpp
 struct X {
 — *end example*]
 — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
 A declaration whose *declarator-id* has an *unqualified-id* that is a
 *conversion-function-id* declares a *conversion function*; its
 *declarator* shall be a function declarator [[dcl.fct]] of the form
 ``` bnf
+noptr-declarator parameters-and-qualifiers
 ```
+where the *noptr-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 a *conversion-function-id*;
 - otherwise, the *id-expression* is a *qualified-id* whose
   *unqualified-id* is a *conversion-function-id*.
 A conversion function shall have no non-object parameters and shall be a
+non-static member function of a class or class template `X`; its
+declared return type is the *conversion-type-id* and it specifies a
+conversion from `X` to the type specified by the *conversion-type-id*,
+interpreted as a *type-id* [[dcl.name]]. A *decl-specifier* in the
+*decl-specifier-seq* of a conversion function (if any) shall not be a
+*defining-type-specifier*.
+[*Note 1*: A conversion function is never invoked for implicit or
+explicit conversions of an object to the same object type (or a
+reference to it), to a base class of that type (or a reference to it),
+or to cv `void`. Even though never directly called to perform a
+conversion, such conversion functions can be declared and can
+potentially be reached through a call to a virtual conversion function
+in a base class. — *end note*]
 [*Example 1*:
 ``` cpp
 struct X {
 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 2*:
 This prevents ambiguities between the declarator operator `*` and its
 expression counterparts.
 [*Example 3*:
 — *end example*]
 — *end note*]
+[*Note 3*:
 A conversion function in a derived class hides only conversion functions
 in base classes that convert to the same type. A conversion function
 template with a dependent return type hides only templates in base
 classes that correspond to it [[class.member.lookup]]; otherwise, it
 [*Note 1*:
 However, when the *cast-expression* of a *delete-expression* refers to
 an object of class type with a virtual destructor, because the
 deallocation function is chosen by the destructor of the dynamic type of
+the object, the effect is the same in that case.
+[*Example 3*:
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete(void*, std::size_t);
 Here, storage for the object of class `D` is deallocated by
 `D::operator delete()`, and the object of class `E` is destroyed and its
 storage is deallocated by `E::operator delete()`, due to the virtual
 destructor.
+— *end example*]
 — *end note*]
 [*Note 2*:
 Virtual destructors have no effect on the deallocation function actually
 called when the *cast-expression* of a *delete-expression* refers to an
+array of objects of class type.
+[*Example 4*:
 ``` cpp
 struct B {
   virtual ~B();
   void operator delete[](void*, std::size_t);
   B* bp = new D[i];
   delete[] bp;      // undefined behavior
 }
 ```
+— *end example*]
 — *end note*]
 Access to the deallocation function is checked statically, even if a
 different one is actually executed.
+[*Example 5*: For the call on line “// 1” above, if
 `B::operator delete()` had been private, the delete expression would
 have been ill-formed. — *end example*]
 [*Note 3*: If a deallocation function has no explicit
 *noexcept-specifier*, it has a non-throwing exception specification
 [*Note 1*: One special guarantee is made in order to simplify the use
 of unions: If a standard-layout union contains several standard-layout
 structs that share a common initial sequence [[class.mem]], and if a
 non-static data member of an object of this standard-layout union type
+is active and is one of the standard-layout structs, the common initial
+sequence of any of the standard-layout struct members can be inspected;
+see  [[class.mem]]. — *end note*]
 The size of a union is sufficient to contain the largest of its
 non-static data members. Each non-static data member is allocated as if
 it were the sole member of a non-union class.
 address. — *end note*]
 A union can have member functions (including constructors and
 destructors), but it shall not have virtual [[class.virtual]] functions.
 A union shall not have base classes. A union shall not be used as a base
+class. If a union contains a non-static data member of reference type,
 the program is ill-formed.
 [*Note 3*:
+If any non-static data member of a union has a non-trivial copy
+constructor, move constructor [[class.copy.ctor]], copy assignment
+operator, or move assignment operator [[class.copy.assign]], the
+corresponding member function of the union must be user-provided or it
+will be implicitly deleted [[dcl.fct.def.delete]] for the union.
 [*Example 1*:
 Consider the following union:
 };
 ```
 Since `std::string` [[string.classes]] declares non-trivial versions of
 all of the special member functions, `U` will have an implicitly deleted
+copy/move constructor and copy/move assignment operator. The default
+constructor and destructor of `U` are both trivial even though
+`std::string` has a non-trivial default constructor and a non-trivial
+destructor.
 — *end example*]
 — *end note*]
   subscripting operator, S(E) is S(A) if `A` is of array type, S(B) if
   `B` is of array type, and empty otherwise.
 - Otherwise, S(E) is empty.
 In an assignment expression of the form `E1 = E2` that uses either the
+built-in assignment operator [[expr.assign]] or a trivial assignment
+operator [[class.copy.assign]], for each element `X` of S(`E1`) and each
+anonymous union member `X` [[class.union.anon]] that is a member of a
+union and has such an element as an immediate subobject (recursively),
+if modification of `X` would have undefined behavior under
+[[basic.life]], an object of the type of `X` is implicitly created in
+the nominated storage; no initialization is performed and the beginning
+of its lifetime is sequenced after the value computation of the left and
+right operands and before the assignment.
 [*Note 4*: This ends the lifetime of the previously-active member of
 the union, if any [[basic.life]]. — *end note*]
 [*Example 2*:
 Here `a` and `p` are used like ordinary (non-member) variables, but
 since they are union members they have the same address.
 — *end example*]
+An anonymous union declared in the scope of a namespace with external
+linkage shall use the *storage-class-specifier* `static`. Anonymous
+unions declared at block scope shall not use a *storage-class-specifier*
+that is not permitted in the declaration of a block variable. An
+anonymous union declaration at class scope shall not have a
+*storage-class-specifier*.
 [*Note 1*:
 A union for which objects, pointers, or references are declared is not
 an anonymous union.
 An enclosing function has no special access to members of the local
 class; it obeys the usual access rules [[class.access]]. Member
 functions of a local class shall be defined within their class
 definition, if they are defined at all.
+A class nested within a local class is a local class. A member of a
+local class `X` shall be declared only in the definition of `X` or, if
+the member is a nested class, in the nearest enclosing block scope of
+`X`.
 [*Note 2*: A local class cannot have static data members
 [[class.static.data]]. — *end note*]
 ## Derived classes <a id="class.derived">[[class.derived]]</a>
 ``` bnf
 class-or-decltype:
     nested-name-specifierₒₚₜ type-name
     nested-name-specifier template simple-template-id
+ computed-type-specifier
 ```
 ``` bnf
 access-specifier:
     private
 *nested-name-specifier*, *type-name*, and/or *simple-template-id*. A
 *class-or-decltype* shall denote a (possibly cv-qualified) class type
 that is not an incompletely defined class [[class.mem]]; any
 cv-qualifiers are ignored. The class denoted by the *class-or-decltype*
 of a *base-specifier* is called a *direct base class* for the class
+being defined; for each such *base-specifier*, the corresponding
+*direct base class relationship* is the ordered pair (`D`, `B`) where
+`D` is the class being defined and `B` is the direct base class. The
+lookup for the component name of the *type-name* or *simple-template-id*
+is type-only [[basic.lookup]]. A class `B` is a base class of a class
+`D` if it is a direct base class of `D` or a direct base class of one of
+`D`’s base classes. A class is an *indirect base class* of another if it
+is a base class but not a direct base class. A class is said to be
+(directly or indirectly) *derived* from its (direct or indirect) base
+classes.
 [*Note 1*: See [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
 Members of a base class are also members of the derived class.
 ### Virtual functions <a id="class.virtual">[[class.virtual]]</a>
 A non-static member function is a *virtual function* if it is first
 declared with the keyword `virtual` or if it overrides a virtual member
+function declared in a base class (see below).[^5]
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
 A class with a virtual member function is called a
+*polymorphic class*.[^6]
 If a virtual member function F is declared in a class B, and, in a class
 D derived (directly or indirectly) from B, a declaration of a member
 function G corresponds [[basic.scope.scope]] to a declaration of F,
+ignoring trailing *requires-clause*s, then G *overrides*[^7]
+F. For convenience, we say that any virtual function overrides itself. A
 virtual member function V of a class object S is a *final overrider*
 unless the most derived class [[intro.object]] of which S is a base
 class subobject (if any) has another member function that overrides V.
 In a derived class, if a virtual member function of a base class
+subobject has more than one final overrider, the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
 the following criteria:
 - both are pointers to classes, both are lvalue references to classes,
+  or both are rvalue references to classes[^8]
 - the class in the return type of `B::f` is the same class as the class
   in the return type of `D::f`, or is an unambiguous and accessible
   direct or indirect base class of the class in the return type of
   `D::f`
 - both pointers or references have the same cv-qualification and the
 [*Note 1*: A constructor or destructor can be named by an expression
 [[basic.def.odr]] even though it has no name. — *end note*]
 A member of a class can also access all the members to which the class
 has access. A local class of a member function may access the same
+members that the member function itself may access.[^9]
+Members of a class defined with the keyword `class` are private by
 default. Members of a class defined with the keywords `struct` or
 `union` are public by default.
 [*Example 1*:
 — *end example*]
 [*Note 3*:
 Because access control applies to the declarations named, if access
+control is applied to a type alias, only the accessibility of the
 typedef or alias declaration itself is considered. The accessibility of
+the underlying entity is not considered.
+[*Example 3*:
 ``` cpp
 class A {
   class B { };
 public:
   A::BB x;          // OK, typedef A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
+— *end example*]
 — *end note*]
 [*Note 4*: Access control does not prevent members from being found by
 name lookup or implicit conversions to base classes from being
 considered. — *end note*]
 appearing outside the class’s *member-specification*.
 [*Note 5*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
+[*Example 4*:
 ``` cpp
 class A {
   typedef int I;    // private member
+  I f() pre(A::x > 0);
+  friend I g(I) post(A::x <= 0);
   static I x;
   template<int> struct Q;
   template<int> friend struct R;
 protected:
     struct B { };
 };
+A::I A::f() pre(A::x > 0) { return 0; }
+A::I g(A::I p = A::x) post(A::x <= 0);
 A::I g(A::I p) { return 0; }
 A::I A::x = 0;
 template<A::I> struct A::Q { };
 template<A::I> struct R { };
 [[temp.inst]].
 Access for a default *template-argument* [[temp.param]] is checked in
 the context in which it appears rather than at any points of use of it.
+[*Example 5*:
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
 another class using the `protected` access specifier, the public and
 protected members of the base class are accessible as protected members
 of the derived class. If a class is declared to be a base class for
 another class using the `private` access specifier, the public and
 protected members of the base class are accessible as private members of
+the derived class.[^10]
 In the absence of an *access-specifier* for a base class, `public` is
 assumed when the derived class is defined with the *class-key* `struct`
 and `private` is assumed when the class is defined with the *class-key*
 `class`.
 accessible directly. Because of the rules on pointer conversions
 [[conv.ptr]] and explicit casts
 [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]], a conversion
 from a pointer to a derived class to a pointer to an inaccessible base
 class can be ill-formed if an implicit conversion is used, but
+well-formed if an explicit cast is used.
+[*Example 2*:
 ``` cpp
 class B {
 public:
   int mi;                       // non-static member
   ::B* bp2 = (::B*)this;        // OK with cast
   bp2->mi = 3;                  // OK, access through a pointer to B.
 }
 ```
+— *end example*]
 — *end note*]
 A base class `B` of `N` is *accessible* at *R*, if
 - an invented public member of `B` would be a public member of `N`, or
   `N`, and an invented public member of `B` would be a private or
   protected member of `P`, or
 - there exists a class `S` such that `B` is a base class of `S`
   accessible at *R* and `S` is a base class of `N` accessible at *R*.
+[*Example 3*:
 ``` cpp
 class B {
 public:
   int m;
 [*Note 2*: It follows that members and friends of a class `X` can
 implicitly convert an `X*` to a pointer to a private or protected
 immediate base class of `X`. — *end note*]
+An expression E that designates a member `m` has a *designating class*
+that affects the access to `m`. This designating class is either
+- the innermost class of which `m` is directly a member if E is a
+  *splice-expression* or
+- the class in whose scope name lookup performed a search that found `m`
+  otherwise.
 [*Note 3*: This class can be explicit, e.g., when a *qualified-id* is
 used, or implicit, e.g., when a class member access operator
 [[expr.ref]] is used (including cases where an implicit “`this->`” is
 added). If both a class member access operator and a *qualified-id* are
+used to name the member (as in `p->T::m`), the class designating the
+member is the class designated by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
+A member `m` is accessible at the point *R* when designated in class `N`
+if
+- `m` is designated by a *splice-expression*, or
 - `m` as a member of `N` is public, or
 - `m` as a member of `N` is private, and *R* occurs in a direct member
   or friend of class `N`, or
 - `m` as a member of `N` is protected, and *R* occurs in a direct member
   or friend of class `N`, or in a member of a class `P` derived from
   `N`, where `m` as a member of `P` is public, private, or protected, or
 - there exists a base class `B` of `N` that is accessible at *R*, and
+  `m` is accessible at *R* when designated in class `B`.
+  \[*Example 4*:
   ``` cpp
   class B;
   class A {
   private:
     int i;
 If a class member access operator, including an implicit “`this->`”, is
 used to access a non-static data member or non-static member function,
 the reference is ill-formed if the left operand (considered as a pointer
 in the “`.`” operator case) cannot be implicitly converted to a pointer
+to the designating class of the right operand.
 [*Note 4*: This requirement is in addition to the requirement that the
+member be accessible as designated. — *end note*]
 ### Friends <a id="class.friend">[[class.friend]]</a>
 A friend of a class is a function or class that is given permission to
 name the private and protected members of the class. A class specifies
 };
 ```
 — *end example*]
+A friend declaration that does not declare a function shall be a
+*friend-type-declaration*.
 [*Note 1*: A friend declaration can be the *declaration* in a
 *template-declaration* [[temp.pre]], [[temp.friend]]. — *end note*]
+If a *friend-type-specifier* in a friend declaration designates a
+(possibly cv-qualified) class type, that class is declared as a friend;
+otherwise, the *friend-type-specifier* is ignored.
 [*Example 4*:
 ``` cpp
 class C;
 typedef C Ct;
+class E;
 class X1 {
   friend C;                     // OK, class C is a friend
 };
   friend Ct;                    // OK, class C is a friend
   friend D;                     // error: D not found
   friend class D;               // OK, elaborated-type-specifier declares new class
 };
+template <typename ... Ts> class R {
+  friend Ts...;
+};
+template <class... Ts, class... Us>
+class R<R<Ts...>, R<Us...>> {
+  friend Ts::Nested..., Us...;
 };
 R<C> rc;                        // class C is a friend of R<C>
+R<C, E> rce; // classes C and E are friends of R<C, E>
+R<int> Ri;                      // OK, ``friend int;'' is ignored
+struct E { struct Nested; };
+R<R<E>, R<C, int>> rr;          // E::Nested and C are friends of R<R<E>, R<C, int>>
 ```
 — *end example*]
 [*Note 2*:
 A friend declaration refers to an entity, not (all overloads of) a name.
 A member function of a class `X` can be a friend of a class `Y`.
 ### Protected member access <a id="class.protected">[[class.protected]]</a>
 An additional access check beyond those described earlier in
 [[class.access]] is applied when a non-static data member or non-static
+member function is a protected member of its designating class
+[[class.access.base]].[^11]
 As described earlier, access to a protected member is granted because
 the reference occurs in a friend or direct member of some class `C`. If
 the access is to form a pointer to member [[expr.unary.op]], the
 *nested-name-specifier* shall denote `C` or a class derived from `C`.
 void fr(B* pb, D1* p1, D2* p2) {
   pb->i = 1;                    // error
   p1->i = 2;                    // error
   p2->i = 3;                    // OK (access through a D2)
+  p2->B::i = 4;                 // OK (access through a D2, even though designating class is B)
   int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK (type of &D2::i is int B::*)
+  B::j = 5;                     // error: not a friend of designating class B
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
   pb->i = 1;                    // error
 complex g = { 1, 2 };           // initialized by calling complex(double, double) with arguments 1 and 2
 ```
 — *end example*]
+[*Note 1*:  Overloading of the assignment operator [[over.assign]] has
+no effect on initialization. — *end note*]
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
 [*Note 2*: Braces can be elided in the *initializer-list* for any
 aggregate, even if the aggregate has members of a class type with
 user-defined type conversions; see  [[dcl.init.aggr]]. — *end note*]
 [*Note 3*: If `T` is a class type with no default constructor, any
+initializing declaration of an object of type `T` (or array thereof) is
+ill-formed if no *initializer* is explicitly specified (see
+[[class.init]] and  [[dcl.init]]). — *end note*]
 [*Note 4*:  The order in which objects with static or thread storage
 duration are initialized is described in  [[basic.start.dynamic]] and
 [[stmt.dcl]]. — *end note*]
 *mem-initializer-id* naming the member or base class and composed of a
 single identifier refers to the class member. A *mem-initializer-id* for
 the hidden base class can be specified using a qualified
 name. — *end note*]
+Unless the *mem-initializer-id* names the constructor’s class, a direct
 non-static data member of the constructor’s class, or a direct or
 virtual base of that class, the *mem-initializer* is ill-formed.
 A *mem-initializer-list* can initialize a base class using any
 *class-or-decltype* that denotes that base class type.
 [*Note 4*: After the call to a constructor for class `X` for an object
 with automatic or dynamic storage duration has completed, if the
 constructor was not invoked as part of value-initialization and a member
 of `X` is neither initialized nor given a value during execution of the
 *compound-statement* of the body of the constructor, the member has an
+indeterminate or erroneous value [[basic.indet]]. — *end note*]
 [*Example 6*:
 ``` cpp
 struct A {
 struct C {
   C() { }               // initializes members as follows:
   A a;                  // OK, calls A::A()
   const B b;            // error: B has no default constructor
+  int i;                // OK, i has indeterminate or erroneous value
   int j = 5;            // OK, j has the value 5
 };
 ```
 — *end example*]
 `X::i`; this takes place each time an object of class `X` is created.
 — *end example*]
 Member functions (including virtual member functions, [[class.virtual]])
+can be called for an object under construction or destruction.
+Similarly, an object under construction or destruction can be the
+operand of the `typeid` operator [[expr.typeid]] or of a `dynamic_cast`
+[[expr.dynamic.cast]]. However, if these operations are performed during
+evaluation of
+- a *ctor-initializer* (or in a function called directly or indirectly
+  from a *ctor-initializer*) before all the *mem-initializer*s for base
+  classes have completed,
+- a precondition assertion of a constructor, or
+- a postcondition assertion of a destructor [[dcl.contract.func]],
+the program has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
 When a constructor for type `B` is invoked to initialize an object of a
 different type `D` (that is, when the constructor was inherited
 [[namespace.udecl]]), initialization proceeds as if a defaulted default
 constructor were used to initialize the `D` object and each base class
 subobject from which the constructor was inherited, except that the `B`
+subobject is initialized by the inherited constructor if the base class
+subobject were to be initialized as part of the `D` object
+[[class.base.init]]. The invocation of the inherited constructor,
+including the evaluation of any arguments, is omitted if the `B`
+subobject is not to be initialized as part of the `D` object. The
+complete initialization is considered to be a single function call; in
+particular, unless omitted, the initialization of the inherited
+constructor’s parameters is sequenced before the initialization of any
+part of the `D` object.
 [*Example 1*:
 ``` cpp
 struct B1 {
 constructors, while writing a message to the standard log whenever an
 object of class `Log` is destroyed.
 — *end example*]
+[*Example 2*:
+``` cpp
+struct V { V() = default; V(int); };
+struct Q { Q(); };
+struct A : virtual V, Q {
+  using V::V;
+  A() = delete;
+};
+int bar() { return 42; }
+struct B : A {
+  B() : A(bar()) {} // OK
+};
+struct C : B {};
+void foo() { C c; } // bar is not invoked, because the V subobject is not initialized as part of B
+```
+— *end example*]
 If the constructor was inherited from multiple base class subobjects of
 type `B`, the program is ill-formed.
+[*Example 3*:
 ``` cpp
 struct A { A(int); };
 struct B : A { using A::A; };
 A* pa = &bobj;                          // undefined behavior: upcast to a base class type
 B bobj;                                 // definition of bobj
 extern X xobj;
+int* p3 = &xobj.i;                      // OK, all constructors of X are trivial
 X xobj;
 ```
 For another example,
 };
 ```
 — *end example*]
+During the construction of an object, if the value of any of its
+subobjects or any element of its object representation is accessed
+through a glvalue that is not obtained, directly or indirectly, from the
+constructor’s `this` pointer, the value thus obtained is unspecified.
 [*Example 2*:
 ``` cpp
 struct C;
 Member functions, including virtual functions [[class.virtual]], can be
 called during construction or destruction [[class.base.init]]. When a
 virtual function is called directly or indirectly from a constructor or
 from a destructor, including during the construction or destruction of
+the class’s non-static data members, or during the evaluation of a
+postcondition assertion of a constructor or a precondition assertion of
+a destructor [[dcl.contract.func]], and the object to which the call
 applies is the object (call it `x`) under construction or destruction,
 the function called is the final overrider in the constructor’s or
 destructor’s class and not one overriding it in a more-derived class. If
 the virtual function call uses an explicit class member access
 [[expr.ref]] and the object expression refers to the complete object of
 — *end example*]
 ### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
 When certain criteria are met, an implementation is allowed to omit the
+creation of a class object from a source object of the same type
+(ignoring cv-qualification), even if the selected constructor and/or the
+destructor for the object have side effects. In such cases, the
+implementation treats the source and target of the omitted
+initialization as simply two different ways of referring to the same
+object. If the first parameter of the selected constructor is an rvalue
+reference to the object’s type, the destruction of that object occurs
+when the target would have been destroyed; otherwise, the destruction
+occurs at the later of the times when the two objects would have been
+destroyed without the optimization.
+[*Note 1*: Because only one object is destroyed instead of two, and the
+creation of one object is omitted, there is still one object destroyed
+for each one constructed. — *end note*]
+This elision of object creation, called *copy elision*, is permitted in
+the following circumstances (which may be combined to eliminate multiple
+copies):
+- in a `return` statement [[stmt.return]] in a function with a class
+  return type, when the *expression* is the name of a non-volatile
+ object o with automatic storage duration (other than a function
+ parameter or a variable introduced by the *exception-declaration* of a
+  *handler* [[except.handle]]), the copy-initialization of the result
+  object can be omitted by constructing o directly into the function
+  call’s result object;
 - in a *throw-expression* [[expr.throw]], when the operand is the name
+  of a non-volatile object o with automatic storage duration (other than
+ a function parameter or a variable introduced by the
+ *exception-declaration* of a *handler*) that belongs to a scope that
+ does not contain the innermost enclosing *compound-statement*
+ associated with a *try-block* (if there is one), the
+  copy-initialization of the exception object can be omitted by
+  constructing o directly into the exception object;
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
+  and destructor for the parameter copy object;
+- when the *exception-declaration* of a *handler* [[except.handle]]
+  declares an object o, the copy-initialization of o can be omitted by
+ treating the *exception-declaration* as an alias for the exception
+ object if the meaning of the program will be unchanged except for the
+ execution of constructors and destructors for the object declared by
+ the *exception-declaration*. \[*Note 2*: There cannot be a move from
+  the exception object because it is always an lvalue. — *end note*]
 Copy elision is not permitted where an expression is evaluated in a
 context requiring a constant expression [[expr.const]] and in constant
 initialization [[basic.start.static]].
+[*Note 3*: It is possible that copy elision is performed if the same
 expression is evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
 ## Comparisons <a id="class.compare">[[class.compare]]</a>
 ### Defaulted comparison operator functions <a id="class.compare.default">[[class.compare.default]]</a>
+A defaulted comparison operator function [[over.binary]] shall be a
+non-template function that
+- is a non-static member or friend of some class `C`,
+- is defined as defaulted in `C` or in a context where `C` is complete,
+  and
 - either has two parameters of type `const C&` or two parameters of type
   `C`, where the implicit object parameter (if any) is considered to be
   the first parameter.
+Such a comparison operator function is termed a defaulted comparison
+operator function for class `C`. Name lookups and access checks in the
+implicit definition [[dcl.fct.def.default]] of a comparison operator
+function are performed from a context equivalent to its *function-body*.
+A definition of a comparison operator as defaulted that appears in a
+class shall be the first declaration of that function.
+[*Example 1*:
+``` cpp
+struct S;
+bool operator==(S, S) = default;                    // error: S is not complete
+struct S {
+  friend bool operator==(S, const S&) = default;    // error: parameters of different types
+};
+enum E { };
+bool operator==(E, E) = default;                    // error: not a member or friend of a class
+```
+— *end example*]
 A defaulted `<=>` or `==` operator function for class `C` is defined as
 deleted if any non-static data member of `C` is of reference type or `C`
 has variant members [[class.union.anon]].
 operator function has an implicit exception specification
 [[except.spec]] that can differ from the implicit exception
 specification of the three-way comparison operator
 function. — *end note*]
+[*Example 2*:
 ``` cpp
 template<typename T> struct X {
   friend constexpr std::partial_ordering operator<=>(X, X) requires (sizeof(T) != 1) = default;
   // implicitly declares: friend constexpr bool operator==(X, X) requires (sizeof(T) != 1) = default;
 A defaulted `==` operator function for a class `C` is defined as deleted
 unless, for each `xᵢ` in the expanded list of subobjects for an object
 `x` of type `C`, `xᵢ`` == ``xᵢ` is usable [[class.compare.default]].
+The return value of a defaulted `==` operator function with parameters
+`x` and `y` is determined by comparing corresponding elements `xᵢ` and
+`yᵢ` in the expanded lists of subobjects for `x` and `y` (in increasing
+index order) until the first index i where `xᵢ`` == ``yᵢ` yields a
+result value which, when contextually converted to `bool`, yields
+`false`. The return value is `false` if such an index exists and `true`
+otherwise.
 [*Example 1*:
 ``` cpp
 struct D {
 The *synthesized three-way comparison* of type `R` [[cmp.categories]] of
 glvalues `a` and `b` of the same type is defined as follows:
 - If `a <=> b` is usable [[class.compare.default]] and can be explicitly
   converted to `R` using `static_cast`, `static_cast<R>(a <=> b)`.
+- Otherwise, if `a <=> b` is usable or overload resolution for `a <=> b`
+ is performed and finds at least one viable candidate, the synthesized
+ three-way comparison is not defined.
 - Otherwise, if `R` is not a comparison category type, or either the
   expression `a == b` or the expression `a < b` is not usable, the
   synthesized three-way comparison is not defined.
 - Otherwise, if `R` is `strong_ordering`, then
   ``` cpp
   common comparison type (see below) of `R₀`, `R₁`, …, `R_n-1`.
 - Otherwise, `R` shall not contain a placeholder type. If the
   synthesized three-way comparison of type `R` between any objects `xᵢ`
   and `xᵢ` is not defined, the operator function is defined as deleted.
+The return value of type `R` of the defaulted three-way comparison
 operator function with parameters `x` and `y` of the same type is
 determined by comparing corresponding elements `xᵢ` and `yᵢ` in the
 expanded lists of subobjects for `x` and `y` (in increasing index order)
 until the first index i where the synthesized three-way comparison of
 type `R` between `xᵢ` and `yᵢ` yields a result value `vᵢ` where
+`vᵢ` `!=` 0, contextually converted to `bool`, yields `true`. The return
+value is a copy of `vᵢ` if such an index exists and
+`static_cast<R>(std::strong_ordering::equal)` otherwise.
 The *common comparison type* `U` of a possibly-empty list of n
 comparison category types `T₀`, `T₁`, …, `T_n-1` is defined as follows:
 - If at least one `Tᵢ` is `std::partial_ordering`, `U` is
 `bool`.
 The operator function with parameters `x` and `y` is defined as deleted
 if
+- a first overload resolution [[over.match]], as applied to `x @ y`,
+ - does not result in a usable candidate, or
+ - the selected candidate is not a rewritten candidate, or
+- a second overload resolution for the expression resulting from the
+  interpretation of `x @ y` using the selected rewritten candidate
+  [[over.match.oper]] does not result in a usable candidate (for
+  example, that expression might be `(x <=> y) @ 0`), or
+- `x @ y` cannot be implicitly converted to `bool`.
+In any of the two overload resolutions above, the defaulted operator
+function is not considered as a candidate for the `@` operator.
+Otherwise, the operator function yields `x @ y`.
 [*Example 1*:
 ``` cpp
 struct HasNoLessThan { };
 <!-- Link reference definitions -->
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lval]: expr.md#basic.lval
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
+[basic.types.general]: basic.md#basic.types.general
 [class]: #class
 [class.abstract]: #class.abstract
 [class.access]: #class.access
 [class.access.base]: #class.access.base
 [class.access.general]: #class.access.general
 [cmp.weakord]: support.md#cmp.weakord
 [conv]: expr.md#conv
 [conv.mem]: expr.md#conv.mem
 [conv.ptr]: expr.md#conv.ptr
 [conv.rval]: expr.md#conv.rval
+[cpp.cond]: cpp.md#cpp.cond
+[dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.attr.nouniqueaddr]: dcl.md#dcl.attr.nouniqueaddr
+[dcl.contract.func]: dcl.md#dcl.contract.func
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.init.general]: dcl.md#dcl.init.general
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.meaning]: dcl.md#dcl.meaning
+[dcl.meaning.general]: dcl.md#dcl.meaning.general
 [dcl.name]: dcl.md#dcl.name
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [depr.impldec]: future.md#depr.impldec
 [depr.static.constexpr]: future.md#depr.static.constexpr
 [diff.class]: compatibility.md#diff.class
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
+[expr.assign]: expr.md#expr.assign
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.delete]: expr.md#expr.delete
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.typeid]: expr.md#expr.typeid
 [expr.unary.op]: expr.md#expr.unary.op
 [intro.execution]: basic.md#intro.execution
 [intro.object]: basic.md#intro.object
+[meta.reflection.define.aggregate]: meta.md#meta.reflection.define.aggregate
+[module.reach]: module.md#module.reach
 [namespace.udecl]: dcl.md#namespace.udecl
 [over]: over.md#over
+[over.assign]: over.md#over.assign
 [over.best.ics]: over.md#over.best.ics
 [over.binary]: over.md#over.binary
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
 [over.match.call]: over.md#over.match.call
 [over.match.copy]: over.md#over.match.copy
 [over.match.funcs]: over.md#over.match.funcs
+[over.match.general]: over.md#over.match.general
+[over.match.oper]: over.md#over.match.oper
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [special]: #special
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.return]: stmt.md#stmt.return
 [string.classes]: strings.md#string.classes
 [temp.arg]: temp.md#temp.arg
 [temp.constr]: temp.md#temp.constr
 [temp.constr.order]: temp.md#temp.constr.order
 [temp.deduct.guide]: temp.md#temp.deduct.guide
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.friend]: temp.md#temp.friend
 [temp.inst]: temp.md#temp.inst
 [temp.mem]: temp.md#temp.mem
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
+[temp.spec.general]: temp.md#temp.spec.general
 [temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.layout.compatible.type]: basic.md#term.layout.compatible.type
 [term.object.representation]: basic.md#term.object.representation
 [^1]: This ensures that two subobjects that have the same class type and
     that belong to the same most derived object are not allocated at the
     same address [[expr.eq]].
+[^2]: This implies that the reference parameter of the
     implicitly-declared copy constructor cannot bind to a `volatile`
     lvalue; see  [[diff.class]].
+[^3]: Because a template assignment operator or an assignment operator
     taking an rvalue reference parameter is never a copy assignment
     operator, the presence of such an assignment operator does not
     suppress the implicit declaration of a copy assignment operator.
     Such assignment operators participate in overload resolution with
     other assignment operators, including copy assignment operators,
     and, if selected, will be used to assign an object.
+[^4]: This implies that the reference parameter of the
     implicitly-declared copy assignment operator cannot bind to a
     `volatile` lvalue; see  [[diff.class]].
+[^5]: The use of the `virtual` specifier in the declaration of an
     overriding function is valid but redundant (has empty semantics).
+[^6]: If all virtual functions are immediate functions, the class is
     still polymorphic even if its internal representation does not
     otherwise require any additions for that polymorphic behavior.
+[^7]: A function with the same name but a different parameter list
     [[over]] as a virtual function is not necessarily virtual and does
     not override. Access control [[class.access]] is not considered in
     determining overriding.
+[^8]: Multi-level pointers to classes or references to multi-level
     pointers to classes are not allowed.
+[^9]: Access permissions are thus transitive and cumulative to nested
     and local classes.
+[^10]: As specified previously in [[class.access]], private members of a
     base class remain inaccessible even to derived classes unless friend
     declarations within the base class definition are used to grant
     access explicitly.
+[^11]: This additional check does not apply to other members, e.g.,
     static data members or enumerator member constants.

Diff to HTML by rtfpessoa