[class] - C++20 → C++23

Files changed (1) hide show

tmp/tmpba7gq7h0/{from.md → to.md} +977 -1375

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

@@ -43,37 +43,53 @@ class-key:
     union
 ```
 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.class.spec]]. 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*]
-A *class-name* is inserted into the scope in which it is declared
-immediately after the *class-name* is seen. The *class-name* is also
-inserted into the scope of the class 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.
 If a *class-head-name* contains a *nested-name-specifier*, the
-*class-specifier* shall refer to a class that was previously declared
-directly in the class or namespace to which the *nested-name-specifier*
-refers, or in an element of the inline namespace set [[namespace.def]]
-of that namespace (i.e., not merely inherited or introduced by a
-*using-declaration*), and the *class-specifier* shall appear in a
-namespace enclosing the previous declaration. In such cases, the
-*nested-name-specifier* of the *class-head-name* of the definition shall
-not begin with a *decltype-specifier*.
 [*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*]
@@ -82,45 +98,45 @@ 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 1*:
 ``` 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*]
 ## Properties of classes <a id="class.prop">[[class.prop]]</a>
 A *trivially copyable class* is a class:
 - that has at least one eligible copy constructor, move constructor,
-  copy assignment operator, or move assignment operator ([[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
@@ -143,13 +159,13 @@ A class `S` is a *standard-layout class* if it:
 - 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 may be at a zero offset in `X`. — *end note*]
-  - If `X` is a non-union class type with no (possibly inherited
- [[class.derived]]) 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
     member of `X` (where said member may be an anonymous union), the set
     M(X) consists of X₀ and the elements of M(X₀).
   - If `X` is a union type, the set M(X) is the union of all M(Uᵢ) and
@@ -214,13 +230,15 @@ struct POD {        // both trivial and standard-layout
 — *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 or has
-at least one trivial eligible constructor and a trivial, non-deleted
-destructor.
 ## Class names <a id="class.name">[[class.name]]</a>
 A class definition introduces a new type.
@@ -246,53 +264,49 @@ are type mismatches, and that
 ``` cpp
 int f(X);
 int f(Y);
 ```
-declare an overloaded [[over]] function `f()` and not simply a single
-function `f()` twice. For the same reason,
 ``` cpp
 struct S { int a; };
 struct S { int a; };            // error: double definition
 ```
 is ill-formed because it defines `S` twice.
 — *end example*]
-A class declaration introduces the class name into the scope where it is
-declared and hides any class, variable, function, or other declaration
-of that name in an enclosing scope [[basic.scope]]. If a class name is
-declared in a scope where a variable, function, or enumerator of the
-same name is also declared, then when both declarations are in scope,
-the class can be referred to only using an *elaborated-type-specifier*
-[[basic.lookup.elab]].
 [*Example 2*:
 ``` cpp
 struct stat {
   // ...
 };
 stat gstat;                     // use plain stat to define variable
-int stat(struct stat*);         // redeclare stat as function
 void f() {
   struct stat* ps;              // struct prefix needed to name struct stat
-  stat(ps);                     // call stat()
 }
 ```
 — *end example*]
-A *declaration* consisting solely of *class-key* *identifier*`;` is
-either a redeclaration of the name in the current scope or a forward
-declaration of the identifier as a class name. It introduces the class
-name into the current scope.
 [*Example 3*:
 ``` cpp
 struct s { int a; };
@@ -305,12 +319,10 @@ void g() {
 }
 ```
 — *end example*]
-[*Note 1*:
 Such declarations allow definition of classes that refer to each other.
 [*Example 4*:
 ``` cpp
@@ -334,12 +346,12 @@ functions in  [[over.oper]].
 — *end note*]
 [*Note 2*: An *elaborated-type-specifier* [[dcl.type.elab]] can also be
 used as a *type-specifier* as part of a declaration. It differs from a
-class declaration in that if a class of the elaborated name is in scope
-the elaborated name will refer to it. — *end note*]
 [*Example 5*:
 ``` cpp
 struct s { int a; };
@@ -372,10 +384,12 @@ artistry with names can be confusing and is best avoided.
 A *simple-template-id* is only a *class-name* if its *template-name*
 names a class template.
 ## Class members <a id="class.mem">[[class.mem]]</a>
 ``` bnf
 member-specification:
     member-declaration member-specificationₒₚₜ
     access-specifier ':' member-specificationₒₚₜ
 ```
@@ -425,27 +439,29 @@ virt-specifier:
 pure-specifier:
     '=' '0'
 ```
 The *member-specification* in a class definition declares the full set
-of members of the class; no member can be added elsewhere. A *direct
-member* of a class `X` is a member of `X` that was first declared within
-the *member-specification* of `X`, including anonymous union objects
-[[class.union.anon]] and direct members thereof. Members of a class are
-data members, member functions [[class.mfct]], nested types,
-enumerators, and member templates [[temp.mem]] and specializations
-thereof.
 [*Note 1*: A specialization of a static data member template is a
 static data member. A specialization of a member function template is a
 member function. A specialization of a member class template is a nested
 class. — *end note*]
 A *member-declaration* does not declare new members of the class if it
 is
 - a friend declaration [[class.friend]],
 - a *static_assert-declaration*,
 - a *using-declaration* [[namespace.udecl]], or
 - an *empty-declaration*.
 For any other *member-declaration*, each declared entity that is not an
@@ -453,23 +469,23 @@ 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*,
@@ -479,31 +495,36 @@ except that
   defined, and
 - an enumeration can be introduced with an *opaque-enum-declaration* and
   later redeclared with an *enum-specifier*.
 [*Note 3*: A single name can denote several member functions provided
-their types are sufficiently different [[over.load]]. — *end note*]
-A *complete-class context* of a class is a
 - function body [[dcl.fct.def.general]],
 - default argument [[dcl.fct.default]],
 - *noexcept-specifier* [[except.spec]], or
 - default member initializer
-within the *member-specification* of the class.
 [*Note 4*: A complete-class context of a nested class is also a
 complete-class context of any enclosing class, if the nested class is
 defined within the *member-specification* of the enclosing
 class. — *end note*]
-A class is considered a completely-defined object type [[basic.types]]
-(or complete type) at the closing `}` of the *class-specifier*. The
-class is regarded as complete within its complete-class contexts;
-otherwise it is regarded as incomplete within its own class
-*member-specification*.
 In a *member-declarator*, an `=` immediately following the *declarator*
 is interpreted as introducing a *pure-specifier* if the *declarator-id*
 has function type, otherwise it is interpreted as introducing a
 *brace-or-equal-initializer*.
@@ -511,12 +532,12 @@ has function type, otherwise it is interpreted as introducing a
 [*Example 1*:
 ``` cpp
 struct S {
   using T = void();
-  T * p = 0;        // OK: brace-or-equal-initializer
-  virtual T f = 0;  // OK: pure-specifier
 };
 ```
 — *end example*]
@@ -546,11 +567,15 @@ data member. (For static data members, see  [[class.static.data]]; for
 non-static data members, see  [[class.base.init]] and
 [[dcl.init.aggr]]). A *brace-or-equal-initializer* for a non-static data
 member specifies a *default member initializer* for the member, and
 shall not directly or indirectly cause the implicit definition of a
 defaulted default constructor for the enclosing class or the exception
-specification of that constructor.
 A member shall not be declared with the `extern`
 *storage-class-specifier*. Within a class definition, a member shall not
 be declared with the `thread_local` *storage-class-specifier* unless
 also declared `static`.
@@ -571,12 +596,12 @@ it shall not appear if the optional *member-declarator-list* is omitted.
 A *virt-specifier-seq* shall contain at most one of each
 *virt-specifier*. A *virt-specifier-seq* shall appear only in the first
 declaration of a virtual member function [[class.virtual]].
 The type of a non-static data member shall not be an incomplete type
-[[basic.types]], an abstract class type [[class.abstract]], or a
-(possibly multi-dimensional) array thereof.
 [*Note 5*: In particular, a class `C` cannot contain a non-static
 member of class `C`, but it can contain a pointer or reference to an
 object of class `C`. — *end note*]
@@ -615,45 +640,47 @@ object to which `sp` points; `s.left` refers to the `left` subtree
 pointer of the object `s`; and `s.right->tword[0]` refers to the initial
 character of the `tword` member of the `right` subtree of `s`.
 — *end example*]
-[*Note 8*:  Non-static data members of a (non-union) class with the
-same access control [[class.access]] and non-zero size [[intro.object]]
-are allocated so that later members have higher addresses within a class
-object. The order of allocation of non-static data members with
-different access control is unspecified. Implementation alignment
-requirements might cause two adjacent members not to be allocated
-immediately after each other; so might requirements for space for
-managing virtual functions [[class.virtual]] and virtual base classes
 [[class.mi]]. — *end note*]
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
 - every static data member of class `T`;
-- every member function of class `T` \[*Note 9*: This restriction does
   not apply to constructors, which do not have names
-  [[class.ctor]] — *end note*] ;
 - every member of class `T` that is itself a type;
 - every member template of class `T`;
 - every enumerator of every member of class `T` that is an unscoped
- enumerated type; and
 - every member of every anonymous union that is a member of class `T`.
 In addition, if class `T` has a user-declared constructor
 [[class.ctor]], every non-static data member of class `T` shall have a
 name different from `T`.
 The *common initial sequence* of two standard-layout struct
 [[class.prop]] types is the longest sequence of non-static data members
 and bit-fields in declaration order, starting with the first such entity
-in each of the structs, such that corresponding entities have
-layout-compatible types, either both entities are declared with the
-`no_unique_address` attribute [[dcl.attr.nouniqueaddr]] or neither is,
-and either both entities are bit-fields with the same width or neither
-is a bit-field.
 [*Example 4*:
 ``` cpp
 struct A { int a; char b; };
@@ -674,11 +701,12 @@ Two standard-layout struct [[class.prop]] types are *layout-compatible
 classes* if their common initial sequence comprises all members and
 bit-fields of both classes [[basic.types]].
 Two standard-layout unions are layout-compatible if they have the same
 number of non-static data members and corresponding non-static data
-members (in any order) have layout-compatible types [[basic.types]].
 In a standard-layout union with an active member [[class.union]] of
 struct type `T1`, it is permitted to read a non-static data member `m`
 of another union member of struct type `T2` provided `m` is part of the
 common initial sequence of `T1` and `T2`; the behavior is as if the
@@ -704,55 +732,27 @@ type has undefined behavior [[dcl.type.cv]]. — *end note*]
 If a standard-layout class object has any non-static data members, its
 address is the same as the address of its first non-static data member
 if that member is not a bit-field. Its address is also the same as the
 address of each of its base class subobjects.
-[*Note 11*: There might therefore be unnamed padding within a
 standard-layout struct object inserted by an implementation, but not at
 its beginning, as necessary to achieve appropriate
 alignment. — *end note*]
 [*Note 12*: The object and its first subobject are
-pointer-interconvertible ([[basic.compound]],
-[[expr.static.cast]]). — *end note*]
 ### Member functions <a id="class.mfct">[[class.mfct]]</a>
-A member function may be defined [[dcl.fct.def]] in its class
-definition, in which case it is an inline [[dcl.inline]] member function
-if it is attached to the global module, or it may be defined outside of
-its class definition if it has already been declared but not defined in
-its class definition.
 [*Note 1*: A member function is also inline if it is declared `inline`,
 `constexpr`, or `consteval`. — *end note*]
-A member function definition that appears outside of the class
-definition shall appear in a namespace scope enclosing the class
-definition. Except for member function definitions that appear outside
-of a class definition, and except for explicit specializations of member
-functions of class templates and member function templates [[temp.spec]]
-appearing outside of the class definition, a member function shall not
-be redeclared.
-[*Note 2*: There can be at most one definition of a non-inline member
-function in a program. There may be more than one inline member function
-definition in a program. See  [[basic.def.odr]] and
-[[dcl.inline]]. — *end note*]
-[*Note 3*: Member functions of a class have the linkage of the name of
-the class. See  [[basic.link]]. — *end note*]
-If the definition of a member function is lexically outside its class
-definition, the member function name shall be qualified by its class
-name using the `::` operator.
-[*Note 4*: A name used in a member function definition (that is, in the
-*parameter-declaration-clause* including the default arguments
-[[dcl.fct.default]] or in the member function body) is looked up as
-described in  [[basic.lookup]]. — *end note*]
 [*Example 1*:
 ``` cpp
 struct X {
   typedef int T;
@@ -760,30 +760,23 @@ struct X {
   void f(T);
 };
 void X::f(T t = count) { }
 ```
-The member function `f` of class `X` is defined in global scope; the
-notation `X::f` specifies that the function `f` is a member of class `X`
-and in the scope of class `X`. In the function definition, the parameter
-type `T` refers to the typedef member `T` declared in class `X` and the
-default argument `count` refers to the static data member `count`
-declared in class `X`.
 — *end example*]
-[*Note 5*: A `static` local variable or local type in a member function
-always refers to the same entity, whether or not the member function is
-inline. — *end note*]
-Previously declared member functions may be mentioned in friend
-declarations.
 Member functions of a local class shall be defined inline in their class
 definition, if they are defined at all.
-[*Note 6*:
 A member function can be declared (but not defined) using a typedef for
 a function type. The resulting member function has exactly the same type
 as it would have if the function declarator were provided explicitly,
 see  [[dcl.fct]]. For example,
@@ -803,34 +796,29 @@ 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>
 A non-static member function may be called for an object of its class
 type, or for an object of a class derived [[class.derived]] from its
-class type, using the class member access syntax ([[expr.ref]],
-[[over.match.call]]). A non-static member function may also be called
-directly using the function call syntax ([[expr.call]],
-[[over.match.call]]) from within its class or a class derived from its
-class, or a member thereof, as described below.
-If a non-static member function of a class `X` is called for an object
-that is not of type `X`, or of a type derived from `X`, the behavior is
-undefined.
-When an *id-expression* [[expr.prim.id]] that is not part of a class
-member access syntax [[expr.ref]] and not used to form a pointer to
-member [[expr.unary.op]] is used in a member of class `X` in a context
-where `this` can be used [[expr.prim.this]], if name lookup
-[[basic.lookup]] resolves the name in the *id-expression* to a
-non-static non-type member of some class `C`, and if either the
-*id-expression* is potentially evaluated or `C` is `X` or a base class
-of `X`, the *id-expression* is transformed into a class member access
-expression [[expr.ref]] using `(*this)` [[class.this]] as the
-*postfix-expression* to the left of the `.` operator.
 [*Note 1*: If `C` is not `X` or a base class of `X`, the class member
 access expression is ill-formed. — *end note*]
 This transformation does not apply in the template definition context
@@ -869,113 +857,29 @@ which the function is called. Thus, in the call `n1.set("abc",&n2,0)`,
 refers to `n2.tword`. The functions `strlen`, `perror`, and `strcpy` are
 not members of the class `tnode` and should be declared elsewhere.[^2]
 — *end example*]
-A non-static member function may be declared `const`, `volatile`, or
-`const` `volatile`. These *cv-qualifier*s affect the type of the `this`
-pointer [[class.this]]. They also affect the function type [[dcl.fct]]
-of the member function; a member function declared `const` is a *const
-member function*, a member function declared `volatile` is a *volatile
-member function* and a member function declared `const` `volatile` is a
-*const volatile member function*.
-[*Example 2*:
-``` cpp
-struct X {
-  void g() const;
-  void h() const volatile;
-};
-```
-`X::g` is a const member function and `X::h` is a const volatile member
-function.
-— *end example*]
-A non-static member function may be declared with a *ref-qualifier*
-[[dcl.fct]]; see  [[over.match.funcs]].
-A non-static member function may be declared virtual [[class.virtual]]
-or pure virtual [[class.abstract]].
-#### The `this` pointer <a id="class.this">[[class.this]]</a>
-In the body of a non-static [[class.mfct]] member function, the keyword
-`this` is a prvalue whose value is a pointer to the object for which the
-function is called. The type of `this` in a member function whose type
-has a *cv-qualifier-seq* cv and whose class is `X` is “pointer to cv
-`X`”.
-[*Note 1*: Thus in a const member function, the object for which the
-function is called is accessed through a const access
-path. — *end note*]
-[*Example 1*:
-``` cpp
-struct s {
-  int a;
-  int f() const;
-  int g() { return a++; }
-  int h() const { return a++; } // error
-};
-int s::f() const { return a; }
-```
-The `a++` in the body of `s::h` is ill-formed because it tries to modify
-(a part of) the object for which `s::h()` is called. This is not allowed
-in a const member function because `this` is a pointer to `const`; that
-is, `*this` has `const` type.
-— *end example*]
-[*Note 2*: Similarly, `volatile` semantics [[dcl.type.cv]] apply in
-volatile member functions when accessing the object and its non-static
-data members. — *end note*]
-A member function whose type has a *cv-qualifier-seq* *cv1* can be
-called on an object expression [[expr.ref]] of type *cv2* `T` only if
-*cv1* is the same as or more cv-qualified than *cv2*
-[[basic.type.qualifier]].
-[*Example 2*:
-``` cpp
-void k(s& x, const s& y) {
-  x.f();
-  x.g();
-  y.f();
-  y.g();                        // error
-}
-```
-The call `y.g()` is ill-formed because `y` is `const` and `s::g()` is a
-non-const member function, that is, `s::g()` is less-qualified than the
-object expression `y`.
-— *end example*]
-[*Note 3*: Constructors and destructors cannot be declared `const`,
-`volatile`, or `const` `volatile`. However, these functions can be
-invoked to create and destroy objects with cv-qualified types; see
-[[class.ctor]] and  [[class.dtor]]. — *end note*]
 ### Special member functions <a id="special">[[special]]</a>
 Default constructors [[class.default.ctor]], copy constructors, move
 constructors [[class.copy.ctor]], copy assignment operators, move
 assignment operators [[class.copy.assign]], and prospective destructors
 [[class.dtor]] are *special member functions*.
 [*Note 1*: The implementation will implicitly declare these member
 functions for some class types when the program does not explicitly
-declare them. The implementation will implicitly define them if they are
-odr-used [[basic.def.odr]] or needed for constant evaluation
-[[expr.const]]. — *end note*]
 An implicitly-declared special member function is declared at the
 closing `}` of the *class-specifier*. Programs shall not define
 implicitly-declared special member functions.
@@ -1031,38 +935,37 @@ which:
 For a class, its non-static data members, its non-virtual direct base
 classes, and, if the class is not abstract [[class.abstract]], its
 virtual base classes are called its *potentially constructed
 subobjects*.
-A defaulted special member function is *constexpr-compatible* if the
-corresponding implicitly-declared special member function would be a
-constexpr function.
 ### Constructors <a id="class.ctor">[[class.ctor]]</a>
-A *constructor* is introduced by a declaration whose *declarator* is a
-function declarator [[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
-- in a *member-declaration* that belongs to the *member-specification*
- of a class or class template but is not a friend declaration
-  [[class.friend]], the *id-expression* is the injected-class-name
- [[class.pre]] of the immediately-enclosing entity or
-- in a declaration at namespace scope or in a friend declaration, the
- *id-expression* is a *qualified-id* that names a constructor
-  [[class.qual]].
 Constructors do not have names. In a constructor declaration, each
 *decl-specifier* in the optional *decl-specifier-seq* shall be `friend`,
-`inline`, `constexpr`, or an *explicit-specifier*.
 [*Example 1*:
 ``` cpp
 struct S {
@@ -1072,18 +975,17 @@ struct S {
 S::S() { }          // defines the constructor
 ```
 — *end example*]
-A constructor is used to initialize objects of its class type. Because
-constructors do not have names, they are never found during name lookup;
-however an explicit type conversion using the functional notation
-[[expr.type.conv]] will cause a constructor to be called to initialize
-an object.
-[*Note 1*: The syntax looks like an explicit call of the
-constructor. — *end note*]
 [*Example 2*:
 ``` cpp
 complex zz = complex(1,2.3);
@@ -1110,15 +1012,19 @@ during construction; see  [[class.base.init]] and
 A constructor can be invoked for a `const`, `volatile` or `const`
 `volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
 not applied on an object under construction. They come into effect when
 the constructor for the most derived object [[intro.object]] ends.
-A `return` statement in the body of a constructor shall not specify a
-return value. The address of a constructor shall not be taken.
 A constructor shall not be a coroutine.
 #### Default constructors <a id="class.default.ctor">[[class.default.ctor]]</a>
 A *default constructor* for a class `X` is a constructor of class `X`
 for which each parameter that is not a function parameter pack has a
 default argument (including the case of a constructor with no
@@ -1166,42 +1072,33 @@ A default constructor is *trivial* if it is not user-provided and if:
   type (or array thereof), each such class has a trivial default
   constructor.
 Otherwise, the default constructor is *non-trivial*.
-A default constructor that is defaulted and not defined as deleted is
-*implicitly defined* when it is odr-used [[basic.def.odr]] to create an
-object of its class type [[intro.object]], when it is needed for
-constant evaluation [[expr.const]], or when it is explicitly defaulted
-after its first declaration. The implicitly-defined default constructor
 performs the set of initializations of the class that would be performed
 by a user-written default constructor for that class with no
 *ctor-initializer* [[class.base.init]] and an empty
 *compound-statement*. If that user-written default constructor would be
 ill-formed, the program is ill-formed. If that user-written default
-constructor would satisfy the requirements of a constexpr constructor
-[[dcl.constexpr]], the implicitly-defined default constructor is
-`constexpr`. Before the defaulted default constructor for a class is
-implicitly defined, all the non-user-provided default constructors for
-its base classes and its non-static data members are implicitly defined.
 [*Note 1*: An implicitly-declared default constructor has an exception
 specification [[except.spec]]. An explicitly-defaulted definition might
 have an implicit exception specification, see
 [[dcl.fct.def]]. — *end note*]
-Default constructors are called implicitly to create class objects of
-static, thread, or automatic storage duration ([[basic.stc.static]],
-[[basic.stc.thread]], [[basic.stc.auto]]) defined without an initializer
-[[dcl.init]], are called to create class objects of dynamic storage
-duration [[basic.stc.dynamic]] created by a *new-expression* in which
-the *new-initializer* is omitted [[expr.new]], or are called when the
-explicit type conversion syntax [[expr.type.conv]] is used. A program is
-ill-formed if the default constructor for an object is implicitly used
-and the constructor is not accessible [[class.access]].
-[*Note 2*:  [[class.base.init]] describes the order in which
 constructors for base classes and non-static data members are called and
 describes how arguments can be specified for the calls to these
 constructors. — *end note*]
 #### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
@@ -1250,11 +1147,11 @@ Y e = d;            // calls Y(const Y&)
 — *end example*]
 [*Note 1*:
-All forms of copy/move constructor may be declared for a class.
 [*Example 3*:
 ``` cpp
 struct X {
@@ -1316,25 +1213,26 @@ void h() {
 If the class definition does not explicitly declare a copy constructor,
 a non-explicit one is declared *implicitly*. If the class definition
 declares a move constructor or move assignment operator, the implicitly
 declared copy constructor is defined as deleted; otherwise, it is
-defined as defaulted [[dcl.fct.def]]. The latter case is deprecated if
-the class has a user-declared copy assignment operator or a
-user-declared destructor [[depr.impldec]].
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
 if each potentially constructed subobject of a class type `M` (or array
 thereof) has a copy constructor whose first parameter is of type `const`
-`M&` or `const` `volatile` `M&`.[^3] Otherwise, the implicitly-declared
-copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
@@ -1347,11 +1245,11 @@ if and only if
 - `X` does not have a user-declared move assignment operator, and
 - `X` does not have a user-declared destructor.
 [*Note 3*: When the move constructor is not implicitly declared or
 explicitly supplied, expressions that otherwise would have invoked the
-move constructor may instead invoke a copy constructor. — *end note*]
 The implicitly-declared move constructor for class `X` will have the
 form
 ``` cpp
@@ -1360,24 +1258,24 @@ X::X(X&&)
 An implicitly-declared copy/move constructor is an inline public member
 of its class. A defaulted copy/move constructor for a class `X` is
 defined as deleted [[dcl.fct.def.delete]] if `X` has:
-- a potentially constructed subobject type `M` (or array thereof) that
-  cannot be copied/moved because overload resolution [[over.match]], as
-  applied to find `M`’s corresponding constructor, results in an
-  ambiguity or a function that is deleted or inaccessible from the
-  defaulted constructor,
 - a variant member whose corresponding constructor as selected by
   overload resolution is non-trivial,
 - any potentially constructed subobject of a type with a destructor that
   is deleted or inaccessible from the defaulted constructor, or,
 - for the copy constructor, a non-static data member of rvalue reference
   type.
 [*Note 4*: A defaulted move constructor that is defined as deleted is
-ignored by overload resolution ([[over.match]], [[over.over]]). Such a
 constructor would otherwise interfere with initialization from an rvalue
 which can use the copy constructor instead. — *end note*]
 A copy/move constructor for class `X` is trivial if it is not
 user-provided and if:
@@ -1390,22 +1288,17 @@ user-provided and if:
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
-A copy/move constructor that is defaulted and not defined as deleted is
-*implicitly defined* when it is odr-used [[basic.def.odr]], when it is
-needed for constant evaluation [[expr.const]], or when it is explicitly
-defaulted after its first declaration.
 [*Note 5*: The copy/move constructor is implicitly defined even if the
-implementation elided its odr-use ([[basic.def.odr]],
-[[class.temporary]]). — *end note*]
-If the implicitly-defined constructor would satisfy the requirements of
-a constexpr constructor [[dcl.constexpr]], the implicitly-defined
-constructor is `constexpr`.
 Before the defaulted copy/move constructor for a class is implicitly
 defined, all non-user-provided copy/move constructors for its
 potentially constructed subobjects are implicitly defined.
@@ -1434,27 +1327,27 @@ to its type:
 Virtual base class subobjects shall be initialized only once by the
 implicitly-defined copy/move constructor (see  [[class.base.init]]).
 The implicitly-defined copy/move constructor for a union `X` copies the
-object representation [[basic.types]] of `X`. For each object nested
-within [[intro.object]] the object that is the source of the copy, a
-corresponding object o nested within the destination is identified (if
-the object is a subobject) or created (otherwise), and the lifetime of o
-begins before the copy is performed.
 ### Copy/move assignment operator <a id="class.copy.assign">[[class.copy.assign]]</a>
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
-parameter of type `X`, `X&`, `const X&`, `volatile X&`, or
 `const volatile X&`.[^4]
 [*Note 1*: An overloaded assignment operator must be declared to have
 only one parameter; see  [[over.ass]]. — *end note*]
-[*Note 2*: More than one form of copy assignment operator may be
 declared for a class. — *end note*]
 [*Note 3*:
 If a class `X` only has a copy assignment operator with a parameter of
@@ -1480,12 +1373,12 @@ void f() {
 — *end note*]
 If the class definition does not explicitly declare a copy assignment
 operator, one is declared *implicitly*. If the class definition declares
 a move constructor or move assignment operator, the implicitly declared
-copy assignment operator is defined as deleted; otherwise, it is defined
-as defaulted [[dcl.fct.def]]. The latter case is deprecated if the class
 has a user-declared copy constructor or a user-declared destructor
 [[depr.impldec]]. The implicitly-declared copy assignment operator for a
 class `X` will have the form
 ``` cpp
@@ -1507,17 +1400,18 @@ the form
 ``` cpp
 X& X::operator=(X&)
 ```
 A user-declared move assignment operator `X::operator=` is a non-static
-non-template member function of class `X` with exactly one parameter of
-type `X&&`, `const X&&`, `volatile X&&`, or `const volatile X&&`.
 [*Note 4*: An overloaded assignment operator must be declared to have
 only one parameter; see  [[over.ass]]. — *end note*]
-[*Note 5*: More than one form of move assignment operator may be
 declared for a class. — *end note*]
 If the definition of a class `X` does not explicitly declare a move
 assignment operator, one will be implicitly declared as defaulted if and
 only if
@@ -1558,14 +1452,12 @@ have the form
 ``` cpp
 X& X::operator=(X&&)
 ```
 The implicitly-declared copy/move assignment operator for class `X` has
-the return type `X&`; it returns the object for which the assignment
-operator is invoked, that is, the object assigned to. An
-implicitly-declared copy/move assignment operator is an inline public
-member of its class.
 A defaulted copy/move assignment operator for class `X` is defined as
 deleted if `X` has:
 - a variant member with a non-trivial corresponding assignment operator
@@ -1579,23 +1471,23 @@ deleted if `X` has:
   corresponding assignment operator, results in an ambiguity or a
   function that is deleted or inaccessible from the defaulted assignment
   operator.
 [*Note 6*: A defaulted move assignment operator that is defined as
-deleted is ignored by overload resolution ([[over.match]],
-[[over.over]]). — *end note*]
 Because a copy/move assignment operator is implicitly declared for a
 class if not declared by the user, a base class copy/move assignment
 operator is always hidden by the corresponding assignment operator of a
-derived class [[over.ass]]. A *using-declaration* [[namespace.udecl]]
-that brings in from a base class an assignment operator with a parameter
-type that could be that of a copy/move assignment operator for the
-derived class is not considered an explicit declaration of such an
-operator and does not suppress the implicit declaration of the derived
-class operator; the operator introduced by the *using-declaration* is
-hidden by the implicitly-declared operator in the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
 user-provided and if:
 - class `X` has no virtual functions [[class.virtual]] and no virtual
@@ -1606,31 +1498,19 @@ user-provided and if:
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
-A copy/move assignment operator for a class `X` that is defaulted and
-not defined as deleted is *implicitly defined* when it is odr-used
-[[basic.def.odr]] (e.g., when it is selected by overload resolution to
-assign to an object of its class type), when it is needed for constant
-evaluation [[expr.const]], or when it is explicitly defaulted after its
-first declaration. The implicitly-defined copy/move assignment operator
-is `constexpr` if
-- `X` is a literal type, and
-- the assignment operator selected to copy/move each direct base class
-  subobject is a constexpr function, and
-- for each non-static data member of `X` that is of class type (or array
-  thereof), the assignment operator selected to copy/move that member is
-  a constexpr function.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members are
 implicitly defined.
-[*Note 7*: An implicitly-declared copy/move assignment operator has an
 implied exception specification [[except.spec]]. — *end note*]
 The implicitly-defined copy/move assignment operator for a non-union
 class `X` performs memberwise copy/move assignment of its subobjects.
 The direct base classes of `X` are assigned first, in the order of their
@@ -1668,21 +1548,27 @@ It is unspecified whether the virtual base class subobject `V` is
 assigned twice by the implicitly-defined copy/move assignment operator
 for `C`.
 — *end example*]
-The implicitly-defined copy assignment operator for a union `X` copies
-the object representation [[basic.types]] of `X`. If the source and
-destination of the assignment are not the same object, then for each
-object nested within [[intro.object]] the object that is the source of
-the copy, a corresponding object o nested within the destination is
-created, and the lifetime of o begins before the copy is performed.
 ### Destructors <a id="class.dtor">[[class.dtor]]</a>
-A *prospective destructor* is introduced by a declaration whose
-*declarator* is a function declarator [[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
@@ -1693,13 +1579,13 @@ parentheses, and the *id-expression* has one of the following forms:
 - in a *member-declaration* that belongs to the *member-specification*
   of a class or class template but is not a friend declaration
   [[class.friend]], the *id-expression* is `~`*class-name* and the
   *class-name* is the injected-class-name [[class.pre]] of the
   immediately-enclosing entity or
-- in a declaration at namespace scope or in a friend declaration, the
-  *id-expression* is *nested-name-specifier* `~`*class-name* and the
- *class-name* names the same class as the *nested-name-specifier*.
 A prospective destructor shall take no arguments [[dcl.fct]]. Each
 *decl-specifier* of the *decl-specifier-seq* of a prospective destructor
 declaration (if any) shall be `friend`, `inline`, `virtual`,
 `constexpr`, or `consteval`.
@@ -1719,21 +1605,25 @@ the form
 At the end of the definition of a class, overload resolution is
 performed among the prospective destructors declared in that class with
 an empty argument list to select the *destructor* for the class, also
 known as the *selected destructor*. The program is ill-formed if
 overload resolution fails. Destructor selection does not constitute a
-reference to, or odr-use [[basic.def.odr]] of, the selected destructor,
 and in particular, the selected destructor may be deleted
 [[dcl.fct.def.delete]].
-The address of a destructor shall not be taken. A destructor can be
-invoked for a `const`, `volatile` or `const` `volatile` object. `const`
-and `volatile` semantics [[dcl.type.cv]] are not applied on an object
-under destruction. They stop being in effect when the destructor for the
-most derived object [[intro.object]] starts.
-[*Note 1*: A declaration of a destructor that does not have a
 *noexcept-specifier* has the same exception specification as if it had
 been implicitly declared [[except.spec]]. — *end note*]
 A defaulted destructor for a class `X` is defined as deleted if:
@@ -1746,37 +1636,31 @@ A defaulted destructor for a class `X` is defined as deleted if:
   function results in an ambiguity or in a function that is deleted or
   inaccessible from the defaulted destructor.
 A destructor is trivial if it is not user-provided and if:
-- the destructor is not `virtual`,
 - all of the direct base classes of its class have trivial destructors,
   and
 - for all of the non-static data members of its class that are of class
   type (or array thereof), each such class has a trivial destructor.
 Otherwise, the destructor is *non-trivial*.
-A defaulted destructor is a constexpr destructor if it satisfies the
-requirements for a constexpr destructor [[dcl.constexpr]].
-A destructor that is defaulted and not defined as deleted is *implicitly
-defined* when it is odr-used [[basic.def.odr]] or when it is explicitly
-defaulted after its first declaration.
 Before a defaulted destructor for a class is implicitly defined, all the
 non-user-provided destructors for its base classes and its non-static
 data members are implicitly defined.
-A prospective destructor can be declared `virtual` [[class.virtual]] or
-pure `virtual` [[class.abstract]]. If the destructor of a class is
-virtual and any objects of that class or any derived class are created
-in the program, the destructor shall be defined. If a class has a base
-class with a virtual destructor, its destructor (whether user- or
-implicitly-declared) is virtual.
-[*Note 2*:  Some language constructs have special semantics when used
 during destruction; see  [[class.cdtor]]. — *end note*]
 After executing the body of the destructor and destroying any objects
 with automatic storage duration allocated within the body, a destructor
 for class `X` calls the destructors for `X`’s direct non-variant
@@ -1784,53 +1668,56 @@ non-static data members, the destructors for `X`’s non-virtual direct
 base classes and, if `X` is the most derived class [[class.base.init]],
 its destructor calls the destructors for `X`’s virtual base classes. All
 destructors are called as if they were referenced with a qualified name,
 that is, ignoring any possible virtual overriding destructors in more
 derived classes. Bases and members are destroyed in the reverse order of
-the completion of their constructor (see  [[class.base.init]]). A
-`return` statement [[stmt.return]] in a destructor might not directly
-return to the caller; before transferring control to the caller, the
-destructors for the members and bases are called. Destructors for
-elements of an array are called in reverse order of their construction
-(see  [[class.init]]).
 A destructor is invoked implicitly
 - for a constructed object with static storage duration
   [[basic.stc.static]] at program termination [[basic.start.term]],
 - for a constructed object with thread storage duration
   [[basic.stc.thread]] at thread exit,
 - for a constructed object with automatic storage duration
   [[basic.stc.auto]] when the block in which an object is created exits
   [[stmt.dcl]],
-- for a constructed temporary object when its lifetime ends (
-  [[conv.rval]], [[class.temporary]]).
 In each case, the context of the invocation is the context of the
 construction of the object. A destructor may also be invoked implicitly
 through use of a *delete-expression* [[expr.delete]] for a constructed
 object allocated by a *new-expression* [[expr.new]]; the context of the
 invocation is the *delete-expression*.
-[*Note 3*: An array of class type contains several subobjects for each
 of which the destructor is invoked. — *end note*]
 A destructor can also be invoked explicitly. A destructor is
 *potentially invoked* if it is invoked or as specified in  [[expr.new]],
 [[stmt.return]], [[dcl.init.aggr]], [[class.base.init]], and
 [[except.throw]]. A program is ill-formed if a destructor that is
 potentially invoked is deleted or not accessible from the context of the
 invocation.
 At the point of definition of a virtual destructor (including an
-implicit definition [[class.dtor]]), the non-array deallocation function
-is determined as if for the expression `delete this` appearing in a
-non-virtual destructor of the destructor’s class (see  [[expr.delete]]).
-If the lookup fails or if the deallocation function has a deleted
-definition [[dcl.fct.def]], the program is ill-formed.
-[*Note 4*: This assures that a deallocation function corresponding to
 the dynamic type of an object is available for the *delete-expression*
 [[class.free]]. — *end note*]
 In an explicit destructor call, the destructor is specified by a `~`
 followed by a *type-name* or *decltype-specifier* that denotes the
@@ -1838,11 +1725,11 @@ destructor’s class type. The invocation of a destructor is subject to
 the usual rules for member functions [[class.mfct]]; that is, if the
 object is not of the destructor’s class type and not of a class derived
 from the destructor’s class type (including when the destructor is
 invoked via a null pointer value), the program has undefined behavior.
-[*Note 5*: Invoking `delete` on a null pointer does not call the
 destructor; see [[expr.delete]]. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -1866,17 +1753,17 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 6*: An explicit destructor call must always be written using a
 member access operator [[expr.ref]] or a *qualified-id*
 [[expr.prim.id.qual]]; in particular, the *unary-expression* `~X()` in a
 member function is not an explicit destructor call
 [[expr.unary.op]]. — *end note*]
-[*Note 7*:
 Explicit calls of destructors are rarely needed. One use of such calls
 is for objects placed at specific addresses using a placement
 *new-expression*. Such use of explicit placement and destruction of
 objects can be necessary to cope with dedicated hardware resources and
@@ -1898,20 +1785,20 @@ void g() {                      // rare, specialized use:
 }
 ```
 — *end note*]
-Once a destructor is invoked for an object, the object no longer exists;
 the behavior is undefined if the destructor is invoked for an object
 whose lifetime has ended [[basic.life]].
 [*Example 2*: If the destructor for an object with automatic storage
 duration is explicitly invoked, and the block is subsequently left in a
 manner that would ordinarily invoke implicit destruction of the object,
 the behavior is undefined. — *end example*]
-[*Note 8*:
 The notation for explicit call of a destructor can be used for any
 scalar type name [[expr.prim.id.dtor]]. Allowing this makes it possible
 to write code without having to know if a destructor exists for a given
 type. For example:
@@ -1926,19 +1813,21 @@ p->I::~I();
 A destructor shall not be a coroutine.
 ### Conversions <a id="class.conv">[[class.conv]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
 conversions* and are used for implicit type conversions [[conv]], for
-initialization [[dcl.init]], and for explicit type conversions (
-[[expr.type.conv]], [[expr.cast]], [[expr.static.cast]]).
-User-defined conversions are applied only where they are unambiguous (
-[[class.member.lookup]], [[class.conv.fct]]). Conversions obey the
-access control rules [[class.access]]. Access control is applied after
 ambiguity resolution [[basic.lookup]].
 [*Note 1*: See  [[over.match]] for a discussion of the use of
 conversions in function calls as well as examples below. — *end note*]
@@ -1956,36 +1845,11 @@ struct Y {
   operator X();
 };
 Y a;
 int b = a;          // error: no viable conversion (a.operator X().operator int() not considered)
-int c = X(a);       // OK: a.operator X().operator int()
-```
-— *end example*]
-User-defined conversions are used implicitly only if they are
-unambiguous. A conversion function in a derived class does not hide a
-conversion function in a base class unless the two functions convert to
-the same type. Function overload resolution [[over.match.best]] selects
-the best conversion function to perform the conversion.
-[*Example 2*:
-``` cpp
-struct X {
-  operator int();
-};
-struct Y : X {
-    operator char();
-};
-void f(Y& a) {
-  if (a) {          // error: ambiguous between X::operator int() and Y::operator char()
-  }
-}
 ```
 — *end example*]
 #### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
@@ -2016,13 +1880,13 @@ void f(X arg) {
 [*Note 1*:
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax
-[[dcl.init]] or where casts ([[expr.static.cast]], [[expr.cast]]) are
 explicitly used; see also  [[over.match.copy]]. A default constructor
-may be an explicit constructor; such a constructor will be used to
 perform default-initialization or value-initialization [[dcl.init]].
 [*Example 2*:
 ``` cpp
@@ -2030,19 +1894,19 @@ struct Z {
   explicit Z();
   explicit Z(int);
   explicit Z(int, int);
 };
-Z a;                            // OK: default-initialization performed
-Z b{};                          // OK: direct initialization syntax used
 Z c = {};                       // error: copy-list-initialization
 Z a1 = 1;                       // error: no implicit conversion
-Z a3 = Z(1);                    // OK: direct initialization syntax used
-Z a2(1);                        // OK: direct initialization syntax used
-Z* p = new Z(1);                // OK: direct initialization syntax used
-Z a4 = (Z)1;                    // OK: explicit cast used
-Z a5 = static_cast<Z>(1);       // OK: explicit cast used
 Z a6 = { 3, 4 };                // error: no implicit conversion
 ```
 — *end example*]
@@ -2050,18 +1914,15 @@ Z a6 = { 3, 4 };                // error: no implicit conversion
 A non-explicit copy/move constructor [[class.copy.ctor]] is a converting
 constructor.
 [*Note 2*: An implicitly-declared copy/move constructor is not an
-explicit constructor; it may be called for implicit type
 conversions. — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
-A member function of a class `X` having no parameters with a name of the
-form
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
 ```
@@ -2073,20 +1934,44 @@ conversion-type-id:
 ``` bnf
 conversion-declarator:
     ptr-operator conversion-declaratorₒₚₜ
 ```
 specifies a conversion from `X` to the type specified by the
-*conversion-type-id*. Such functions are called *conversion functions*.
-A *decl-specifier* in the *decl-specifier-seq* of a conversion function
-(if any) shall be neither a *defining-type-specifier* nor `static`. The
-type of the conversion function [[dcl.fct]] is “function taking no
-parameter returning *conversion-type-id*”. A conversion function is
-never used to convert a (possibly cv-qualified) object to the (possibly
-cv-qualified) same object type (or a reference to it), to a (possibly
-cv-qualified) base class of that type (or a reference to it), or to
-cv `void`.[^6]
 [*Example 1*:
 ``` cpp
 struct X {
@@ -2118,13 +2003,13 @@ class Y { };
 struct Z {
   explicit operator Y() const;
 };
 void h(Z z) {
-  Y y1(z);          // OK: direct-initialization
   Y y2 = z;         // error: no conversion function candidate for copy-initialization
-  Y y3 = (Y)z;      // OK: cast notation
 }
 void g(X a, X b) {
   int i = (a) ? 1+a : 0;
   int j = (a&&b) ? a+b : i;
@@ -2167,18 +2052,47 @@ operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
 — *end example*]
 — *end note*]
-Conversion functions are inherited.
 Conversion functions can be virtual.
 A conversion function template shall not have a deduced return type
 [[dcl.spec.auto]].
-[*Example 5*:
 ``` cpp
 struct S {
   operator auto() const { return 10; }      // OK
   template<class T>
@@ -2188,10 +2102,12 @@ struct S {
 — *end example*]
 ### Static members <a id="class.static">[[class.static]]</a>
 A static member `s` of class `X` may be referred to using the
 *qualified-id* expression `X::s`; it is not necessary to use the class
 member access syntax [[expr.ref]] to refer to a static member. A static
 member may be referred to using the class member access syntax, in which
 case the object expression is evaluated.
@@ -2203,39 +2119,17 @@ struct process {
   static void reschedule();
 };
 process& g();
 void f() {
-  process::reschedule();        // OK: no object necessary
   g().reschedule();             // g() is called
 }
 ```
 — *end example*]
-A static member may be referred to directly in the scope of its class or
-in the scope of a class derived [[class.derived]] from its class; in
-this case, the static member is referred to as if a *qualified-id*
-expression was used, with the *nested-name-specifier* of the
-*qualified-id* naming the class scope from which the static member is
-referenced.
-[*Example 2*:
-``` cpp
-int g();
-struct X {
-  static int g();
-};
-struct Y : X {
-  static int i;
-};
-int Y::i = g();                 // equivalent to Y::g();
-```
-— *end example*]
 Static members obey the usual class member access rules
 [[class.access]]. When used in the declaration of a class member, the
 `static` specifier shall only be used in the member declarations that
 appear within the *member-specification* of the class definition.
@@ -2246,16 +2140,12 @@ namespace scope. — *end note*]
 [*Note 1*: The rules described in  [[class.mfct]] apply to static
 member functions. — *end note*]
 [*Note 2*: A static member function does not have a `this` pointer
-[[class.this]]. — *end note*]
-A static member function shall not be `virtual`. There shall not be a
-static and a non-static member function with the same name and the same
-parameter types [[over.load]]. A static member function shall not be
-declared `const`, `volatile`, or `const volatile`.
 #### Static data members <a id="class.static.data">[[class.static.data]]</a>
 A static data member is not part of the subobjects of a class. If a
 static data member is declared `thread_local` there is one copy of the
@@ -2268,17 +2158,14 @@ member shall not be a direct member [[class.mem]] of an unnamed
 [[class.pre]] or local [[class.local]] class or of a (possibly
 indirectly) nested class [[class.nest]] thereof.
 The declaration of a non-inline static data member in its class
 definition is not a definition and may be of an incomplete type other
-than cv `void`. The definition for a static data member that is not
-defined inline in the class definition shall appear in a namespace scope
-enclosing the member’s class definition. In the definition at namespace
-scope, the name of the static data member shall be qualified by its
-class name using the `::` operator. The *initializer* expression in the
-definition of a static data member is in the scope of its class
-[[basic.scope.class]].
 [*Example 1*:
 ``` cpp
 class process {
@@ -2288,20 +2175,20 @@ class process {
 process* process::running = get_main();
 process* process::run_chain = running;
 ```
-The static data member `run_chain` of class `process` is defined in
-global scope; the notation `process::run_chain` specifies that the
-member `run_chain` is a member of class `process` and in the scope of
-class `process`. In the static data member definition, the *initializer*
-expression refers to the static data member `running` of class
-`process`.
 — *end example*]
-[*Note 1*:
 Once the static data member has been defined, it exists even if no
 objects of its class have been created.
 [*Example 2*:
@@ -2309,56 +2196,57 @@ objects of its class have been created.
 In the example above, `run_chain` and `running` exist even if no objects
 of class `process` are created by the program.
 — *end example*]
 — *end note*]
 If a non-volatile non-inline `const` static data member is of integral
 or enumeration type, its declaration in the class definition can specify
 a *brace-or-equal-initializer* in which every *initializer-clause* that
 is an *assignment-expression* is a constant expression [[expr.const]].
 The member shall still be defined in a namespace scope if it is odr-used
-[[basic.def.odr]] in the program and the namespace scope definition
-shall not contain an *initializer*. An inline static data member may be
-defined in the class definition and may specify a
 *brace-or-equal-initializer*. If the member is declared with the
 `constexpr` specifier, it may be redeclared in namespace scope with no
 initializer (this usage is deprecated; see [[depr.static.constexpr]]).
 Declarations of other static data members shall not specify a
 *brace-or-equal-initializer*.
-[*Note 2*: There is exactly one definition of a static data member that
-is odr-used [[basic.def.odr]] in a valid program. — *end note*]
-[*Note 3*: Static data members of a class in namespace scope have the
 linkage of the name of the class [[basic.link]]. — *end note*]
-Static data members are initialized and destroyed exactly like non-local
-variables ([[basic.start.static]], [[basic.start.dynamic]],
-[[basic.start.term]]).
 ### Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
 ``` bnf
 identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
 ```
 specifies a bit-field. The optional *attribute-specifier-seq* appertains
 to the entity being declared. A bit-field shall not be a static member.
-A bit-field shall have integral or enumeration type; the bit-field
-semantic property is not part of the type of the class member. The
-*constant-expression* shall be an integral constant expression with a
-value greater than or equal to zero and is called the *width* of the
-bit-field. If the width of a bit-field is larger than the width of the
-bit-field’s type (or, in case of an enumeration type, of its underlying
-type), the extra bits are padding bits [[basic.types]]. Allocation of
-bit-fields within a class object is *implementation-defined*. Alignment
-of bit-fields is *implementation-defined*. Bit-fields are packed into
-some addressable allocation unit.
 [*Note 1*: Bit-fields straddle allocation units on some machines and
 not on others. Bit-fields are assigned right-to-left on some machines,
 left-to-right on others. — *end note*]
@@ -2373,12 +2261,12 @@ externally-imposed layouts. — *end note*]
 As a special case, an unnamed bit-field with a width of zero specifies
 alignment of the next bit-field at an allocation unit boundary. Only
 when declaring an unnamed bit-field may the width be zero.
 The address-of operator `&` shall not be applied to a bit-field, so
-there are no pointers to bit-fields. A non-const reference shall not be
-bound to a bit-field [[dcl.init.ref]].
 [*Note 3*: If the initializer for a reference of type `const` `T&` is
 an lvalue that refers to a bit-field, the reference is bound to a
 temporary initialized to hold the value of the bit-field; the reference
 is not bound to the bit-field directly. See
@@ -2411,16 +2299,139 @@ void f() {
 }
 ```
 — *end example*]
 ### Nested class declarations <a id="class.nest">[[class.nest]]</a>
 A class can be declared within another class. A class declared within
-another is called a *nested class*. The name of a nested class is local
-to its enclosing class. The nested class is in the scope of its
-enclosing class.
 [*Note 1*: See  [[expr.prim.id]] for restrictions on the use of
 non-static data members and non-static member functions. — *end note*]
 [*Example 1*:
@@ -2433,29 +2444,33 @@ struct enclose {
   int x;
   static int s;
   struct inner {
     void f(int i) {
-      int a = sizeof(x);        // OK: operand of sizeof is an unevaluated operand
       x = i;                    // error: assign to enclose::x
-      s = i;                    // OK: assign to enclose::s
-      ::x = i;                  // OK: assign to global x
-      y = i;                    // OK: assign to global y
     }
     void g(enclose* p, int i) {
-      p->x = i;                 // OK: assign to enclose::x
     }
   };
 };
-inner* p = 0;                   // error: inner not in scope
 ```
 — *end example*]
-Member functions and static data members of a nested class can be
-defined in a namespace scope enclosing the definition of their class.
 [*Example 2*:
 ``` cpp
 struct enclose {
@@ -2466,63 +2481,30 @@ struct enclose {
 };
 int enclose::inner::x = 1;
 void enclose::inner::f(int i) { ... }
-```
-— *end example*]
-If class `X` is defined in a namespace scope, a nested class `Y` may be
-declared in class `X` and later defined in the definition of class `X`
-or be later defined in a namespace scope enclosing the definition of
-class `X`.
-[*Example 3*:
-``` cpp
 class E {
   class I1;                     // forward declaration of nested class
   class I2;
   class I1 { };                 // definition of nested class
 };
 class E::I2 { };                // definition of nested class
 ```
 — *end example*]
-Like a member function, a friend function [[class.friend]] defined
-within a nested class is in the lexical scope of that class; it obeys
-the same rules for name binding as a static member function of that
-class [[class.static]], but it has no special access rights to members
-of an enclosing class.
-### Nested type names <a id="class.nested.type">[[class.nested.type]]</a>
-Type names obey exactly the same scope rules as other names. In
-particular, type names defined within a class definition cannot be used
-outside their class without qualification.
-[*Example 1*:
-``` cpp
-struct X {
-  typedef int I;
-  class Y { ... };
-  I a;
-};
-I b;                            // error
-Y c;                            // error
-X::Y d;                         // OK
-X::I e;                         // OK
-```
-— *end example*]
 ## Unions <a id="class.union">[[class.union]]</a>
 A *union* is a class defined with the *class-key* `union`.
 In a union, a non-static data member is *active* if its name refers to
 an object whose lifetime has begun and has not ended [[basic.life]]. At
 most one of the non-static data members of an object of union type can
@@ -2540,27 +2522,29 @@ 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.
 [*Note 2*: A union object and its non-static data members are
-pointer-interconvertible ([[basic.compound]], [[expr.static.cast]]). As
-a 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. — *end note*]
 [*Example 1*:
 Consider the following union:
@@ -2578,10 +2562,12 @@ 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*]
 When the left operand of an assignment operator involves a member access
 expression [[expr.ref]] that nominates a union member, it may begin the
 lifetime of that union member, as described below. For an expression
 `E`, define the set S(E) of subexpressions of `E` as follows:
@@ -2612,32 +2598,32 @@ the union, if any [[basic.life]]. — *end note*]
 union A { int x; int y[4]; };
 struct B { A a; };
 union C { B b; int k; };
 int f() {
   C c;                  // does not start lifetime of any union member
-  c.b.a.y[3] = 4;       // OK: S(c.b.a.y[3]) contains c.b and c.b.a.y;
                         // creates objects to hold union members c.b and c.b.a.y
-  return c.b.a.y[3];    // OK: c.b.a.y refers to newly created object (see [basic.life])
 }
 struct X { const int a; int b; };
 union Y { X x; int k; };
 void g() {
   Y y = { { 1, 2 } };   // OK, y.x is active union member[class.mem]
   int n = y.x.a;
-  y.k = 4;              // OK: ends lifetime of y.x, y.k is active member of union
   y.x.b = n;            // undefined behavior: y.x.b modified outside its lifetime,
                         // S(y.x.b) is empty because X's default constructor is deleted,
                         // so union member y.x's lifetime does not implicitly start
 }
 ```
 — *end example*]
-[*Note 5*: In general, one must use explicit destructor calls and
-placement *new-expression* to change the active member of a
-union. — *end note*]
 [*Example 3*:
 Consider an object `u` of a `union` type `U` having non-static data
 members `m` of type `M` and `n` of type `N`. If `M` has a non-trivial
@@ -2660,20 +2646,18 @@ A union of the form
 ``` bnf
 union '{' member-specification '}' ';'
 ```
 is called an *anonymous union*; it defines an unnamed type and an
-unnamed object of that type called an *anonymous union object*. Each
-*member-declaration* in the *member-specification* of an anonymous union
-shall either define a non-static data member or be a
-*static_assert-declaration*. Nested types, anonymous unions, and
 functions shall not be declared within an anonymous union. The names of
-the members of an anonymous union shall be distinct from the names of
-any other entity in the scope in which the anonymous union is declared.
-For the purpose of name lookup, after the anonymous union definition,
-the members of the anonymous union are considered to have been defined
-in the scope in which the anonymous union is declared.
 [*Example 1*:
 ``` cpp
 void f() {
@@ -2686,17 +2670,17 @@ 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 a named namespace or in the global
-namespace shall be declared `static`. Anonymous unions declared at block
-scope shall be declared with any storage class allowed for a block-scope
 variable, or with no storage class. A storage class is not allowed in a
-declaration of an anonymous union in a class scope. An anonymous union
-shall not have private or protected members [[class.access]]. An
-anonymous union shall not have member functions.
 A union for which objects, pointers, or references are declared is not
 an anonymous union.
 [*Example 2*:
@@ -2713,11 +2697,13 @@ The assignment to plain `aa` is ill-formed since the member name is not
 visible outside the union, and even if it were visible, it is not
 associated with any particular object.
 — *end example*]
-[*Note 1*: Initialization of unions with no user-declared constructors
 is described in  [[dcl.init.aggr]]. — *end note*]
 A *union-like class* is a union or a class that has an anonymous union
 as a direct member. A union-like class `X` has a set of *variant
 members*. If `X` is a union, a non-static data member of `X` that is not
@@ -2744,17 +2730,14 @@ union U {
 — *end example*]
 ## Local class declarations <a id="class.local">[[class.local]]</a>
 A class can be declared within a function definition; such a class is
-called a *local class*. The name of a local class is local to its
-enclosing scope. The local class is in the scope of the enclosing scope,
-and has the same access to names outside the function as does the
-enclosing function.
 [*Note 1*: A declaration in a local class cannot odr-use
-[[basic.def.odr]] a local entity from an enclosing scope. — *end note*]
 [*Example 1*:
 ``` cpp
 int x;
@@ -2769,17 +2752,17 @@ void f() {
   struct local {
     int g() { return x; }       // error: odr-use of non-odr-usable variable x
     int h() { return s; }       // OK
     int k() { return ::x; }     // OK
     int l() { return q(); }     // OK
-    int m() { return N; }       // OK: not an odr-use
     int* n() { return &N; }     // error: odr-use of non-odr-usable variable N
     int p() { return y; }       // error: odr-use of non-odr-usable structured binding y
   };
 }
-local* p = 0;                   // error: local not in scope
 ```
 — *end example*]
 An enclosing function has no special access to members of the local
@@ -2795,10 +2778,12 @@ 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>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
 base-clause:
@@ -2833,42 +2818,41 @@ access-specifier:
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
-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. During the lookup for a base class name, non-type names
-are ignored [[basic.scope.hiding]]. 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*]
-Unless redeclared in the derived class, members of a base class are also
-considered to be members of the derived class. Members of a base class
-other than constructors are said to be *inherited* by the derived class.
-Constructors of a base class can also be inherited as described in
-[[namespace.udecl]]. Inherited members can be referred to in expressions
-in the same manner as other members of the derived class, unless their
-names are hidden or ambiguous [[class.member.lookup]].
-[*Note 2*: The scope resolution operator `::` [[expr.prim.id.qual]] can
-be used to refer to a direct or indirect base member explicitly. This
-allows access to a name that has been redeclared in the derived class. A
-derived class can itself serve as a base class subject to access
-control; see  [[class.access.base]]. A pointer to a derived class can be
-implicitly converted to a pointer to an accessible unambiguous base
-class [[conv.ptr]]. An lvalue of a derived class type can be bound to a
-reference to an accessible unambiguous base class
-[[dcl.init.ref]]. — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
@@ -2904,29 +2888,26 @@ derived object [[intro.object]] is unspecified.
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
 “directly derived from” (see Figure [[fig:class.dag]]). An arrow
 need not have a physical representation in memory. A DAG of subobjects
-is often referred to as a “subobject lattice”.
 <a id="fig:class.dag"></a>
 ![Directed acyclic graph \[fig:class.dag\]](images/figdag.svg)
- — *end note*]
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
-[*Note 5*: A base class subobject might have a layout [[basic.stc]]
-different from the layout of a most derived object of the same type. A
-base class subobject might have a polymorphic behavior [[class.cdtor]]
-different from the polymorphic behavior of a most derived object of the
-same type. A base class subobject may be of zero size [[class]];
-however, two subobjects that have the same class type and that belong to
-the same most derived object must not be allocated at the same address
-[[expr.eq]]. — *end note*]
 ### Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
@@ -2944,22 +2925,22 @@ class D : public A, public B, public C { ... };
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
 specified by the semantics of initialization by constructor
-[[class.base.init]], cleanup [[class.dtor]], and storage layout (
-[[class.mem]], [[class.access.spec]]). — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
 be a direct and an indirect base class. There are limited things that
-can be done with such a class. The non-static data members and member
-functions of the direct base class cannot be referred to in the scope of
-the derived class. However, the static members, enumerations and types
-can be unambiguously referred to. — *end note*]
 [*Example 2*:
 ``` cpp
 class X { ... };
@@ -2997,12 +2978,12 @@ subobjects of class `L` as shown in Figure [[fig:class.nonvirt]].
 <a id="fig:class.nonvirt"></a>
 ![Non-virtual base \[fig:class.nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
-subobject is meant. The body of function `C::f` could refer to the
-member `next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
@@ -3069,25 +3050,24 @@ 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 that declares or inherits a virtual function is called a
 *polymorphic class*.[^8]
-If a virtual member function `vf` is declared in a class `Base` and in a
-class `Derived`, derived directly or indirectly from `Base`, a member
-function `vf` with the same name, parameter-type-list [[dcl.fct]],
-cv-qualification, and ref-qualifier (or absence of same) as `Base::vf`
-is declared, then `Derived::vf` *overrides*[^9] `Base::vf`. For
-convenience we say that any virtual function overrides itself. A virtual
-member function `C::vf` 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) declares or inherits another member function
-that overrides `vf`. 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 {
@@ -3113,11 +3093,11 @@ void foo() {
 ``` cpp
 struct A { virtual void f(); };
 struct B : A { };
 struct C : A { void f(); };
-struct D : B, C { };            // OK: A::f and C::f are the final overriders
                                 // for the B and C subobjects, respectively
 ```
 — *end example*]
@@ -3187,20 +3167,20 @@ A virtual function shall not have a trailing *requires-clause*
 [[dcl.decl]].
 [*Example 5*:
 ``` cpp
 struct A {
   virtual void f() requires true;       // error: virtual function cannot be constrained[temp.constr.decl]
 };
 ```
 — *end example*]
-Even though destructors are not inherited, a destructor in a derived
-class overrides a base class destructor declared virtual; see
-[[class.dtor]] and  [[class.free]].
 The return type of an overriding function shall be either identical to
 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
@@ -3217,14 +3197,15 @@ the following criteria:
   as or less cv-qualification than the class type in the return type of
   `B::f`.
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
-complete at the point of declaration of `D::f` or shall be the class
-type `D`. When the overriding function is called as the final overrider
-of the overridden function, its result is converted to the type returned
-by the (statically chosen) overridden function [[expr.call]].
 [*Example 6*:
 ``` cpp
 class B { };
@@ -3245,11 +3226,11 @@ struct No_good : public Base {
 class A;
 struct Derived : public Base {
     void vf1();     // virtual and overrides Base::vf1()
     void vf2(int);  // not virtual, hides Base::vf2()
     char vf3();     // error: invalid difference in return type only
-    D*   vf4();     // OK: returns pointer to derived class
     A*   vf5();     // error: returns pointer to incomplete class
     void f();
 };
 void g() {
@@ -3278,12 +3259,12 @@ object (the static type) [[expr.call]]. — *end note*]
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
 function cannot be a non-member [[dcl.fct.spec]] function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
-virtual function declared in one class can be declared a friend (
-[[class.friend]]) in another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
 pure [[class.abstract]] in that class, or both; no diagnostic is
 required [[basic.def.odr]].
@@ -3392,14 +3373,13 @@ void D::f() { ... B::f(); }
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
-A function with a deleted definition [[dcl.fct.def]] shall not override
-a function that does not have a deleted definition. Likewise, a function
-that does not have a deleted definition shall not override a function
-with a deleted definition.
 A `consteval` virtual function shall not override a virtual function
 that is not `consteval`. A `consteval` virtual function shall not be
 overridden by a virtual function that is not `consteval`.
@@ -3421,12 +3401,12 @@ below. — *end note*]
 A class is an *abstract class* if it has at least one pure virtual
 function.
 [*Note 3*: An abstract class can be used only as a base class of some
 other class; no objects of an abstract class can be created except as
-subobjects of a class derived from it ([[basic.def]],
-[[class.mem]]). — *end note*]
 A pure virtual function need be defined only if called with, or as if
 with [[class.dtor]], the *qualified-id* syntax [[expr.prim.id.qual]].
 [*Example 1*:
@@ -3460,17 +3440,18 @@ struct C {
 [*Note 5*: An abstract class type cannot be used as a parameter or
 return type of a function being defined [[dcl.fct]] or called
 [[expr.call]], except as specified in [[dcl.type.simple]]. Further, an
 abstract class type cannot be used as the type of an explicit type
-conversion ([[expr.static.cast]], [[expr.reinterpret.cast]],
-[[expr.const.cast]]), because the resulting prvalue would be of abstract
-class type [[basic.lval]]. However, pointers and references to abstract
-class types can appear in such contexts. — *end note*]
-A class is abstract if it contains or inherits at least one pure virtual
-function for which the final overrider is pure virtual.
 [*Example 3*:
 ``` cpp
 class ab_circle : public shape {
@@ -3497,276 +3478,38 @@ would make class `circle` non-abstract and a definition of
 `circle::draw()` must be provided.
 — *end example*]
 [*Note 6*: An abstract class can be derived from a class that is not
-abstract, and a pure virtual function may override a virtual function
 which is not pure. — *end note*]
 Member functions can be called from a constructor (or destructor) of an
 abstract class; the effect of making a virtual call [[class.virtual]] to
 a pure virtual function directly or indirectly for the object being
 created (or destroyed) from such a constructor (or destructor) is
 undefined.
-## Member name lookup <a id="class.member.lookup">[[class.member.lookup]]</a>
-Member name lookup determines the meaning of a name (*id-expression*) in
-a class scope [[basic.scope.class]]. Name lookup can result in an
-ambiguity, in which case the program is ill-formed. For an
-*unqualified-id*, name lookup begins in the class scope of `this`; for a
-*qualified-id*, name lookup begins in the scope of the
-*nested-name-specifier*. Name lookup takes place before access control (
-[[basic.lookup]], [[class.access]]).
-The following steps define the result of name lookup for a member name
-`f` in a class scope `C`.
-The *lookup set* for `f` in `C`, called S(f,C), consists of two
-component sets: the *declaration set*, a set of members named `f`; and
-the *subobject set*, a set of subobjects where declarations of these
-members (possibly including *using-declaration*s) were found. In the
-declaration set, *using-declaration*s are replaced by the set of
-designated members that are not hidden or overridden by members of the
-derived class [[namespace.udecl]], and type declarations (including
-injected-class-names) are replaced by the types they designate. S(f,C)
-is calculated as follows:
-If `C` contains a declaration of the name `f`, the declaration set
-contains every declaration of `f` declared in `C` that satisfies the
-requirements of the language construct in which the lookup occurs.
-[*Note 1*: Looking up a name in an *elaborated-type-specifier*
-[[basic.lookup.elab]] or *base-specifier* [[class.derived]], for
-instance, ignores all non-type declarations, while looking up a name in
-a *nested-name-specifier* [[basic.lookup.qual]] ignores function,
-variable, and enumerator declarations. As another example, looking up a
-name in a *using-declaration* [[namespace.udecl]] includes the
-declaration of a class or enumeration that would ordinarily be hidden by
-another declaration of that name in the same scope. — *end note*]
-If the resulting declaration set is not empty, the subobject set
-contains `C` itself, and calculation is complete.
-Otherwise (i.e., `C` does not contain a declaration of `f` or the
-resulting declaration set is empty), S(f,C) is initially empty. If `C`
-has base classes, calculate the lookup set for `f` in each direct base
-class subobject Bᵢ, and merge each such lookup set S(f,Bᵢ) in turn into
-S(f,C).
-The following steps define the result of merging lookup set S(f,Bᵢ) into
-the intermediate S(f,C):
-- If each of the subobject members of S(f,Bᵢ) is a base class subobject
-  of at least one of the subobject members of S(f,C), or if S(f,Bᵢ) is
-  empty, S(f,C) is unchanged and the merge is complete. Conversely, if
-  each of the subobject members of S(f,C) is a base class subobject of
-  at least one of the subobject members of S(f,Bᵢ), or if S(f,C) is
-  empty, the new S(f,C) is a copy of S(f,Bᵢ).
-- Otherwise, if the declaration sets of S(f,Bᵢ) and S(f,C) differ, the
-  merge is ambiguous: the new S(f,C) is a lookup set with an invalid
-  declaration set and the union of the subobject sets. In subsequent
-  merges, an invalid declaration set is considered different from any
-  other.
-- Otherwise, the new S(f,C) is a lookup set with the shared set of
-  declarations and the union of the subobject sets.
-The result of name lookup for `f` in `C` is the declaration set of
-S(f,C). If it is an invalid set, the program is ill-formed.
-[*Example 1*:
-``` cpp
-struct A { int x; };                    // S(x,A) = { { A::x }, { A } }
-struct B { float x; };                  // S(x,B) = { { B::x }, { B } }
-struct C: public A, public B { };       // S(x,C) = { invalid, { A in C, B in C } }
-struct D: public virtual C { };         // S(x,D) = S(x,C)
-struct E: public virtual C { char x; }; // S(x,E) = { { E::x }, { E } }
-struct F: public D, public E { };       // S(x,F) = S(x,E)
-int main() {
-  F f;
-  f.x = 0;                              // OK, lookup finds E::x
-}
-```
-S(x,F) is unambiguous because the `A` and `B` base class subobjects of
-`D` are also base class subobjects of `E`, so S(x,D) is discarded in the
-first merge step.
-— *end example*]
-If the name of an overloaded function is unambiguously found, overload
-resolution [[over.match]] also takes place before access control.
-Ambiguities can often be resolved by qualifying a name with its class
-name.
-[*Example 2*:
-``` cpp
-struct A {
-  int f();
-};
-```
-``` cpp
-struct B {
-  int f();
-};
-```
-``` cpp
-struct C : A, B {
-  int f() { return A::f() + B::f(); }
-};
-```
-— *end example*]
-[*Note 2*: A static member, a nested type or an enumerator defined in a
-base class `T` can unambiguously be found even if an object has more
-than one base class subobject of type `T`. Two base class subobjects
-share the non-static member subobjects of their common virtual base
-classes. — *end note*]
-[*Example 3*:
-``` cpp
-struct V {
-  int v;
-};
-struct A {
-  int a;
-  static int   s;
-  enum { e };
-};
-struct B : A, virtual V { };
-struct C : A, virtual V { };
-struct D : B, C { };
-void f(D* pd) {
-  pd->v++;          // OK: only one v (virtual)
-  pd->s++;          // OK: only one s (static)
-  int i = pd->e;    // OK: only one e (enumerator)
-  pd->a++;          // error: ambiguous: two a{s} in D
-}
-```
-— *end example*]
-[*Note 3*:  When virtual base classes are used, a hidden declaration
-can be reached along a path through the subobject lattice that does not
-pass through the hiding declaration. This is not an ambiguity. The
-identical use with non-virtual base classes is an ambiguity; in that
-case there is no unique instance of the name that hides all the
-others. — *end note*]
-[*Example 4*:
-``` cpp
-struct V { int f();  int x; };
-struct W { int g();  int y; };
-struct B : virtual V, W {
-  int f();  int x;
-  int g();  int y;
-};
-struct C : virtual V, W { };
-struct D : B, C { void glorp(); };
-```
-<a id="fig:class.lookup"></a>
-![Name lookup \[fig:class.lookup\]](images/figname.svg)
-As illustrated in Figure [[fig:class.lookup]], the names declared in
-`V` and the left-hand instance of `W` are hidden by those in `B`, but
-the names declared in the right-hand instance of `W` are not hidden at
-all.
-``` cpp
-void D::glorp() {
-  x++;              // OK: B::x hides V::x
-  f();              // OK: B::f() hides V::f()
-  y++;              // error: B::y and C's W::y
-  g();              // error: B::g() and C's W::g()
-}
-```
-— *end example*]
-An explicit or implicit conversion from a pointer to or an expression
-designating an object of a derived class to a pointer or reference to
-one of its base classes shall unambiguously refer to a unique object
-representing the base class.
-[*Example 5*:
-``` cpp
-struct V { };
-struct A { };
-struct B : A, virtual V { };
-struct C : A, virtual V { };
-struct D : B, C { };
-void g() {
-  D d;
-  B* pb = &d;
-  A* pa = &d;       // error: ambiguous: C's A or B's A?
-  V* pv = &d;       // OK: only one V subobject
-}
-```
-— *end example*]
-[*Note 4*: Even if the result of name lookup is unambiguous, use of a
-name found in multiple subobjects might still be ambiguous (
-[[conv.mem]], [[expr.ref]], [[class.access.base]]). — *end note*]
-[*Example 6*:
-``` cpp
-struct B1 {
-  void f();
-  static void f(int);
-  int i;
-};
-struct B2 {
-  void f(double);
-};
-struct I1: B1 { };
-struct I2: B1 { };
-struct D: I1, I2, B2 {
-  using B1::f;
-  using B2::f;
-  void g() {
-    f();                        // Ambiguous conversion of this
-    f(0);                       // Unambiguous (static)
-    f(0.0);                     // Unambiguous (only one B2)
-    int B1::* mpB1 = &D::i;     // Unambiguous
-    int D::* mpD = &D::i;       // Ambiguous conversion
-  }
-};
-```
-— *end example*]
 ## Member access control <a id="class.access">[[class.access]]</a>
 A member of a class can be
-- private; that is, its name can be used only by members and friends of
- the class in which it is declared.
-- protected; that is, its name can be used only by members and friends
- of the class in which it is declared, by classes derived from that
- class, and by their friends (see  [[class.protected]]).
-- public; that is, its name can be used anywhere without access
-  restriction.
-A member of a class can also access all the names to which the class has
-access. A local class of a member function may access the same names
-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.
@@ -3782,61 +3525,77 @@ struct S {
 };
 ```
 — *end example*]
-Access control is applied uniformly to all names, whether the names are
-referred to from declarations or expressions.
-[*Note 1*: Access control applies to names nominated by friend
 declarations [[class.friend]] and *using-declaration*s
 [[namespace.udecl]]. — *end note*]
-In the case of overloaded function names, access control is applied to
-the function selected by overload resolution.
-[*Note 2*:
-Because access control applies to names, if access control is applied to
-a typedef name, only the accessibility of the typedef name itself is
-considered. The accessibility of the entity referred to by the typedef
-is not considered. For example,
 ``` cpp
 class A {
   class B { };
 public:
   typedef B BB;
 };
 void f() {
-  A::BB x;          // OK, typedef name A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
 — *end note*]
-[*Note 3*: Access to members and base classes is controlled, not their
-visibility [[basic.scope.hiding]]. Names of members are still visible,
-and implicit conversions to base classes are still considered, when
-those members and base classes are inaccessible. — *end note*]
 The interpretation of a given construct is established without regard to
 access control. If the interpretation established makes use of
-inaccessible member names or base classes, the construct is ill-formed.
-All access controls in [[class.access]] affect the ability to access a
-class member name from the declaration of a particular entity, including
 parts of the declaration preceding the name of the entity being declared
 and, if the entity is a class, the definitions of members of the class
 appearing outside the class’s *member-specification*.
-[*Note 4*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
-[*Example 2*:
 ``` cpp
 class A {
   typedef int I;    // private member
   I f();
@@ -3867,21 +3626,20 @@ is as the return type of a member of class `A`. Similarly, the use of
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 — *end example*]
-The names in a default argument [[dcl.fct.default]] are bound at the
-point of declaration, and access is checked at that point rather than at
-any points of use of the default argument. Access checking for default
-arguments in function templates and in member functions of class
-templates is performed as described in  [[temp.inst]].
-The names in a default *template-argument* [[temp.param]] have their
-access checked in the context in which they appear rather than at any
-points of use of the default *template-argument*.
-[*Example 3*:
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
@@ -3896,12 +3654,12 @@ D <C<B> >* d;       // access error, C::TT is protected
 — *end example*]
 ### Access specifiers <a id="class.access.spec">[[class.access.spec]]</a>
-Member declarations can be labeled by an *access-specifier* (
-[[class.derived]]):
 ``` bnf
 access-specifier ':' member-specificationₒₚₜ
 ```
@@ -3939,13 +3697,10 @@ public:
 };
 ```
 — *end example*]
-[*Note 1*: The effect of access control on the order of allocation of
-data members is specified in  [[expr.rel]]. — *end note*]
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
 [*Example 3*:
@@ -3960,11 +3715,11 @@ private:
 };
 ```
 — *end example*]
-[*Note 2*: In a derived class, the lookup of a base class name will
 find the injected-class-name instead of the name of the base class in
 the scope in which it was declared. The injected-class-name might be
 less accessible than the name of the base class in the scope in which it
 was declared. — *end note*]
@@ -4019,17 +3774,17 @@ Here `B` is a public base of `D2`, `D4`, and `D6`, a private base of
 — *end example*]
 [*Note 1*:
-A member of a private base class might be inaccessible as an inherited
-member name, 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 might 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
@@ -4048,24 +3803,24 @@ void DD::f() {
   b.mi = 3;                     // OK (b.mi is different from this->mi)
   b.si = 3;                     // OK (b.si is different from this->si)
   ::B::si = 3;                  // OK
   ::B* bp1 = this;              // error: B is a private base class
   ::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
-- *R* occurs in a member or friend of class `N`, and an invented public
-  member of `B` would be a private or protected member of `N`, or
-- *R* occurs in a member or friend of a class `P` derived from `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*:
@@ -4089,20 +3844,20 @@ class N: private S {
 ```
 — *end example*]
 If a base class is accessible, one can implicitly convert a pointer to a
-derived class to a pointer to that base class ([[conv.ptr]],
-[[conv.mem]]).
 [*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 which the member name was
-looked up and found.
 [*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
@@ -4111,15 +3866,15 @@ 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 member or
-  friend of class `N`, or
-- `m` as a member of `N` is protected, and *R* occurs in a 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;
@@ -4128,11 +3883,11 @@ A member `m` is accessible at the point *R* when named in class `N` if
     int i;
     friend void f(B*);
   };
   class B : public A { };
   void f(B* p) {
-    p->i = 1;         // OK: B* can be implicitly converted to A*, and f has access to i in A
   }
   ```
   — *end example*]
@@ -4146,14 +3901,14 @@ to the naming class of the right operand.
 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
-use the private and protected member names from the class. A class
-specifies its friends, if any, by way of friend declarations. Such
-declarations give special access rights to the friends, but they do not
-make the nominated friends members of the befriending class.
 [*Example 1*:
 The following example illustrates the differences between members and
 friends:
@@ -4176,26 +3931,26 @@ void f() {
 }
 ```
 — *end example*]
-Declaring a class to be a friend implies that the names of private and
-protected members from the class granting friendship can be accessed in
-the *base-specifier*s and member declarations of the befriended class.
 [*Example 2*:
 ``` cpp
 class A {
   class B { };
   friend class X;
 };
-struct X : A::B {               // OK: A::B accessible to friend
-  A::B mx;                      // OK: A::B accessible to member of friend
   class Y {
-    A::B my;                    // OK: A::B accessible to nested member of friend
   };
 };
 ```
 — *end example*]
@@ -4217,74 +3972,62 @@ class Z {
 };
 ```
 — *end example*]
-A class shall not be defined in a friend declaration.
-[*Example 4*:
-``` cpp
-class A {
-  friend class B { };           // error: cannot define class in friend declaration
-};
-```
-— *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 may 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 5*:
 ``` cpp
 class C;
 typedef C Ct;
 class X1 {
-  friend C;                     // OK: class C is a friend
 };
 class X2 {
-  friend Ct;                    // OK: class C is a friend
-  friend D;                     // error: no type-name D in scope
-  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]],
-[[namespace.memdef]]). Otherwise, the function retains its previous
-linkage [[dcl.stc]].
-When a friend declaration refers to an overloaded name or operator, only
-the function specified by the parameter types becomes a friend. A member
-function of a class `X` can be a friend of a class `Y`.
-[*Example 6*:
 ``` cpp
 class Y {
   friend char* X::foo(int);
   friend X::X(char);            // constructors can be friends
@@ -4292,15 +4035,17 @@ class Y {
 };
 ```
 — *end example*]
-A function can be defined in a friend declaration of a class if and only
-if the class is a non-local class [[class.local]], the function name is
-unqualified, and the function has namespace scope.
-[*Example 7*:
 ``` cpp
 class M {
   friend void f() { }           // definition of global f, a friend of M,
                                 // not the definition of a member function
@@ -4308,26 +4053,27 @@ class M {
 ```
 — *end example*]
 Such a function is implicitly an inline [[dcl.inline]] function if it is
-attached to the global module. A friend function defined in a class is
-in the (lexical) scope of the class in which it is defined. A friend
-function defined outside the class is not [[basic.lookup.unqual]].
 No *storage-class-specifier* shall appear in the *decl-specifier-seq* of
 a friend declaration.
-A name nominated by a friend declaration shall be accessible in the
-scope of the class containing the friend declaration. The meaning of the
-friend declaration is the same whether the friend declaration appears in
-the private, protected, or public [[class.mem]] portion of the class
 *member-specification*.
 Friendship is neither inherited nor transitive.
-[*Example 8*:
 ``` cpp
 class A {
   friend class B;
   int a;
@@ -4350,19 +4096,48 @@ class D : public B  {
 };
 ```
 — *end example*]
-If a friend declaration appears in a local class [[class.local]] and the
-name specified is an unqualified name, a prior declaration is looked up
-without considering scopes that are outside the innermost enclosing
-non-class scope. For a friend function declaration, if there is no prior
-declaration, the program is ill-formed. For a friend class declaration,
-if there is no prior declaration, the class that is specified belongs to
-the innermost enclosing non-class scope, but if it is subsequently
-referenced, its name is not found by name lookup until a matching
-declaration is provided in the innermost enclosing non-class scope.
 [*Example 9*:
 ``` cpp
 class X;
@@ -4388,17 +4163,19 @@ 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 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`. All other accesses involve a (possibly implicit)
-object expression [[expr.ref]]. In this case, the class of the object
-expression shall be `C` or a class derived from `C`.
 [*Example 1*:
 ``` cpp
 class B {
@@ -4468,11 +4245,11 @@ private:
 void f() {
   D d;
   B* pb = &d;
   D* pd = &d;
-  pb->f();                      // OK: B::f() is public, D::f() is invoked
   pd->f();                      // error: D::f() is private
 }
 ```
 — *end example*]
@@ -4482,12 +4259,13 @@ used to denote the object for which the member function is called (`B*`
 in the example above). The access of the member function in the class in
 which it was defined (`D` in the example above) is in general not known.
 ### Multiple access <a id="class.paths">[[class.paths]]</a>
-If a name can be reached by several paths through a multiple inheritance
-graph, the access is that of the path that gives most access.
 [*Example 1*:
 ``` cpp
 class W { public: void f(); };
@@ -4516,14 +4294,14 @@ shall be obeyed.
 class E {
   int x;
   class B { };
   class I {
-    B b;                        // OK: E::I can access E::B
     int y;
     void f(E* p, int i) {
-      p->x = i;                 // OK: E::I can access E::x
     }
   };
   int g(I* p) {
     return p->y;                // error: I::y is private
@@ -4533,10 +4311,12 @@ class E {
 — *end example*]
 ## Initialization <a id="class.init">[[class.init]]</a>
 When no initializer is specified for an object of (possibly
 cv-qualified) class type (or array thereof), or the initializer has the
 form `()`, the object is initialized as specified in  [[dcl.init]].
 An object of class type (or array thereof) can be explicitly
@@ -4596,11 +4376,11 @@ complex v[6] = { 1, complex(1,2), complex(), 2 };
 ```
 Here, `complex::complex(double)` is called for the initialization of
 `v[0]` and `v[3]`, `complex::complex({}double, double)` is called for
 the initialization of `v[1]`, `complex::complex()` is called for the
-initialization `v[2]`, `v[4]`, and `v[5]`. For another example,
 ``` cpp
 struct X {
   int i;
   float f;
@@ -4653,20 +4433,18 @@ mem-initializer:
 mem-initializer-id:
     class-or-decltype
     identifier
 ```
-In a *mem-initializer-id* an initial unqualified *identifier* is looked
-up in the scope of the constructor’s class and, if not found in that
-scope, it is looked up in the scope containing the constructor’s
-definition.
 [*Note 1*: If the constructor’s class contains a member with the same
 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 may 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.
@@ -4685,11 +4463,11 @@ C::C(): global_A() { }          // mem-initializer for base A
 ```
 — *end example*]
 If a *mem-initializer-id* is ambiguous because it designates both a
-direct non-virtual base class and an inherited virtual base class, the
 *mem-initializer* is ill-formed.
 [*Example 2*:
 ``` cpp
@@ -4773,14 +4551,15 @@ struct A {
 };
 ```
 — *end example*]
-In a non-delegating constructor, if a given potentially constructed
-subobject is not designated by a *mem-initializer-id* (including the
-case where there is no *mem-initializer-list* because the constructor
-has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
   initializer [[class.mem]] and either
   - the constructor’s class is a union [[class.union]], and no other
     variant member of that union is designated by a *mem-initializer-id*
@@ -4795,11 +4574,11 @@ has no *ctor-initializer*), then
   [[class.union.anon]], no initialization is performed;
 - otherwise, the entity is default-initialized [[dcl.init]].
 [*Note 3*: An abstract class [[class.abstract]] is never a most derived
 class, thus its constructors never initialize virtual base classes,
-therefore the corresponding *mem-initializer*s may be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
@@ -4821,14 +4600,14 @@ struct B {
   B(int);
 };
 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*]
@@ -4934,13 +4713,14 @@ B b(3);             // use V()
 C c(4);             // use V()
 ```
 — *end example*]
-Names in the *expression-list* or *braced-init-list* of a
-*mem-initializer* are evaluated in the scope of the constructor for
-which the *mem-initializer* is specified.
 [*Example 10*:
 ``` cpp
 class X {
@@ -4959,15 +4739,10 @@ of the constructor parameter `i`, initializes `X::i` with the value of
 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*]
-[*Note 7*: Because the *mem-initializer* are evaluated in the scope of
-the constructor, the `this` pointer can be used in the *expression-list*
-of a *mem-initializer* to refer to the object being
-initialized. — *end note*]
 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
@@ -5004,11 +4779,11 @@ public:
 };
 ```
 — *end example*]
-[*Note 8*:  [[class.cdtor]] describes the result of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
 well-defined cases; that is, describes the polymorphic behavior of an
 object under construction. — *end note*]
 A *mem-initializer* followed by an ellipsis is a pack expansion
@@ -5058,28 +4833,28 @@ struct D1 : B1 {
   int x;
   int y = get();
 };
 void test() {
-  D1 d(2, 3, 4);    // OK: B1 is initialized by calling B1(2, 3, 4),
                     // then d.x is default-initialized (no initialization is performed),
                     // then d.y is initialized by calling get()
-  D1 e;             // error: D1 has a deleted default constructor
 }
 struct D2 : B2 {
   using B2::B2;
   B1 b;
 };
-D2 f(1.0);          // error: B1 has a deleted default constructor
 struct W { W(int); };
 struct X : virtual W { using W::W; X() = delete; };
 struct Y : X { using X::X; };
 struct Z : Y, virtual W { using Y::Y; };
-Z z(0);             // OK: initialization of Y does not invoke default constructor of X
 template<class T> struct Log : T {
   using T::T;       // inherits all constructors from class T
   ~Log() { std::clog << "Destroying wrapper" << std::endl; }
 };
@@ -5115,18 +4890,18 @@ struct D2 : V1, V2 {
   using V1::V1;
   using V2::V2;
 };
 D1 d1(0);           // error: ambiguous
-D2 d2(0);           // OK: initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
 struct O : M {};
 struct P : N, O { using N::N; using O::O; };
-P p(0);             // OK: use M(0) to initialize N's base class,
                     // use M() to initialize O's base class
 ```
 — *end example*]
@@ -5357,13 +5132,15 @@ 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*
@@ -5371,14 +5148,14 @@ combined to eliminate multiple copies):
   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) whose scope does not extend beyond
- the end of the innermost enclosing *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
@@ -5394,12 +5171,12 @@ combined to eliminate multiple copies):
 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*: Copy elision might be performed if the same expression is
-evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
 class Thing {
@@ -5428,54 +5205,25 @@ constexpr A g() {
 constexpr A a;          // well-formed, a.p points to a
 constexpr A b = g();    // error: b.p would be dangling[expr.const]
 void h() {
-  A c = g();            // well-formed, c.p may point to c or to an ephemeral temporary
 }
 ```
 Here the criteria for elision can eliminate the copying of the object
 `t` with automatic storage duration into the result object for the
-function call `f()`, which is the global object `t2`. Effectively, the
-construction of the local object `t` can be viewed as directly
-initializing the global object `t2`, and that object’s destruction will
-occur at program exit. Adding a move constructor to `Thing` has the same
-effect, but it is the move construction from the object with automatic
-storage duration to `t2` that is elided.
 — *end example*]
-An *implicitly movable entity* is a variable of automatic storage
-duration that is either a non-volatile object or an rvalue reference to
-a non-volatile object type. In the following copy-initialization
-contexts, a move operation might be used instead of a copy operation:
-- If the *expression* in a `return` [[stmt.return]] or `co_return`
-  [[stmt.return.coroutine]] statement is a (possibly parenthesized)
-  *id-expression* that names an implicitly movable entity declared in
-  the body or *parameter-declaration-clause* of the innermost enclosing
-  function or *lambda-expression*, or
-- if the operand of a *throw-expression* [[expr.throw]] is a (possibly
-  parenthesized) *id-expression* that names an implicitly movable entity
-  whose scope does not extend beyond the *compound-statement* of the
-  innermost *try-block* or *function-try-block* (if any) whose
-  *compound-statement* or *ctor-initializer* encloses the
-  *throw-expression*,
-overload resolution to select the constructor for the copy or the
-`return_value` overload to call is first performed as if the expression
-or operand were an rvalue. If the first overload resolution fails or was
-not performed, overload resolution is performed again, considering the
-expression or operand as an lvalue.
-[*Note 3*: This two-stage overload resolution must be performed
-regardless of whether copy elision will occur. It determines the
-constructor or the `return_value` overload to be called if elision is
-not performed, and the selected constructor or `return_value` overload
-must be accessible even if the call is elided. — *end note*]
 [*Example 2*:
 ``` cpp
 class Thing {
 public:
@@ -5487,24 +5235,44 @@ private:
 };
 Thing f(bool b) {
   Thing t;
   if (b)
-    throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
-  return t;             // OK: Thing(Thing&&) used (or elided) to return t
 }
-Thing t2 = f(false);    // OK: no extra copy/move performed, t2 constructed by call to f
 struct Weird {
   Weird();
   Weird(Weird&);
 };
-Weird g() {
-  Weird w;
- return w;             // OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
 }
 ```
 — *end example*]
@@ -5538,23 +5306,19 @@ template<class T> void f() {
 ### 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 const non-volatile member of `C` having one parameter of
- type `const C&` and either no *ref-qualifier* or the *ref-qualifier*
-  `&`, or
-- a friend of `C` having either two parameters of type `const C&` or two
-  parameters of type `C`.
-A comparison operator function for class `C` that is defaulted on its
-first declaration and is not defined as deleted is *implicitly defined*
-when it is odr-used or needed for constant evaluation. Name lookups in
-the defaulted definition 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]].
@@ -5563,47 +5327,28 @@ A binary operator expression `a @ b` is *usable* if either
 - `a` or `b` is of class or enumeration type and overload resolution
   [[over.match]] as applied to `a @ b` results in a usable candidate, or
 - neither `a` nor `b` is of class or enumeration type and `a @ b` is a
   valid expression.
-A defaulted comparison function is *constexpr-compatible* if it
-satisfies the requirements for a constexpr function [[dcl.constexpr]]
-and no overload resolution performed when determining whether to delete
-the function results in a usable candidate that is a non-constexpr
-function.
-[*Note 1*:
-This includes the overload resolutions performed:
-- for an `operator<=>` whose return type is not `auto`, when determining
-  whether a synthesized three-way comparison is defined,
-- for an `operator<=>` whose return type is `auto` or for an
-  `operator==`, for a comparison between an element of the expanded list
-  of subobjects and itself, or
-- for a secondary comparison operator `@`, for the expression `x @ y`.
-— *end note*]
 If the *member-specification* does not explicitly declare any member or
 friend named `operator==`, an `==` operator function is declared
 implicitly for each three-way comparison operator function defined as
 defaulted in the *member-specification*, with the same access and
 *function-definition* and in the same class scope as the respective
 three-way comparison operator function, except that the return type is
 replaced with `bool` and the *declarator-id* is replaced with
 `operator==`.
-[*Note 2*: Such an implicitly-declared `==` operator for a class `X` is
 defined as defaulted in the definition of `X` and has the same
 *parameter-declaration-clause* and trailing *requires-clause* as the
 respective three-way comparison operator. It is declared with `friend`,
 `virtual`, `constexpr`, or `consteval` if the three-way comparison
 operator function is so declared. If the three-way comparison operator
 function has no *noexcept-specifier*, the implicitly-declared `==`
 operator function has an implicit exception specification
-[[except.spec]] that may differ from the implicit exception
 specification of the three-way comparison operator
 function. — *end note*]
 [*Example 1*:
@@ -5617,11 +5362,11 @@ template<typename T> struct X {
 };
 ```
 — *end example*]
-[*Note 3*: The `==` operator function is declared implicitly even if
 the defaulted three-way comparison operator function is defined as
 deleted. — *end note*]
 The direct base class subobjects of `C`, in the order of their
 declaration in the *base-specifier-list* of `C`, followed by the
@@ -5667,12 +5412,12 @@ struct D {
 ### Three-way comparison <a id="class.spaceship">[[class.spaceship]]</a>
 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]],
-  `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
@@ -5695,13 +5440,13 @@ glvalues `a` and `b` of the same type is defined as follows:
   a < b  ? partial_ordering::less :
   b < a  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
-[*Note 1*: A synthesized three-way comparison may be ill-formed if
-overload resolution finds usable candidates that do not otherwise meet
-the requirements implied by the defined expression. — *end note*]
 Let `R` be the declared return type of a defaulted three-way comparison
 operator function, and let `xᵢ` be the elements of the expanded list of
 subobjects for an object `x` of type `C`.
@@ -5765,184 +5510,35 @@ struct C {
 };
 ```
 — *end example*]
-## Free store <a id="class.free">[[class.free]]</a>
-Any allocation function for a class `T` is a static member (even if not
-explicitly declared `static`).
-[*Example 1*:
-``` cpp
-class Arena;
-struct B {
-  void* operator new(std::size_t, Arena*);
-};
-struct D1 : B {
-};
-Arena*  ap;
-void foo(int i) {
-  new (ap) D1;      // calls B::operator new(std::size_t, Arena*)
-  new D1[i];        // calls ::operator new[](std::size_t)
-  new D1;           // error: ::operator new(std::size_t) hidden
-}
-```
-— *end example*]
-When an object is deleted with a *delete-expression* [[expr.delete]], a
-deallocation function (`operator delete()` for non-array objects or
-`operator delete[]()` for arrays) is (implicitly) called to reclaim the
-storage occupied by the object [[basic.stc.dynamic.deallocation]].
-Class-specific deallocation function lookup is a part of general
-deallocation function lookup [[expr.delete]] and occurs as follows. If
-the *delete-expression* is used to deallocate a class object whose
-static type has a virtual destructor, the deallocation function is the
-one selected at the point of definition of the dynamic type’s virtual
-destructor [[class.dtor]].[^15] Otherwise, if the *delete-expression* is
-used to deallocate an object of class `T` or array thereof, the
-deallocation function’s name is looked up in the scope of `T`. If this
-lookup fails to find the name, general deallocation function lookup
-[[expr.delete]] continues. If the result of the lookup is ambiguous or
-inaccessible, or if the lookup selects a placement deallocation
-function, the program is ill-formed.
-Any deallocation function for a class `X` is a static member (even if
-not explicitly declared `static`).
-[*Example 2*:
-``` cpp
-class X {
-  void operator delete(void*);
-  void operator delete[](void*, std::size_t);
-};
-class Y {
-  void operator delete(void*, std::size_t);
-  void operator delete[](void*);
-};
-```
-— *end example*]
-Since member allocation and deallocation functions are `static` they
-cannot be virtual.
-[*Note 1*:
-However, when the *cast-expression* of a *delete-expression* refers to
-an object of class type, because the deallocation function actually
-called is looked up in the scope of the class that is the dynamic type
-of the object if the destructor is virtual, the effect is the same in
-that case. For example,
-``` cpp
-struct B {
-  virtual ~B();
-  void operator delete(void*, std::size_t);
-};
-struct D : B {
-  void operator delete(void*);
-};
-struct E : B {
-  void log_deletion();
-  void operator delete(E *p, std::destroying_delete_t) {
-    p->log_deletion();
-    p->~E();
-    ::operator delete(p);
-  }
-};
-void f() {
-  B* bp = new D;
-  delete bp;        // 1: uses D::operator delete(void*)
-  bp = new E;
-  delete bp;        // 2: uses E::operator delete(E*, std::destroying_delete_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 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);
-};
-struct D : B {
-  void operator delete[](void*, std::size_t);
-};
-void f(int i) {
-  D* dp = new D[i];
-  delete [] dp;     // uses D::operator delete[](void*, std::size_t)
-  B* bp = new D[i];
-  delete[] bp;      // undefined behavior
-}
-```
-— *end note*]
-Access to the deallocation function is checked statically. Hence, even
-though a different one might actually be executed, the statically
-visible deallocation function is required to be accessible.
-[*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
-[[except.spec]]. — *end note*]
 <!-- Link reference definitions -->
 [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.lookup.qual]: basic.md#basic.lookup.qual
-[basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: expr.md#basic.lval
-[basic.scope]: basic.md#basic.scope
 [basic.scope.class]: basic.md#basic.scope.class
-[basic.scope.hiding]: basic.md#basic.scope.hiding
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
 [basic.start.term]: basic.md#basic.start.term
-[basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
-[basic.stc.dynamic]: basic.md#basic.stc.dynamic
-[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
-[basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [class]: #class
 [class.abstract]: #class.abstract
 [class.access]: #class.access
 [class.access.base]: #class.access.base
 [class.access.nest]: #class.access.nest
 [class.access.spec]: #class.access.spec
 [class.access.virt]: #class.access.virt
 [class.base.init]: #class.base.init
 [class.bit]: #class.bit
@@ -5951,45 +5547,50 @@ have been ill-formed. — *end example*]
 [class.compare.default]: #class.compare.default
 [class.compare.secondary]: #class.compare.secondary
 [class.conv]: #class.conv
 [class.conv.ctor]: #class.conv.ctor
 [class.conv.fct]: #class.conv.fct
 [class.copy.assign]: #class.copy.assign
 [class.copy.ctor]: #class.copy.ctor
 [class.copy.elision]: #class.copy.elision
 [class.ctor]: #class.ctor
 [class.default.ctor]: #class.default.ctor
 [class.derived]: #class.derived
 [class.dtor]: #class.dtor
 [class.eq]: #class.eq
 [class.expl.init]: #class.expl.init
 [class.free]: #class.free
 [class.friend]: #class.friend
 [class.inhctor.init]: #class.inhctor.init
 [class.init]: #class.init
 [class.local]: #class.local
 [class.mem]: #class.mem
-[class.member.lookup]: #class.member.lookup
 [class.mfct]: #class.mfct
-[class.mfct.non-static]: #class.mfct.non-static
 [class.mi]: #class.mi
 [class.name]: #class.name
 [class.nest]: #class.nest
-[class.nested.type]: #class.nested.type
 [class.paths]: #class.paths
 [class.pre]: #class.pre
 [class.prop]: #class.prop
 [class.protected]: #class.protected
 [class.qual]: basic.md#class.qual
 [class.spaceship]: #class.spaceship
 [class.static]: #class.static
 [class.static.data]: #class.static.data
 [class.static.mfct]: #class.static.mfct
 [class.temporary]: basic.md#class.temporary
-[class.this]: #class.this
 [class.union]: #class.union
 [class.union.anon]: #class.union.anon
 [class.virtual]: #class.virtual
 [cmp.categories]: support.md#cmp.categories
 [cmp.categories.pre]: support.md#cmp.categories.pre
 [cmp.partialord]: support.md#cmp.partialord
 [cmp.strongord]: support.md#cmp.strongord
@@ -6004,19 +5605,23 @@ have been ill-formed. — *end example*]
 [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.fct.def.delete]: dcl.md#dcl.fct.def.delete
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.fct.spec]: dcl.md#dcl.fct.spec
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.inline]: dcl.md#dcl.inline
 [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
 [dcl.type.simple]: dcl.md#dcl.type.simple
@@ -6051,44 +5656,46 @@ have been ill-formed. — *end example*]
 [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.def]: dcl.md#namespace.def
-[namespace.memdef]: dcl.md#namespace.memdef
 [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.load]: over.md#over.load
 [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
-[stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [string.classes]: strings.md#string.classes
 [temp.arg]: temp.md#temp.arg
-[temp.class.spec]: temp.md#temp.class.spec
 [temp.constr]: temp.md#temp.constr
 [temp.constr.order]: temp.md#temp.constr.order
 [temp.dep.type]: temp.md#temp.dep.type
 [temp.expl.spec]: temp.md#temp.expl.spec
 [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]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^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]].
@@ -6109,23 +5716,23 @@ have been ill-formed. — *end example*]
 [^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 though its internal representation might 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
@@ -6146,10 +5753,5 @@ have been ill-formed. — *end example*]
     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.
-[^15]: A similar provision is not needed for the array version of
-    `operator` `delete` because  [[expr.delete]] requires that in this
-    situation, the static type of the object to be deleted be the same
-    as its dynamic type.

     union
 ```
 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.
 If a *class-head-name* contains a *nested-name-specifier*, the
+*class-specifier* shall not inhabit a class scope. If its *class-name*
+is an *identifier*, the *class-specifier* shall correspond to one or
+more declarations nominable in the class, class template, or namespace
+to which the *nested-name-specifier* refers; they shall all have the
+same target scope, and the target scope of the *class-specifier* is that
+scope.
+[*Example 1*:
+``` cpp
+namespace N {
+  template<class>
+  struct A {
+    struct B;
+  };
+}
+using N::A;
+template<class T> struct A<T>::B {};    // OK
+template<> struct A<void> {};           // OK
+```
+— *end example*]
 [*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*]
 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*]
 ## Properties of classes <a id="class.prop">[[class.prop]]</a>
 A *trivially copyable class* is a class:
 - that has at least one eligible copy constructor, move constructor,
+  copy assignment operator, or move assignment operator
+  [[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
 - 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
     member of `X` (where said member may be an anonymous union), the set
     M(X) consists of X₀ and the elements of M(X₀).
   - If `X` is a union type, the set M(X) is the union of all M(Uᵢ) and
 — *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
+- it has at least one trivial eligible constructor and a trivial,
+  non-deleted destructor.
 ## Class names <a id="class.name">[[class.name]]</a>
 A class definition introduces a new type.
 ``` cpp
 int f(X);
 int f(Y);
 ```
+declare overloads [[over]] named `f` and not simply a single function
+`f` twice. For the same reason,
 ``` cpp
 struct S { int a; };
 struct S { int a; };            // error: double definition
 ```
 is ill-formed because it defines `S` twice.
 — *end example*]
+[*Note 1*:
+It can be necessary to use an *elaborated-type-specifier* to refer to a
+class that belongs to a scope in which its name is also bound to a
+variable, function, or enumerator [[basic.lookup.elab]].
 [*Example 2*:
 ``` cpp
 struct stat {
   // ...
 };
 stat gstat;                     // use plain stat to define variable
+int stat(struct stat*);         // stat now also names a function
 void f() {
   struct stat* ps;              // struct prefix needed to name struct stat
+  stat(ps);                     // call stat function
 }
 ```
 — *end example*]
+An *elaborated-type-specifier* can also be used to declare an
+*identifier* as a *class-name*.
 [*Example 3*:
 ``` cpp
 struct s { int a; };
 }
 ```
 — *end example*]
 Such declarations allow definition of classes that refer to each other.
 [*Example 4*:
 ``` cpp
 — *end note*]
 [*Note 2*: An *elaborated-type-specifier* [[dcl.type.elab]] can also be
 used as a *type-specifier* as part of a declaration. It differs from a
+class declaration in that it can refer to an existing class of the given
+name. — *end note*]
 [*Example 5*:
 ``` cpp
 struct s { int a; };
 A *simple-template-id* is only a *class-name* if its *template-name*
 names a class template.
 ## Class members <a id="class.mem">[[class.mem]]</a>
+### General <a id="class.mem.general">[[class.mem.general]]</a>
 ``` bnf
 member-specification:
     member-declaration member-specificationₒₚₜ
     access-specifier ':' member-specificationₒₚₜ
 ```
 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
 *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*,
   defined, and
 - an enumeration can be introduced with an *opaque-enum-declaration* and
   later redeclared with an *enum-specifier*.
 [*Note 3*: A single name can denote several member functions provided
+their types are sufficiently different
+[[basic.scope.scope]]. — *end note*]
+A redeclaration of a class member outside its class definition shall be
+a definition, an explicit specialization, or an explicit instantiation
+[[temp.expl.spec]], [[temp.explicit]]. The member shall not be a
+non-static data member.
+A *complete-class context* of a class (template) is a
 - 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*.
 [*Example 1*:
 ``` cpp
 struct S {
   using T = void();
+  T * p = 0;        // OK, brace-or-equal-initializer
+  virtual T f = 0;  // OK, pure-specifier
 };
 ```
 — *end example*]
 non-static data members, see  [[class.base.init]] and
 [[dcl.init.aggr]]). A *brace-or-equal-initializer* for a non-static data
 member specifies a *default member initializer* for the member, and
 shall not directly or indirectly cause the implicit definition of a
 defaulted default constructor for the enclosing class or the exception
+specification of that constructor. An immediate invocation
+[[expr.const]] that is a potentially-evaluated subexpression
+[[intro.execution]] of a default member initializer is neither evaluated
+nor checked for whether it is a constant expression at the point where
+the subexpression appears.
 A member shall not be declared with the `extern`
 *storage-class-specifier*. Within a class definition, a member shall not
 be declared with the `thread_local` *storage-class-specifier* unless
 also declared `static`.
 A *virt-specifier-seq* shall contain at most one of each
 *virt-specifier*. A *virt-specifier-seq* shall appear only in the first
 declaration of a virtual member function [[class.virtual]].
 The type of a non-static data member shall not be an incomplete type
+[[term.incomplete.type]], an abstract class type [[class.abstract]], or
+a (possibly multidimensional) array thereof.
 [*Note 5*: In particular, a class `C` cannot contain a non-static
 member of class `C`, but it can contain a pointer or reference to an
 object of class `C`. — *end note*]
 pointer of the object `s`; and `s.right->tword[0]` refers to the initial
 character of the `tword` member of the `right` subtree of `s`.
 — *end example*]
+[*Note 8*:  Non-variant non-static data members of non-zero size
+[[intro.object]] are allocated so that later members have higher
+addresses within a class object [[expr.rel]]. Implementation alignment
+requirements can cause two adjacent members not to be allocated
+immediately after each other; so can requirements for space for managing
+virtual functions [[class.virtual]] and virtual base classes
 [[class.mi]]. — *end note*]
 If `T` is the name of a class, then each of the following shall have a
 name different from `T`:
 - 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 addition, if class `T` has a user-declared constructor
 [[class.ctor]], every non-static data member of class `T` shall have a
 name different from `T`.
 The *common initial sequence* of two standard-layout struct
 [[class.prop]] types is the longest sequence of non-static data members
 and bit-fields in declaration order, starting with the first such entity
+in each of the structs, such that
+- corresponding entities have layout-compatible types [[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*:
 ``` cpp
 struct A { int a; char b; };
 classes* if their common initial sequence comprises all members and
 bit-fields of both classes [[basic.types]].
 Two standard-layout unions are layout-compatible if they have the same
 number of non-static data members and corresponding non-static data
+members (in any order) have layout-compatible types
+[[term.layout.compatible.type]].
 In a standard-layout union with an active member [[class.union]] of
 struct type `T1`, it is permitted to read a non-static data member `m`
 of another union member of struct type `T2` provided `m` is part of the
 common initial sequence of `T1` and `T2`; the behavior is as if the
 If a standard-layout class object has any non-static data members, its
 address is the same as the address of its first non-static data member
 if that member is not a bit-field. Its address is also the same as the
 address of each of its base class subobjects.
+[*Note 11*: There can therefore be unnamed padding within a
 standard-layout struct object inserted by an implementation, but not at
 its beginning, as necessary to achieve appropriate
 alignment. — *end note*]
 [*Note 12*: The object and its first subobject are
+pointer-interconvertible
+[[basic.compound]], [[expr.static.cast]]. — *end note*]
 ### 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 1*: A member function is also inline if it is declared `inline`,
 `constexpr`, or `consteval`. — *end note*]
 [*Example 1*:
 ``` cpp
 struct X {
   typedef int T;
   void f(T);
 };
 void X::f(T t = count) { }
 ```
+The definition of the member function `f` of class `X` inhabits the
+global scope; the notation `X::f` indicates that the function `f` is a
+member of class `X` and in the scope of class `X`. In the function
+definition, the parameter type `T` refers to the typedef member `T`
+declared in class `X` and the default argument `count` refers to the
+static data member `count` declared in class `X`.
 — *end example*]
 Member functions of a local class shall be defined inline in their class
 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,
 Also see  [[temp.arg]].
 — *end note*]
+### Non-static member functions <a id="class.mfct.non.static">[[class.mfct.non.static]]</a>
 A non-static member function may be called for an object of its class
 type, or for an object of a class derived [[class.derived]] from its
+class type, using the class member access syntax
+[[expr.ref]], [[over.match.call]]. A non-static member function may also
+be called directly using the function call syntax
+[[expr.call]], [[over.match.call]] from within its class or a class
+derived from its class, or a member thereof, as described below.
+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
 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>
 Default constructors [[class.default.ctor]], copy constructors, move
 constructors [[class.copy.ctor]], copy assignment operators, move
 assignment operators [[class.copy.assign]], and prospective destructors
 [[class.dtor]] are *special member functions*.
 [*Note 1*: The implementation will implicitly declare these member
 functions for some class types when the program does not explicitly
+declare them. The implementation will implicitly define them as needed
+[[dcl.fct.def.default]]. — *end note*]
 An implicitly-declared special member function is declared at the
 closing `}` of the *class-specifier*. Programs shall not define
 implicitly-declared special member functions.
 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>
+#### General <a id="class.ctor.general">[[class.ctor.general]]</a>
+A *declarator* declares a *constructor* if it is a function declarator
+[[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
+- in a friend declaration [[class.friend]], the *id-expression* is a
+ *qualified-id* that names a constructor [[class.qual]];
+- otherwise, in a *member-declaration* that belongs to the
+ *member-specification* of a class or class template, the
+  *id-expression* is the injected-class-name [[class.pre]] of the
+ immediately-enclosing entity;
+- otherwise, the *id-expression* is a *qualified-id* whose
+  *unqualified-id* is the injected-class-name of its lookup context.
 Constructors do not have names. In a constructor declaration, each
 *decl-specifier* in the optional *decl-specifier-seq* shall be `friend`,
+`inline`, `constexpr`, `consteval`, or an *explicit-specifier*.
 [*Example 1*:
 ``` cpp
 struct S {
 S::S() { }          // defines the constructor
 ```
 — *end example*]
+A constructor is used to initialize objects of its class type.
+[*Note 1*: Because constructors do not have names, they are never found
+during unqualified name lookup; however an explicit type conversion
+using the functional notation [[expr.type.conv]] will cause a
+constructor to be called to initialize an object. The syntax looks like
+an explicit call of the constructor. — *end note*]
 [*Example 2*:
 ``` cpp
 complex zz = complex(1,2.3);
 A constructor can be invoked for a `const`, `volatile` or `const`
 `volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
 not applied on an object under construction. They come into effect when
 the constructor for the most derived object [[intro.object]] ends.
+The address of a constructor shall not be taken.
+[*Note 6*: A `return` statement in the body of a constructor cannot
+specify a return value [[stmt.return]]. — *end note*]
 A constructor shall not be a coroutine.
+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
   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>
 — *end example*]
 [*Note 1*:
+All forms of copy/move constructor can be declared for a class.
 [*Example 3*:
 ``` cpp
 struct X {
 If the class definition does not explicitly declare a copy constructor,
 a non-explicit one is declared *implicitly*. If the class definition
 declares a move constructor or move assignment operator, the implicitly
 declared copy constructor is defined as deleted; otherwise, it is
+defaulted [[dcl.fct.def]]. The latter case is deprecated if the class
+has a user-declared copy assignment operator or a user-declared
+destructor [[depr.impldec]].
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
 if each potentially constructed subobject of a class type `M` (or array
 thereof) has a copy constructor whose first parameter is of type `const`
+`M&` or `const` `volatile` `M&`.[^3]
+Otherwise, the implicitly-declared copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 - `X` does not have a user-declared move assignment operator, and
 - `X` does not have a user-declared destructor.
 [*Note 3*: When the move constructor is not implicitly declared or
 explicitly supplied, expressions that otherwise would have invoked the
+move constructor might instead invoke a copy constructor. — *end note*]
 The implicitly-declared move constructor for class `X` will have the
 form
 ``` cpp
 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:
   thereof), the constructor selected to copy/move that member is
   trivial;
 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.
 Virtual base class subobjects shall be initialized only once by the
 implicitly-defined copy/move constructor (see  [[class.base.init]]).
 The implicitly-defined copy/move constructor for a union `X` copies the
+object representation [[term.object.representation]] of `X`. For each
+object nested within [[intro.object]] the object that is the source of
+the copy, a corresponding object o nested within the destination is
+identified (if the object is a subobject) or created (otherwise), and
+the lifetime of o begins before the copy is performed.
 ### Copy/move assignment operator <a id="class.copy.assign">[[class.copy.assign]]</a>
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
+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
 — *end note*]
 If the class definition does not explicitly declare a copy assignment
 operator, one is declared *implicitly*. If the class definition declares
 a move constructor or move assignment operator, the implicitly declared
+copy assignment operator is defined as deleted; otherwise, it is
+defaulted [[dcl.fct.def]]. The latter case is deprecated if the class
 has a user-declared copy constructor or a user-declared destructor
 [[depr.impldec]]. The implicitly-declared copy assignment operator for a
 class `X` will have the form
 ``` cpp
 ``` cpp
 X& X::operator=(X&)
 ```
 A user-declared move assignment operator `X::operator=` is a non-static
+non-template member function of class `X` with exactly one 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
 ``` cpp
 X& X::operator=(X&&)
 ```
 The implicitly-declared copy/move assignment operator for class `X` has
+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
   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
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 otherwise the copy/move assignment operator is *non-trivial*.
+An implicitly-defined [[dcl.fct.def.default]] copy/move assignment
+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
 assigned twice by the implicitly-defined copy/move assignment operator
 for `C`.
 — *end example*]
+The implicitly-defined copy/move assignment operator for a union `X`
+copies the object representation [[term.object.representation]] of `X`.
+If the source and destination of the assignment are not the same object,
+then for each object nested within [[intro.object]] the object that is
+the source of the copy, a corresponding object o nested within the
+destination is created, and the lifetime of o begins before the copy is
+performed.
+The implicitly-defined copy/move assignment operator for a class returns
+the object for which the assignment operator is invoked, that is, the
+object assigned to.
 ### Destructors <a id="class.dtor">[[class.dtor]]</a>
+A declaration whose *declarator-id* has an *unqualified-id* that begins
+with a `~` declares a *prospective destructor*; its *declarator* shall
+be a function declarator [[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 - in a *member-declaration* that belongs to the *member-specification*
   of a class or class template but is not a friend declaration
   [[class.friend]], the *id-expression* is `~`*class-name* and the
   *class-name* is the injected-class-name [[class.pre]] of the
   immediately-enclosing entity or
+- otherwise, the *id-expression* is *nested-name-specifier*
+ `~`*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`.
 At the end of the definition of a class, overload resolution is
 performed among the prospective destructors declared in that class with
 an empty argument list to select the *destructor* for the class, also
 known as the *selected destructor*. The program is ill-formed if
 overload resolution fails. Destructor selection does not constitute a
+reference to, or odr-use [[term.odr.use]] of, the selected destructor,
 and in particular, the selected destructor may be deleted
 [[dcl.fct.def.delete]].
+The address of a destructor shall not be taken.
+[*Note 1*: A `return` statement in the body of a destructor cannot
+specify a return value [[stmt.return]]. — *end note*]
+A destructor can be invoked for a `const`, `volatile` or `const`
+`volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
+not applied on an object under destruction. They stop being in effect
+when the destructor for the most derived object [[intro.object]] starts.
+[*Note 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:
   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.
+A prospective destructor can be declared `virtual` [[class.virtual]] and
+with a *pure-specifier* [[class.abstract]]. If the destructor of a class
+is virtual and any objects of that class or any derived class are
+created in the program, the destructor shall be defined.
+[*Note 3*:  Some language constructs have special semantics when used
 during destruction; see  [[class.cdtor]]. — *end note*]
 After executing the body of the destructor and destroying any objects
 with automatic storage duration allocated within the body, a destructor
 for class `X` calls the destructors for `X`’s direct non-variant
 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*]
+Destructors for elements of an array are called in reverse order of
+their construction (see  [[class.init]]).
 A destructor is invoked implicitly
 - for a constructed object with static storage duration
   [[basic.stc.static]] at program termination [[basic.start.term]],
 - for a constructed object with thread storage duration
   [[basic.stc.thread]] at thread exit,
 - for a constructed object with automatic storage duration
   [[basic.stc.auto]] when the block in which an object is created exits
   [[stmt.dcl]],
+- for a constructed temporary object when its lifetime ends
+  [[conv.rval]], [[class.temporary]].
 In each case, the context of the invocation is the context of the
 construction of the object. A destructor may also be invoked implicitly
 through use of a *delete-expression* [[expr.delete]] for a constructed
 object allocated by a *new-expression* [[expr.new]]; the context of the
 invocation is the *delete-expression*.
+[*Note 5*: An array of class type contains several subobjects for each
 of which the destructor is invoked. — *end note*]
 A destructor can also be invoked explicitly. A destructor is
 *potentially invoked* if it is invoked or as specified in  [[expr.new]],
 [[stmt.return]], [[dcl.init.aggr]], [[class.base.init]], and
 [[except.throw]]. A program is ill-formed if a destructor that is
 potentially invoked is deleted or not accessible from the context of the
 invocation.
 At the point of definition of a virtual destructor (including an
+implicit definition), the non-array deallocation function is determined
+as if for the expression `delete this` appearing in a non-virtual
+destructor of the destructor’s class (see  [[expr.delete]]). If the
+lookup fails or if the deallocation function has a deleted definition
+[[dcl.fct.def]], the program is ill-formed.
+[*Note 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
 the usual rules for member functions [[class.mfct]]; that is, if the
 object is not of the destructor’s class type and not of a class derived
 from the destructor’s class type (including when the destructor is
 invoked via a null pointer value), the program has undefined behavior.
+[*Note 7*: Invoking `delete` on a null pointer does not call the
 destructor; see [[expr.delete]]. — *end note*]
 [*Example 1*:
 ``` cpp
 }
 ```
 — *end example*]
+[*Note 8*: An explicit destructor call must always be written using a
 member access operator [[expr.ref]] or a *qualified-id*
 [[expr.prim.id.qual]]; in particular, the *unary-expression* `~X()` in a
 member function is not an explicit destructor call
 [[expr.unary.op]]. — *end note*]
+[*Note 9*:
 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
 }
 ```
 — *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*:
 The notation for explicit call of a destructor can be used for any
 scalar type name [[expr.prim.id.dtor]]. Allowing this makes it possible
 to write code without having to know if a destructor exists for a given
 type. For example:
 A destructor shall not be a coroutine.
 ### Conversions <a id="class.conv">[[class.conv]]</a>
+#### General <a id="class.conv.general">[[class.conv.general]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
 conversions* and are used for implicit type conversions [[conv]], for
+initialization [[dcl.init]], and for explicit type conversions
+[[expr.type.conv]], [[expr.cast]], [[expr.static.cast]].
+User-defined conversions are applied only where they are unambiguous
+[[class.member.lookup]], [[class.conv.fct]]. Conversions obey the access
+control rules [[class.access]]. Access control is applied after
 ambiguity resolution [[basic.lookup]].
 [*Note 1*: See  [[over.match]] for a discussion of the use of
 conversions in function calls as well as examples below. — *end note*]
   operator X();
 };
 Y a;
 int b = a;          // error: no viable conversion (a.operator X().operator int() not considered)
+int c = X(a);       // OK, a.operator X().operator int()
 ```
 — *end example*]
 #### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
 [*Note 1*:
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax
+[[dcl.init]] or where casts [[expr.static.cast]], [[expr.cast]] are
 explicitly used; see also  [[over.match.copy]]. A default constructor
+can be an explicit constructor; such a constructor will be used to
 perform default-initialization or value-initialization [[dcl.init]].
 [*Example 2*:
 ``` cpp
   explicit Z();
   explicit Z(int);
   explicit Z(int, int);
 };
+Z a;                            // OK, default-initialization performed
+Z b{};                          // OK, direct initialization syntax used
 Z c = {};                       // error: copy-list-initialization
 Z a1 = 1;                       // error: no implicit conversion
+Z a3 = Z(1);                    // OK, direct initialization syntax used
+Z a2(1);                        // OK, direct initialization syntax used
+Z* p = new Z(1);                // OK, direct initialization syntax used
+Z a4 = (Z)1;                    // OK, explicit cast used
+Z a5 = static_cast<Z>(1);       // OK, explicit cast used
 Z a6 = { 3, 4 };                // error: no implicit conversion
 ```
 — *end example*]
 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
 ```
 ``` bnf
 conversion-declarator:
     ptr-operator 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 {
 struct Z {
   explicit operator Y() const;
 };
 void h(Z z) {
+  Y y1(z);          // OK, direct-initialization
   Y y2 = z;         // error: no conversion function candidate for copy-initialization
+  Y y3 = (Y)z;      // OK, cast notation
 }
 void g(X a, X b) {
   int i = (a) ? 1+a : 0;
   int j = (a&&b) ? a+b : i;
 — *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
+hides and is hidden as a non-template function. Function overload
+resolution [[over.match.best]] selects the best conversion function to
+perform the conversion.
+[*Example 5*:
+``` cpp
+struct X {
+  operator int();
+};
+struct Y : X {
+    operator char();
+};
+void f(Y& a) {
+  if (a) {          // error: ambiguous between X::operator int() and Y::operator char()
+  }
+}
+```
+— *end example*]
+— *end note*]
 Conversion functions can be virtual.
 A conversion function template shall not have a deduced return type
 [[dcl.spec.auto]].
+[*Example 6*:
 ``` cpp
 struct S {
   operator auto() const { return 10; }      // OK
   template<class T>
 — *end example*]
 ### Static members <a id="class.static">[[class.static]]</a>
+#### General <a id="class.static.general">[[class.static.general]]</a>
 A static member `s` of class `X` may be referred to using the
 *qualified-id* expression `X::s`; it is not necessary to use the class
 member access syntax [[expr.ref]] to refer to a static member. A static
 member may be referred to using the class member access syntax, in which
 case the object expression is evaluated.
   static void reschedule();
 };
 process& g();
 void f() {
+  process::reschedule();        // OK, no object necessary
   g().reschedule();             // g() is called
 }
 ```
 — *end example*]
 Static members obey the usual class member access rules
 [[class.access]]. When used in the declaration of a class member, the
 `static` specifier shall only be used in the member declarations that
 appear within the *member-specification* of the class definition.
 [*Note 1*: The rules described in  [[class.mfct]] apply to static
 member functions. — *end note*]
 [*Note 2*: A static member function does not have a `this` pointer
+[[expr.prim.this]]. A static member function cannot be qualified with
+`const`, `volatile`, or `virtual` [[dcl.fct]]. — *end note*]
 #### Static data members <a id="class.static.data">[[class.static.data]]</a>
 A static data member is not part of the subobjects of a class. If a
 static data member is declared `thread_local` there is one copy of the
 [[class.pre]] or local [[class.local]] class or of a (possibly
 indirectly) nested class [[class.nest]] thereof.
 The declaration of a non-inline static data member in its class
 definition is not a definition and may be of an incomplete type other
+than cv `void`.
+[*Note 1*: The *initializer* in the definition of a static data member
+is in the scope of its class [[basic.scope.class]]. — *end note*]
 [*Example 1*:
 ``` cpp
 class process {
 process* process::running = get_main();
 process* process::run_chain = running;
 ```
+The definition of the static data member `run_chain` of class `process`
+inhabits the global scope; the notation `process::run_chain` indicates
+that the member `run_chain` is a member of class `process` and in the
+scope of class `process`. In the static data member definition, the
+*initializer* expression refers to the static data member `running` of
+class `process`.
 — *end example*]
+[*Note 2*:
 Once the static data member has been defined, it exists even if no
 objects of its class have been created.
 [*Example 2*:
 In the example above, `run_chain` and `running` exist even if no objects
 of class `process` are created by the program.
 — *end example*]
+The initialization and destruction of static data members is described
+in [[basic.start.static]], [[basic.start.dynamic]], and
+[[basic.start.term]].
 — *end note*]
 If a non-volatile non-inline `const` static data member is of integral
 or enumeration type, its declaration in the class definition can specify
 a *brace-or-equal-initializer* in which every *initializer-clause* that
 is an *assignment-expression* is a constant expression [[expr.const]].
 The member shall still be defined in a namespace scope if it is odr-used
+[[term.odr.use]] in the program and the namespace scope definition shall
+not contain an *initializer*. The declaration of an inline static data
+member (which is a definition) may specify a
 *brace-or-equal-initializer*. If the member is declared with the
 `constexpr` specifier, it may be redeclared in namespace scope with no
 initializer (this usage is deprecated; see [[depr.static.constexpr]]).
 Declarations of other static data members shall not specify a
 *brace-or-equal-initializer*.
+[*Note 3*: There is exactly one definition of a static data member that
+is odr-used [[term.odr.use]] in a valid program. — *end note*]
+[*Note 4*: Static data members of a class in namespace scope have the
 linkage of the name of the class [[basic.link]]. — *end note*]
 ### Bit-fields <a id="class.bit">[[class.bit]]</a>
 A *member-declarator* of the form
 ``` bnf
 identifierₒₚₜ attribute-specifier-seqₒₚₜ ':' constant-expression brace-or-equal-initializerₒₚₜ
 ```
 specifies a bit-field. The optional *attribute-specifier-seq* appertains
 to the entity being declared. A bit-field shall not be a static member.
+A bit-field shall have integral or (possibly cv-qualified) enumeration
+type; the bit-field semantic property is not part of the type of the
+class member. The *constant-expression* shall be an integral constant
+expression with a value greater than or equal to zero and is called the
+*width* of the bit-field. If the width of a bit-field is larger than the
+width of the bit-field’s type (or, in case of an enumeration type, of
+its underlying type), the extra bits are padding bits
+[[term.padding.bits]]. Allocation of bit-fields within a class object is
+*implementation-defined*. Alignment of bit-fields is
+*implementation-defined*. Bit-fields are packed into some addressable
+allocation unit.
 [*Note 1*: Bit-fields straddle allocation units on some machines and
 not on others. Bit-fields are assigned right-to-left on some machines,
 left-to-right on others. — *end note*]
 As a special case, an unnamed bit-field with a width of zero specifies
 alignment of the next bit-field at an allocation unit boundary. Only
 when declaring an unnamed bit-field may the width be zero.
 The address-of operator `&` shall not be applied to a bit-field, so
+there are no pointers to bit-fields. A non-const reference shall not
+bind to a bit-field [[dcl.init.ref]].
 [*Note 3*: If the initializer for a reference of type `const` `T&` is
 an lvalue that refers to a bit-field, the reference is bound to a
 temporary initialized to hold the value of the bit-field; the reference
 is not bound to the bit-field directly. See
 }
 ```
 — *end example*]
+### Allocation and deallocation functions <a id="class.free">[[class.free]]</a>
+Any allocation function for a class `T` is a static member (even if not
+explicitly declared `static`).
+[*Example 1*:
+``` cpp
+class Arena;
+struct B {
+  void* operator new(std::size_t, Arena*);
+};
+struct D1 : B {
+};
+Arena*  ap;
+void foo(int i) {
+  new (ap) D1;      // calls B::operator new(std::size_t, Arena*)
+  new D1[i];        // calls ::operator new[](std::size_t)
+  new D1;           // error: ::operator new(std::size_t) hidden
+}
+```
+— *end example*]
+Any deallocation function for a class `X` is a static member (even if
+not explicitly declared `static`).
+[*Example 2*:
+``` cpp
+class X {
+  void operator delete(void*);
+  void operator delete[](void*, std::size_t);
+};
+class Y {
+  void operator delete(void*, std::size_t);
+  void operator delete[](void*);
+};
+```
+— *end example*]
+Since member allocation and deallocation functions are `static` they
+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);
+};
+struct D : B {
+  void operator delete(void*);
+};
+struct E : B {
+  void log_deletion();
+  void operator delete(E *p, std::destroying_delete_t) {
+    p->log_deletion();
+    p->~E();
+    ::operator delete(p);
+  }
+};
+void f() {
+  B* bp = new D;
+  delete bp;        // 1: uses D::operator delete(void*)
+  bp = new E;
+  delete bp;        // 2: uses E::operator delete(E*, std::destroying_delete_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 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);
+};
+struct D : B {
+  void operator delete[](void*, std::size_t);
+};
+void f(int i) {
+  D* dp = new D[i];
+  delete [] dp;     // uses D::operator delete[](void*, std::size_t)
+  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
+[[except.spec]]. — *end note*]
 ### Nested class declarations <a id="class.nest">[[class.nest]]</a>
 A class can be declared within another class. A class declared within
+another is called a *nested class*.
 [*Note 1*: See  [[expr.prim.id]] for restrictions on the use of
 non-static data members and non-static member functions. — *end note*]
 [*Example 1*:
   int x;
   static int s;
   struct inner {
     void f(int i) {
+      int a = sizeof(x);        // OK, operand of sizeof is an unevaluated operand
       x = i;                    // error: assign to enclose::x
+      s = i;                    // OK, assign to enclose::s
+      ::x = i;                  // OK, assign to global x
+      y = i;                    // OK, assign to global y
     }
     void g(enclose* p, int i) {
+      p->x = i;                 // OK, assign to enclose::x
     }
   };
 };
+inner* p = 0;                   // error: inner not found
 ```
 — *end example*]
+[*Note 2*:
+Nested classes can be defined either in the enclosing class or in an
+enclosing namespace; member functions and static data members of a
+nested class can be defined either in the nested class or in an
+enclosing namespace scope.
 [*Example 2*:
 ``` cpp
 struct enclose {
 };
 int enclose::inner::x = 1;
 void enclose::inner::f(int i) { ... }
 class E {
   class I1;                     // forward declaration of nested class
   class I2;
   class I1 { };                 // definition of nested class
 };
 class E::I2 { };                // definition of nested class
 ```
 — *end example*]
+— *end note*]
+A friend function [[class.friend]] defined within a nested class has no
+special access rights to members of an enclosing class.
 ## Unions <a id="class.union">[[class.union]]</a>
+### General <a id="class.union.general">[[class.union.general]]</a>
 A *union* is a class defined with the *class-key* `union`.
 In a union, a non-static data member is *active* if its name refers to
 an object whose lifetime has begun and has not ended [[basic.life]]. At
 most one of the non-static data members of an object of union type can
 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.
 [*Note 2*: A union object and its non-static data members are
+pointer-interconvertible [[basic.compound]], [[expr.static.cast]]. As a
+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:
 operator, and destructor. To use `U`, some or all of these member
 functions must be user-provided.
 — *end example*]
+— *end note*]
 When the left operand of an assignment operator involves a member access
 expression [[expr.ref]] that nominates a union member, it may begin the
 lifetime of that union member, as described below. For an expression
 `E`, define the set S(E) of subexpressions of `E` as follows:
 union A { int x; int y[4]; };
 struct B { A a; };
 union C { B b; int k; };
 int f() {
   C c;                  // does not start lifetime of any union member
+  c.b.a.y[3] = 4;       // OK, S(c.b.a.y[3]) contains c.b and c.b.a.y;
                         // creates objects to hold union members c.b and c.b.a.y
+  return c.b.a.y[3];    // OK, c.b.a.y refers to newly created object (see [basic.life])
 }
 struct X { const int a; int b; };
 union Y { X x; int k; };
 void g() {
   Y y = { { 1, 2 } };   // OK, y.x is active union member[class.mem]
   int n = y.x.a;
+  y.k = 4;              // OK, ends lifetime of y.x, y.k is active member of union
   y.x.b = n;            // undefined behavior: y.x.b modified outside its lifetime,
                         // S(y.x.b) is empty because X's default constructor is deleted,
                         // so union member y.x's lifetime does not implicitly start
 }
 ```
 — *end example*]
+[*Note 5*: In cases where the above rule does not apply, the active
+member of a union can only be changed by the use of a placement
+*new-expression*. — *end note*]
 [*Example 3*:
 Consider an object `u` of a `union` type `U` having non-static data
 members `m` of type `M` and `n` of type `N`. If `M` has a non-trivial
 ``` bnf
 union '{' member-specification '}' ';'
 ```
 is called an *anonymous union*; it defines an unnamed type and an
+unnamed object of that type called an *anonymous union member* if it is
+a non-static data member or an *anonymous union variable* otherwise.
+Each *member-declaration* in the *member-specification* of an anonymous
+union shall either define one or more public non-static data members or
+be a *static_assert-declaration*. Nested types, anonymous unions, and
 functions shall not be declared within an anonymous union. The names of
+the members of an anonymous union are bound in the scope inhabited by
+the union declaration.
 [*Example 1*:
 ``` cpp
 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.
 [*Example 2*:
 visible outside the union, and even if it were visible, it is not
 associated with any particular object.
 — *end example*]
+— *end note*]
+[*Note 2*: Initialization of unions with no user-declared constructors
 is described in  [[dcl.init.aggr]]. — *end note*]
 A *union-like class* is a union or a class that has an anonymous union
 as a direct member. A union-like class `X` has a set of *variant
 members*. If `X` is a union, a non-static data member of `X` that is not
 — *end example*]
 ## Local class declarations <a id="class.local">[[class.local]]</a>
 A class can be declared within a function definition; such a class is
+called a *local class*.
 [*Note 1*: A declaration in a local class cannot odr-use
+[[term.odr.use]] a local entity from an enclosing scope. — *end note*]
 [*Example 1*:
 ``` cpp
 int x;
   struct local {
     int g() { return x; }       // error: odr-use of non-odr-usable variable x
     int h() { return s; }       // OK
     int k() { return ::x; }     // OK
     int l() { return q(); }     // OK
+    int m() { return N; }       // OK, not an odr-use
     int* n() { return &N; }     // error: odr-use of non-odr-usable variable N
     int p() { return y; }       // error: odr-use of non-odr-usable structured binding y
   };
 }
+local* p = 0;                   // error: local not found
 ```
 — *end example*]
 An enclosing function has no special access to members of the local
 [*Note 2*: A local class cannot have static data members
 [[class.static.data]]. — *end note*]
 ## Derived classes <a id="class.derived">[[class.derived]]</a>
+### General <a id="class.derived.general">[[class.derived.general]]</a>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
 base-clause:
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
+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.
+[*Note 2*: Constructors of a base class can be explicitly inherited
+[[namespace.udecl]]. Base class members can be referred to in
+expressions in the same manner as other members of the derived class,
+unless their names are hidden or ambiguous [[class.member.lookup]]. The
+scope resolution operator `::` [[expr.prim.id.qual]] can be used to
+refer to a direct or indirect base member explicitly, even if it is
+hidden in the derived class. A derived class can itself serve as a base
+class subject to access control; see  [[class.access.base]]. A pointer
+to a derived class can be implicitly converted to a pointer to an
+accessible unambiguous base class [[conv.ptr]]. An lvalue of a derived
+class type can be bound to a reference to an accessible unambiguous base
+class [[dcl.init.ref]]. — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
 “directly derived from” (see Figure [[fig:class.dag]]). An arrow
 need not have a physical representation in memory. A DAG of subobjects
+is often referred to as a “subobject lattice”. — *end note*]
 <a id="fig:class.dag"></a>
 ![Directed acyclic graph \[fig:class.dag\]](images/figdag.svg)
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
+[*Note 5*: A base class subobject can have a layout different from the
+layout of a most derived object of the same type. A base class subobject
+can have a polymorphic behavior [[class.cdtor]] different from the
+polymorphic behavior of a most derived object of the same type. A base
+class subobject can be of zero size; however, two subobjects that have
+the same class type and that belong to the same most derived object
+cannot be allocated at the same address [[intro.object]]. — *end note*]
 ### Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
 specified by the semantics of initialization by constructor
+[[class.base.init]], cleanup [[class.dtor]], and storage layout
+[[class.mem]], [[class.access.spec]]. — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
 be a direct and an indirect base class. There are limited things that
+can be done with such a class; lookup that finds its non-static data
+members and member functions in the scope of the derived class will be
+ambiguous. However, the static members, enumerations and types can be
+unambiguously referred to. — *end note*]
 [*Example 2*:
 ``` cpp
 class X { ... };
 <a id="fig:class.nonvirt"></a>
 ![Non-virtual base \[fig:class.nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
+subobject is meant. The body of function `C::f` can refer to the member
+`next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
 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 {
 ``` cpp
 struct A { virtual void f(); };
 struct B : A { };
 struct C : A { void f(); };
+struct D : B, C { };            // OK, A::f and C::f are the final overriders
                                 // for the B and C subobjects, respectively
 ```
 — *end example*]
 [[dcl.decl]].
 [*Example 5*:
 ``` cpp
+template<typename T>
 struct A {
   virtual void f() requires true;       // error: virtual function cannot be constrained[temp.constr.decl]
 };
 ```
 — *end example*]
+The *ref-qualifier*, or lack thereof, of an overriding function shall be
+the same as that of the overridden function.
 The return type of an overriding function shall be either identical to
 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
   as or less cv-qualification than the class type in the return type of
   `B::f`.
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
+complete at the locus [[basic.scope.pdecl]] of the overriding
+declaration or shall be the class type `D`. When the overriding function
+is called as the final overrider of the overridden function, its result
+is converted to the type returned by the (statically chosen) overridden
+function [[expr.call]].
 [*Example 6*:
 ``` cpp
 class B { };
 class A;
 struct Derived : public Base {
     void vf1();     // virtual and overrides Base::vf1()
     void vf2(int);  // not virtual, hides Base::vf2()
     char vf3();     // error: invalid difference in return type only
+    D*   vf4();     // OK, returns pointer to derived class
     A*   vf5();     // error: returns pointer to incomplete class
     void f();
 };
 void g() {
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
 function cannot be a non-member [[dcl.fct.spec]] function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
+virtual function declared in one class can be declared a friend
+[[class.friend]] in another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
 pure [[class.abstract]] in that class, or both; no diagnostic is
 required [[basic.def.odr]].
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
+A deleted function [[dcl.fct.def]] shall not override a function that is
+not deleted. Likewise, a function that is not deleted shall not override
+a deleted function.
 A `consteval` virtual function shall not override a virtual function
 that is not `consteval`. A `consteval` virtual function shall not be
 overridden by a virtual function that is not `consteval`.
 A class is an *abstract class* if it has at least one pure virtual
 function.
 [*Note 3*: An abstract class can be used only as a base class of some
 other class; no objects of an abstract class can be created except as
+subobjects of a class derived from it
+[[basic.def]], [[class.mem]]. — *end note*]
 A pure virtual function need be defined only if called with, or as if
 with [[class.dtor]], the *qualified-id* syntax [[expr.prim.id.qual]].
 [*Example 1*:
 [*Note 5*: An abstract class type cannot be used as a parameter or
 return type of a function being defined [[dcl.fct]] or called
 [[expr.call]], except as specified in [[dcl.type.simple]]. Further, an
 abstract class type cannot be used as the type of an explicit type
+conversion
+[[expr.static.cast]], [[expr.reinterpret.cast]], [[expr.const.cast]],
+because the resulting prvalue would be of abstract class type
+[[basic.lval]]. However, pointers and references to abstract class types
+can appear in such contexts. — *end note*]
+A class is abstract if it has at least one pure virtual function for
+which the final overrider is pure virtual.
 [*Example 3*:
 ``` cpp
 class ab_circle : public shape {
 `circle::draw()` must be provided.
 — *end example*]
 [*Note 6*: An abstract class can be derived from a class that is not
+abstract, and a pure virtual function can override a virtual function
 which is not pure. — *end note*]
 Member functions can be called from a constructor (or destructor) of an
 abstract class; the effect of making a virtual call [[class.virtual]] to
 a pure virtual function directly or indirectly for the object being
 created (or destroyed) from such a constructor (or destructor) is
 undefined.
 ## Member access control <a id="class.access">[[class.access]]</a>
+### General <a id="class.access.general">[[class.access.general]]</a>
 A member of a class can be
+- private, that is, it can be named only by members and friends of the
+  class in which it is declared;
+- protected, that is, it can be named only by members and friends of the
+  class in which it is declared, by classes derived from that class, and
+  by their friends (see  [[class.protected]]); or
+- public, that is, it can be named anywhere without access restriction.
+[*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.
 };
 ```
 — *end example*]
+Access control is applied uniformly to declarations and expressions.
+[*Note 2*: Access control applies to members nominated by friend
 declarations [[class.friend]] and *using-declaration*s
 [[namespace.udecl]]. — *end note*]
+When a *using-declarator* is named, access control is applied to it, not
+to the declarations that replace it. For an overload set, access control
+is applied only to the function selected by overload resolution.
+[*Example 2*:
+``` cpp
+struct S {
+  void f(int);
+private:
+  void f(double);
+};
+void g(S* sp) {
+  sp->f(2);         // OK, access control applied after overload resolution
+}
+```
+— *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:
   typedef B BB;
 };
 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*]
 The interpretation of a given construct is established without regard to
 access control. If the interpretation established makes use of
+inaccessible members or base classes, the construct is ill-formed.
+All access controls in [[class.access]] affect the ability to name a
+class member from the declaration of a particular entity, including
 parts of the declaration preceding the name of the entity being declared
 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();
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 — *end example*]
+Access is checked for a default argument [[dcl.fct.default]] at the
+point of declaration, rather than at any points of use of the default
+argument. Access checking for default arguments in function templates
+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:
 — *end example*]
 ### Access specifiers <a id="class.access.spec">[[class.access.spec]]</a>
+Member declarations can be labeled by an *access-specifier*
+[[class.derived]]:
 ``` bnf
 access-specifier ':' member-specificationₒₚₜ
 ```
 };
 ```
 — *end example*]
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
 [*Example 3*:
 };
 ```
 — *end example*]
+[*Note 1*: In a derived class, the lookup of a base class name will
 find the injected-class-name instead of the name of the base class in
 the scope in which it was declared. The injected-class-name might be
 less accessible than the name of the base class in the scope in which it
 was declared. — *end note*]
 — *end example*]
 [*Note 1*:
+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
   b.mi = 3;                     // OK (b.mi is different from this->mi)
   b.si = 3;                     // OK (b.si is different from this->si)
   ::B::si = 3;                  // OK
   ::B* bp1 = this;              // error: B is a private base class
   ::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
+- *R* occurs in a direct member or friend of class `N`, and an invented
+ public member of `B` would be a private or protected member of `N`, or
+- *R* occurs in a direct member or friend of a class `P` derived from
+ `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*:
 ```
 — *end example*]
 If a base class is accessible, one can implicitly convert a pointer to a
+derived class to a pointer to that base class
+[[conv.ptr]], [[conv.mem]].
 [*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
 *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;
     int i;
     friend void f(B*);
   };
   class B : public A { };
   void f(B* p) {
+    p->i = 1;         // OK, B* can be implicitly converted to A*, and f has access to i in A
   }
   ```
   — *end example*]
 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
+its friends, if any, by way of friend declarations. Such declarations
+give special access rights to the friends, but they do not make the
+nominated friends members of the befriending class.
 [*Example 1*:
 The following example illustrates the differences between members and
 friends:
 }
 ```
 — *end example*]
+Declaring a class to be a friend implies that private and protected
+members of the class granting friendship can be named in the
+*base-specifier*s and member declarations of the befriended class.
 [*Example 2*:
 ``` cpp
 class A {
   class B { };
   friend class X;
 };
+struct X : A::B {               // OK, A::B accessible to friend
+  A::B mx;                      // OK, A::B accessible to member of friend
   class Y {
+    A::B my;                    // OK, A::B accessible to nested member of friend
   };
 };
 ```
 — *end example*]
 };
 ```
 — *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
 };
 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`.
+[*Example 5*:
 ``` cpp
 class Y {
   friend char* X::foo(int);
   friend X::X(char);            // constructors can be friends
 };
 ```
 — *end example*]
+— *end note*]
+A function may be defined in a friend declaration of a class if and only
+if the class is a non-local class [[class.local]] and the function name
+is unqualified.
+[*Example 6*:
 ``` cpp
 class M {
   friend void f() { }           // definition of global f, a friend of M,
                                 // not the definition of a member function
 ```
 — *end example*]
 Such a function is implicitly an inline [[dcl.inline]] function if it is
+attached to the global module.
+[*Note 3*: If a friend function is defined outside a class, it is not
+in the scope of the class. — *end note*]
 No *storage-class-specifier* shall appear in the *decl-specifier-seq* of
 a friend declaration.
+A member nominated by a friend declaration shall be accessible in the
+class containing the friend declaration. The meaning of the friend
+declaration is the same whether the friend declaration appears in the
+private, protected, or public [[class.mem]] portion of the class
 *member-specification*.
 Friendship is neither inherited nor transitive.
+[*Example 7*:
 ``` cpp
 class A {
   friend class B;
   int a;
 };
 ```
 — *end example*]
+[*Note 4*: A friend declaration never binds any names
+[[dcl.meaning]], [[dcl.type.elab]]. — *end note*]
+[*Example 8*:
+``` cpp
+// Assume f and g have not yet been declared.
+void h(int);
+template <class T> void f2(T);
+namespace A {
+  class X {
+    friend void f(X);           // A::f(X) is a friend
+    class Y {
+      friend void g();          // A::g is a friend
+      friend void h(int);       // A::h is a friend
+                                // ::h not considered
+      friend void f2<>(int);    // ::f2<>(int) is a friend
+    };
+  };
+  // A::f, A::g and A::h are not visible here
+  X x;
+  void g() { f(x); }            // definition of A::g
+  void f(X) { ... }       // definition of A::f
+  void h(int) { ... }     // definition of A::h
+  // A::f, A::g and A::h are visible here and known to be friends
+}
+using A::x;
+void h() {
+  A::f(x);
+  A::X::f(x);                   // error: f is not a member of A::X
+  A::X::Y::g();                 // error: g is not a member of A::X::Y
+}
+```
+— *end example*]
 [*Example 9*:
 ``` cpp
 class X;
 ### 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`.
+All other accesses involve a (possibly implicit) object expression
+[[expr.ref]]. In this case, the class of the object expression shall be
+`C` or a class derived from `C`.
 [*Example 1*:
 ``` cpp
 class B {
 void f() {
   D d;
   B* pb = &d;
   D* pd = &d;
+  pb->f();                      // OK, B::f() is public, D::f() is invoked
   pd->f();                      // error: D::f() is private
 }
 ```
 — *end example*]
 in the example above). The access of the member function in the class in
 which it was defined (`D` in the example above) is in general not known.
 ### Multiple access <a id="class.paths">[[class.paths]]</a>
+If a declaration can be reached by several paths through a multiple
+inheritance graph, the access is that of the path that gives most
+access.
 [*Example 1*:
 ``` cpp
 class W { public: void f(); };
 class E {
   int x;
   class B { };
   class I {
+    B b;                        // OK, E::I can access E::B
     int y;
     void f(E* p, int i) {
+      p->x = i;                 // OK, E::I can access E::x
     }
   };
   int g(I* p) {
     return p->y;                // error: I::y is private
 — *end example*]
 ## Initialization <a id="class.init">[[class.init]]</a>
+### General <a id="class.init.general">[[class.init.general]]</a>
 When no initializer is specified for an object of (possibly
 cv-qualified) class type (or array thereof), or the initializer has the
 form `()`, the object is initialized as specified in  [[dcl.init]].
 An object of class type (or array thereof) can be explicitly
 ```
 Here, `complex::complex(double)` is called for the initialization of
 `v[0]` and `v[3]`, `complex::complex({}double, double)` is called for
 the initialization of `v[1]`, `complex::complex()` is called for the
+initialization of `v[2]`, `v[4]`, and `v[5]`. For another example,
 ``` cpp
 struct X {
   int i;
   float f;
 mem-initializer-id:
     class-or-decltype
     identifier
 ```
+Lookup for an unqualified name in a *mem-initializer-id* ignores the
+constructor’s function parameter scope.
 [*Note 1*: If the constructor’s class contains a member with the same
 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.
 ```
 — *end example*]
 If a *mem-initializer-id* is ambiguous because it designates both a
+direct non-virtual base class and an indirect virtual base class, the
 *mem-initializer* is ill-formed.
 [*Example 2*:
 ``` cpp
 };
 ```
 — *end example*]
+In a non-delegating constructor other than an implicitly-defined
+copy/move constructor [[class.copy.ctor]], if a given potentially
+constructed subobject is not designated by a *mem-initializer-id*
+(including the case where there is no *mem-initializer-list* because the
+constructor has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
   initializer [[class.mem]] and either
   - the constructor’s class is a union [[class.union]], and no other
     variant member of that union is designated by a *mem-initializer-id*
   [[class.union.anon]], no initialization is performed;
 - otherwise, the entity is default-initialized [[dcl.init]].
 [*Note 3*: An abstract class [[class.abstract]] is never a most derived
 class, thus its constructors never initialize virtual base classes,
+therefore the corresponding *mem-initializer*s can be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
   B(int);
 };
 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*]
 C c(4);             // use V()
 ```
 — *end example*]
+[*Note 7*: The *expression-list* or *braced-init-list* of a
+*mem-initializer* is in the function parameter scope of the constructor
+and can use `this` to refer to the object being
+initialized. — *end note*]
 [*Example 10*:
 ``` cpp
 class X {
 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
 };
 ```
 — *end example*]
+[*Note 8*:  [[class.cdtor]] describes the results of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
 well-defined cases; that is, describes the polymorphic behavior of an
 object under construction. — *end note*]
 A *mem-initializer* followed by an ellipsis is a pack expansion
   int x;
   int y = get();
 };
 void test() {
+  D1 d(2, 3, 4);    // OK, B1 is initialized by calling B1(2, 3, 4),
                     // then d.x is default-initialized (no initialization is performed),
                     // then d.y is initialized by calling get()
+  D1 e;             // error: D1 has no default constructor
 }
 struct D2 : B2 {
   using B2::B2;
   B1 b;
 };
+D2 f(1.0);          // error: B1 has no default constructor
 struct W { W(int); };
 struct X : virtual W { using W::W; X() = delete; };
 struct Y : X { using X::X; };
 struct Z : Y, virtual W { using Y::Y; };
+Z z(0);             // OK, initialization of Y does not invoke default constructor of X
 template<class T> struct Log : T {
   using T::T;       // inherits all constructors from class T
   ~Log() { std::clog << "Destroying wrapper" << std::endl; }
 };
   using V1::V1;
   using V2::V2;
 };
 D1 d1(0);           // error: ambiguous
+D2 d2(0);           // OK, initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
 struct O : M {};
 struct P : N, O { using N::N; using O::O; };
+P p(0);             // OK, use M(0) to initialize N's base class,
                     // use M() to initialize O's base class
 ```
 — *end example*]
 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*
   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
 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
 class Thing {
 constexpr A a;          // well-formed, a.p points to a
 constexpr A b = g();    // error: b.p would be dangling[expr.const]
 void h() {
+  A c = g();            // well-formed, c.p can point to c or be dangling
 }
 ```
 Here the criteria for elision can eliminate the copying of the object
 `t` with automatic storage duration into the result object for the
+function call `f()`, which is the non-local object `t2`. Effectively,
+the construction of `t` can be viewed as directly initializing `t2`, and
+that object’s destruction will occur at program exit. Adding a move
+constructor to `Thing` has the same effect, but it is the move
+construction from the object with automatic storage duration to `t2`
+that is elided.
 — *end example*]
 [*Example 2*:
 ``` cpp
 class Thing {
 public:
 };
 Thing f(bool b) {
   Thing t;
   if (b)
+    throw t;            // OK, Thing(Thing&&) used (or elided) to throw t
+  return t;             // OK, Thing(Thing&&) used (or elided) to return t
 }
+Thing t2 = f(false);    // OK, no extra copy/move performed, t2 constructed by call to f
 struct Weird {
   Weird();
   Weird(Weird&);
 };
+Weird g(bool b) {
+ static Weird w1;
+ Weird w2;
+  if (b)
+    return w1;  // OK, uses Weird(Weird&)
+  else
+    return w2;  // error: w2 in this context is an xvalue
+}
+int& h(bool b, int i) {
+  static int s;
+  if (b)
+    return s;   // OK
+  else
+    return i;   // error: i is an xvalue
+}
+decltype(auto) h2(Thing t) {
+  return t;     // OK, t is an xvalue and h2's return type is Thing
+}
+decltype(auto) h3(Thing t) {
+  return (t);   // OK, (t) is an xvalue and h3's return type is Thing&&
 }
 ```
 — *end example*]
 ### 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]].
 - `a` or `b` is of class or enumeration type and overload resolution
   [[over.match]] as applied to `a @ b` results in a usable candidate, or
 - neither `a` nor `b` is of class or enumeration type and `a @ b` is a
   valid expression.
 If the *member-specification* does not explicitly declare any member or
 friend named `operator==`, an `==` operator function is declared
 implicitly for each three-way comparison operator function defined as
 defaulted in the *member-specification*, with the same access and
 *function-definition* and in the same class scope as the respective
 three-way comparison operator function, except that the return type is
 replaced with `bool` and the *declarator-id* is replaced with
 `operator==`.
+[*Note 1*: Such an implicitly-declared `==` operator for a class `X` is
 defined as defaulted in the definition of `X` and has the same
 *parameter-declaration-clause* and trailing *requires-clause* as the
 respective three-way comparison operator. It is declared with `friend`,
 `virtual`, `constexpr`, or `consteval` if the three-way comparison
 operator function is so declared. If the three-way comparison operator
 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*:
 };
 ```
 — *end example*]
+[*Note 2*: The `==` operator function is declared implicitly even if
 the defaulted three-way comparison operator function is defined as
 deleted. — *end note*]
 The direct base class subobjects of `C`, in the order of their
 declaration in the *base-specifier-list* of `C`, followed by the
 ### Three-way comparison <a id="class.spaceship">[[class.spaceship]]</a>
 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
   a < b  ? partial_ordering::less :
   b < a  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
+[*Note 1*: A synthesized three-way comparison is ill-formed if overload
+resolution finds usable candidates that do not otherwise meet the
+requirements implied by the defined expression. — *end note*]
 Let `R` be the declared return type of a defaulted three-way comparison
 operator function, and let `xᵢ` be the elements of the expanded list of
 subobjects for an object `x` of type `C`.
 };
 ```
 — *end example*]
 <!-- 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
 [basic.scope.class]: basic.md#basic.scope.class
+[basic.scope.pdecl]: basic.md#basic.scope.pdecl
+[basic.scope.scope]: basic.md#basic.scope.scope
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
 [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
 [class.access.nest]: #class.access.nest
 [class.access.spec]: #class.access.spec
 [class.access.virt]: #class.access.virt
 [class.base.init]: #class.base.init
 [class.bit]: #class.bit
 [class.compare.default]: #class.compare.default
 [class.compare.secondary]: #class.compare.secondary
 [class.conv]: #class.conv
 [class.conv.ctor]: #class.conv.ctor
 [class.conv.fct]: #class.conv.fct
+[class.conv.general]: #class.conv.general
 [class.copy.assign]: #class.copy.assign
 [class.copy.ctor]: #class.copy.ctor
 [class.copy.elision]: #class.copy.elision
 [class.ctor]: #class.ctor
+[class.ctor.general]: #class.ctor.general
 [class.default.ctor]: #class.default.ctor
 [class.derived]: #class.derived
+[class.derived.general]: #class.derived.general
 [class.dtor]: #class.dtor
 [class.eq]: #class.eq
 [class.expl.init]: #class.expl.init
 [class.free]: #class.free
 [class.friend]: #class.friend
 [class.inhctor.init]: #class.inhctor.init
 [class.init]: #class.init
+[class.init.general]: #class.init.general
 [class.local]: #class.local
 [class.mem]: #class.mem
+[class.mem.general]: #class.mem.general
+[class.member.lookup]: basic.md#class.member.lookup
 [class.mfct]: #class.mfct
+[class.mfct.non.static]: #class.mfct.non.static
 [class.mi]: #class.mi
 [class.name]: #class.name
 [class.nest]: #class.nest
 [class.paths]: #class.paths
 [class.pre]: #class.pre
 [class.prop]: #class.prop
 [class.protected]: #class.protected
 [class.qual]: basic.md#class.qual
 [class.spaceship]: #class.spaceship
 [class.static]: #class.static
 [class.static.data]: #class.static.data
+[class.static.general]: #class.static.general
 [class.static.mfct]: #class.static.mfct
 [class.temporary]: basic.md#class.temporary
 [class.union]: #class.union
 [class.union.anon]: #class.union.anon
+[class.union.general]: #class.union.general
 [class.virtual]: #class.virtual
 [cmp.categories]: support.md#cmp.categories
 [cmp.categories.pre]: support.md#cmp.categories.pre
 [cmp.partialord]: support.md#cmp.partialord
 [cmp.strongord]: support.md#cmp.strongord
 [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.fct.def.default]: dcl.md#dcl.fct.def.default
 [dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.fct.spec]: dcl.md#dcl.fct.spec
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
+[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
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [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
+[term.odr.use]: basic.md#term.odr.use
+[term.padding.bits]: basic.md#term.padding.bits
 [^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]].
 [^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
     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.

Diff to HTML by rtfpessoa