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

Files changed (1) hide show

tmp/tmpivn6qv63/{from.md → to.md} +498 -530

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

@@ -1,7 +1,9 @@
 ## Class members <a id="class.mem">[[class.mem]]</a>
 ``` bnf
 member-specification:
     member-declaration member-specificationₒₚₜ
     access-specifier ':' member-specificationₒₚₜ
 ```
@@ -51,27 +53,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
@@ -79,23 +83,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*,
@@ -105,31 +109,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*.
@@ -137,12 +146,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*]
@@ -172,11 +181,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`.
@@ -197,12 +210,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*]
@@ -241,45 +254,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; };
@@ -300,11 +315,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
@@ -330,55 +346,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;
@@ -386,30 +374,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,
@@ -429,34 +410,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
@@ -495,113 +471,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.
@@ -657,38 +549,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 {
@@ -698,18 +589,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);
@@ -736,15 +626,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
@@ -792,42 +686,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>
@@ -876,11 +761,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 {
@@ -942,25 +827,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&)
 ```
@@ -973,11 +859,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
@@ -986,24 +872,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:
@@ -1016,22 +902,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.
@@ -1060,27 +941,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
@@ -1106,12 +987,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
@@ -1133,17 +1014,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
@@ -1184,14 +1066,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
@@ -1205,23 +1085,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
@@ -1232,31 +1112,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
@@ -1294,21 +1162,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ₒₚₜ
 ```
@@ -1319,13 +1193,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`.
@@ -1345,21 +1219,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:
@@ -1372,37 +1250,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
@@ -1410,53 +1282,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
@@ -1464,11 +1339,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
@@ -1492,17 +1367,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
@@ -1524,20 +1399,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:
@@ -1552,19 +1427,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*]
@@ -1582,36 +1459,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>
@@ -1642,13 +1494,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
@@ -1656,19 +1508,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*]
@@ -1676,18 +1528,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
 ```
@@ -1699,20 +1548,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 {
@@ -1744,13 +1617,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;
@@ -1793,18 +1666,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>
@@ -1814,10 +1716,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.
@@ -1829,39 +1733,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.
@@ -1872,16 +1754,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
@@ -1894,17 +1772,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 {
@@ -1914,20 +1789,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*:
@@ -1935,56 +1810,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*]
@@ -1999,12 +1875,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
@@ -2037,16 +1913,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*:
@@ -2059,29 +2058,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 {
@@ -2092,56 +2095,21 @@ 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*]

 ## 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.

Diff to HTML by rtfpessoa