[class.mem] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpx2an48b_/{from.md → to.md} +273 -236

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

@@ -10,13 +10,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
@@ -29,20 +31,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
@@ -52,57 +53,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
@@ -122,23 +163,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*.
@@ -268,11 +313,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`.
@@ -287,12 +332,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*:
@@ -355,10 +401,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]].
@@ -391,11 +474,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 {
@@ -406,11 +491,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>
@@ -420,65 +505,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>
@@ -527,11 +561,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
@@ -541,15 +575,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>
@@ -609,12 +644,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*]
@@ -640,79 +673,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>
@@ -840,11 +875,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&)
@@ -872,29 +907,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
@@ -906,13 +940,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.
@@ -921,11 +954,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
@@ -952,23 +985,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 {
@@ -1000,15 +1030,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
@@ -1018,14 +1049,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
@@ -1072,39 +1100,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
@@ -1120,11 +1146,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
@@ -1199,12 +1225,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.
@@ -1237,33 +1263,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.
@@ -1276,17 +1308,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*]
@@ -1332,11 +1365,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.
@@ -1379,11 +1412,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);
@@ -1397,17 +1432,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*:
@@ -1441,11 +1478,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*:
@@ -1468,11 +1505,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 {
@@ -1524,17 +1561,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
@@ -1553,39 +1583,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 {
@@ -1637,11 +1666,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*:
@@ -1666,11 +1695,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
@@ -1965,11 +1994,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);
@@ -1999,17 +2030,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);
@@ -2025,16 +2060,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

 ``` 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

Diff to HTML by rtfpessoa