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

Files changed (1) hide show

tmp/tmpswnk6ron/{from.md → to.md} +144 -366

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

@@ -1,6 +1,6 @@
-# Derived classes <a id="class.derived">[[class.derived]]</a>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
@@ -15,63 +15,63 @@ base-specifier-list:
 ```
 ``` bnf
 base-specifier:
     attribute-specifier-seqₒₚₜ class-or-decltype
-    attribute-specifier-seqₒₚₜ 'virtual' access-specifierₒₚₜ class-or-decltype
-    attribute-specifier-seqₒₚₜ access-specifier 'virtual'ₒₚₜ class-or-decltype
 ```
 ``` bnf
 class-or-decltype:
-    nested-name-specifierₒₚₜ class-name
-    nested-name-specifier 'template' simple-template-id
     decltype-specifier
 ```
 ``` bnf
 access-specifier:
- 'private'
- 'protected'
- 'public'
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
-A *class-or-decltype* shall denote a class type that is not an
-incompletely defined class (Clause  [[class]]). The class denoted by the
-*class-or-decltype* of a *base-specifier* is called a *direct base
-class* for the class being defined. During the lookup for a base class
-name, non-type names are ignored ([[basic.scope.hiding]]). If the name
-found is not a *class-name*, the program is ill-formed. A class `B` is a
-base class of a class `D` if it is a direct base class of `D` or a
-direct base class of one of `D`’s base classes. A class is an *indirect*
-base class of another if it is a base class but not a direct base class.
-A class is said to be (directly or indirectly) *derived* from its
-(direct or indirect) base classes.
-[*Note 1*: See Clause  [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
 Unless redeclared in the derived class, members of a base class are also
 considered to be members of the derived class. Members of a base class
 other than constructors are said to be *inherited* by the derived class.
 Constructors of a base class can also be inherited as described in
 [[namespace.udecl]]. Inherited members can be referred to in expressions
 in the same manner as other members of the derived class, unless their
-names are hidden or ambiguous ([[class.member.lookup]]).
-[*Note 2*: The scope resolution operator `::` ([[expr.prim]]) can be
-used to refer to a direct or indirect base member explicitly. This
 allows access to a name that has been redeclared in the derived class. A
 derived class can itself serve as a base class subject to access
 control; see  [[class.access.base]]. A pointer to a derived class can be
 implicitly converted to a pointer to an accessible unambiguous base
-class ([[conv.ptr]]). An lvalue of a derived class type can be bound to
-a reference to an accessible unambiguous base class (
-[[dcl.init.ref]]). — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
@@ -97,41 +97,41 @@ struct Derived2 : Derived {
 Here, an object of class `Derived2` will have a subobject of class
 `Derived` which in turn will have a subobject of class `Base`.
 — *end example*]
-A *base-specifier* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]).
 The order in which the base class subobjects are allocated in the most
-derived object ([[intro.object]]) is unspecified.
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
-“directly derived from”. An arrow need not have a physical
-representation in memory. A DAG of subobjects is often referred to as a
-“subobject lattice”.
-<a id="fig:dag"></a>
-![Directed acyclic graph \[fig:dag\]](images/figdag.svg)
  — *end note*]
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
-[*Note 5*: A base class subobject might have a layout ([[basic.stc]])
 different from the layout of a most derived object of the same type. A
-base class subobject might have a polymorphic behavior (
-[[class.cdtor]]) different from the polymorphic behavior of a most
-derived object of the same type. A base class subobject may be of zero
-size (Clause  [[class]]); however, two subobjects that have the same
-class type and that belong to the same most derived object must not be
-allocated at the same address ([[expr.eq]]). — *end note*]
-## Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
 [*Note 1*: The use of more than one direct base class is often called
 multiple inheritance. — *end note*]
@@ -146,13 +146,13 @@ class D : public A, public B, public C { ... };
 ```
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
-specified by the semantics of initialization by constructor (
-[[class.base.init]]), cleanup ([[class.dtor]]), and storage layout (
-[[class.mem]],  [[class.access.spec]]). — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
@@ -164,11 +164,11 @@ can be unambiguously referred to. — *end note*]
 [*Example 2*:
 ``` cpp
 class X { ... };
-class Y : public X, public X { ... };             // ill-formed
 ```
 ``` cpp
 class L { public: int next;  ... };
 class A : public L { ... };
@@ -181,38 +181,38 @@ class D : public A, public L { void f(); ... };   // well-formed
 A base class specifier that does not contain the keyword `virtual`
 specifies a *non-virtual base class*. A base class specifier that
 contains the keyword `virtual` specifies a *virtual base class*. For
 each distinct occurrence of a non-virtual base class in the class
-lattice of the most derived class, the most derived object (
-[[intro.object]]) shall contain a corresponding distinct base class
 subobject of that type. For each distinct base class that is specified
 virtual, the most derived object shall contain a single base class
 subobject of that type.
 [*Note 4*:
 For an object of class type `C`, each distinct occurrence of a
 (non-virtual) base class `L` in the class lattice of `C` corresponds
 one-to-one with a distinct `L` subobject within the object of type `C`.
 Given the class `C` defined above, an object of class `C` will have two
-subobjects of class `L` as shown in Figure  [[fig:nonvirt]].
-<a id="fig:nonvirt"></a>
-![Non-virtual base \[fig:nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
 subobject is meant. The body of function `C::f` could refer to the
 member `next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
 Without the `A::` or `B::` qualifiers, the definition of `C::f` above
-would be ill-formed because of ambiguity ([[class.member.lookup]]).
 — *end note*]
 [*Note 5*:
@@ -223,19 +223,19 @@ class V { ... };
 class A : virtual public V { ... };
 class B : virtual public V { ... };
 class C : public A, public B { ... };
 ```
-<a id="fig:virt"></a>
-![Virtual base \[fig:virt\]](images/figvirt.svg)
 For an object `c` of class type `C`, a single subobject of type `V` is
 shared by every base class subobject of `c` that has a `virtual` base
 class of type `V`. Given the class `C` defined above, an object of class
-`C` will have one subobject of class `V`, as shown in Figure
-[[fig:virt]].
 — *end note*]
 [*Note 6*:
@@ -254,280 +254,43 @@ For an object of class `AA`, all `virtual` occurrences of base class `B`
 in the class lattice of `AA` correspond to a single `B` subobject within
 the object of type `AA`, and every other occurrence of a (non-virtual)
 base class `B` in the class lattice of `AA` corresponds one-to-one with
 a distinct `B` subobject within the object of type `AA`. Given the class
 `AA` defined above, class `AA` has two subobjects of class `B`: `Z`’s
-`B` and the virtual `B` shared by `X` and `Y`, as shown in Figure
-[[fig:virtnonvirt]].
-<a id="fig:virtnonvirt"></a>
-![Virtual and non-virtual base \[fig:virtnonvirt\]](images/figvirtnonvirt.svg)
 — *end note*]
-## Member name lookup <a id="class.member.lookup">[[class.member.lookup]]</a>
-Member name lookup determines the meaning of a name (*id-expression*) in
-a class scope ([[basic.scope.class]]). Name lookup can result in an
-*ambiguity*, in which case the program is ill-formed. For an
-*id-expression*, name lookup begins in the class scope of `this`; for a
-*qualified-id*, name lookup begins in the scope of the
-*nested-name-specifier*. Name lookup takes place before access control (
-[[basic.lookup]], Clause  [[class.access]]).
-The following steps define the result of name lookup for a member name
-`f` in a class scope `C`.
-The *lookup set* for `f` in `C`, called S(f,C), consists of two
-component sets: the *declaration set*, a set of members named `f`; and
-the *subobject set*, a set of subobjects where declarations of these
-members (possibly including *using-declaration*s) were found. In the
-declaration set, *using-declaration*s are replaced by the set of
-designated members that are not hidden or overridden by members of the
-derived class ([[namespace.udecl]]), and type declarations (including
-injected-class-names) are replaced by the types they designate. S(f,C)
-is calculated as follows:
-If `C` contains a declaration of the name `f`, the declaration set
-contains every declaration of `f` declared in `C` that satisfies the
-requirements of the language construct in which the lookup occurs.
-[*Note 1*: Looking up a name in an *elaborated-type-specifier* (
-[[basic.lookup.elab]]) or *base-specifier* (Clause  [[class.derived]]),
-for instance, ignores all non-type declarations, while looking up a name
-in a *nested-name-specifier* ([[basic.lookup.qual]]) ignores function,
-variable, and enumerator declarations. As another example, looking up a
-name in a *using-declaration* ([[namespace.udecl]]) includes the
-declaration of a class or enumeration that would ordinarily be hidden by
-another declaration of that name in the same scope. — *end note*]
-If the resulting declaration set is not empty, the subobject set
-contains `C` itself, and calculation is complete.
-Otherwise (i.e., `C` does not contain a declaration of `f` or the
-resulting declaration set is empty), S(f,C) is initially empty. If `C`
-has base classes, calculate the lookup set for `f` in each direct base
-class subobject Bᵢ, and merge each such lookup set S(f,Bᵢ) in turn into
-S(f,C).
-The following steps define the result of merging lookup set S(f,Bᵢ) into
-the intermediate S(f,C):
-- If each of the subobject members of S(f,Bᵢ) is a base class subobject
-  of at least one of the subobject members of S(f,C), or if S(f,Bᵢ) is
-  empty, S(f,C) is unchanged and the merge is complete. Conversely, if
-  each of the subobject members of S(f,C) is a base class subobject of
-  at least one of the subobject members of S(f,Bᵢ), or if S(f,C) is
-  empty, the new S(f,C) is a copy of S(f,Bᵢ).
-- Otherwise, if the declaration sets of S(f,Bᵢ) and S(f,C) differ, the
-  merge is ambiguous: the new S(f,C) is a lookup set with an invalid
-  declaration set and the union of the subobject sets. In subsequent
-  merges, an invalid declaration set is considered different from any
-  other.
-- Otherwise, the new S(f,C) is a lookup set with the shared set of
-  declarations and the union of the subobject sets.
-The result of name lookup for `f` in `C` is the declaration set of
-S(f,C). If it is an invalid set, the program is ill-formed.
-[*Example 1*:
-``` cpp
-struct A { int x; };                    // S(x,A) = { { A::x }, { A } }
-struct B { float x; };                  // S(x,B) = { { B::x }, { B } }
-struct C: public A, public B { };       // S(x,C) = { invalid, { A in C, B in C } }
-struct D: public virtual C { };         // S(x,D) = S(x,C)
-struct E: public virtual C { char x; }; // S(x,E) = { { E::x }, { E } }
-struct F: public D, public E { };       // S(x,F) = S(x,E)
-int main() {
-  F f;
-  f.x = 0;                              // OK, lookup finds E::x
-}
-```
-S(x,F) is unambiguous because the `A` and `B` base class subobjects of
-`D` are also base class subobjects of `E`, so S(x,D) is discarded in the
-first merge step.
-— *end example*]
-If the name of an overloaded function is unambiguously found, overload
-resolution ([[over.match]]) also takes place before access control.
-Ambiguities can often be resolved by qualifying a name with its class
-name.
-[*Example 2*:
-``` cpp
-struct A {
-  int f();
-};
-```
-``` cpp
-struct B {
-  int f();
-};
-```
-``` cpp
-struct C : A, B {
-  int f() { return A::f() + B::f(); }
-};
-```
-— *end example*]
-[*Note 2*: A static member, a nested type or an enumerator defined in a
-base class `T` can unambiguously be found even if an object has more
-than one base class subobject of type `T`. Two base class subobjects
-share the non-static member subobjects of their common virtual base
-classes. — *end note*]
-[*Example 3*:
-``` cpp
-struct V {
-  int v;
-};
-struct A {
-  int a;
-  static int   s;
-  enum { e };
-};
-struct B : A, virtual V { };
-struct C : A, virtual V { };
-struct D : B, C { };
-void f(D* pd) {
-  pd->v++;          // OK: only one v (virtual)
-  pd->s++;          // OK: only one s (static)
-  int i = pd->e;    // OK: only one e (enumerator)
-  pd->a++;          // error, ambiguous: two a{s} in D
-}
-```
-— *end example*]
-[*Note 3*:  When virtual base classes are used, a hidden declaration
-can be reached along a path through the subobject lattice that does not
-pass through the hiding declaration. This is not an ambiguity. The
-identical use with non-virtual base classes is an ambiguity; in that
-case there is no unique instance of the name that hides all the
-others. — *end note*]
-[*Example 4*:
-``` cpp
-struct V { int f();  int x; };
-struct W { int g();  int y; };
-struct B : virtual V, W {
-  int f();  int x;
-  int g();  int y;
-};
-struct C : virtual V, W { };
-struct D : B, C { void glorp(); };
-```
-<a id="fig:name"></a>
-![Name lookup \[fig:name\]](images/figname.svg)
-The names declared in `V` and the left-hand instance of `W` are hidden
-by those in `B`, but the names declared in the right-hand instance of
-`W` are not hidden at all.
-``` cpp
-void D::glorp() {
-  x++;              // OK: B::x hides V::x
-  f();              // OK: B::f() hides V::f()
-  y++;              // error: B::y and C's W::y
-  g();              // error: B::g() and C's W::g()
-}
-```
-— *end example*]
-An explicit or implicit conversion from a pointer to or an expression
-designating an object of a derived class to a pointer or reference to
-one of its base classes shall unambiguously refer to a unique object
-representing the base class.
-[*Example 5*:
-``` cpp
-struct V { };
-struct A { };
-struct B : A, virtual V { };
-struct C : A, virtual V { };
-struct D : B, C { };
-void g() {
-  D d;
-  B* pb = &d;
-  A* pa = &d;       // error, ambiguous: C's A or B's A?
-  V* pv = &d;       // OK: only one V subobject
-}
-```
-— *end example*]
-[*Note 4*: Even if the result of name lookup is unambiguous, use of a
-name found in multiple subobjects might still be ambiguous (
-[[conv.mem]],  [[expr.ref]], [[class.access.base]]). — *end note*]
-[*Example 6*:
-``` cpp
-struct B1 {
-  void f();
-  static void f(int);
-  int i;
-};
-struct B2 {
-  void f(double);
-};
-struct I1: B1 { };
-struct I2: B1 { };
-struct D: I1, I2, B2 {
-  using B1::f;
-  using B2::f;
-  void g() {
-    f();                        // Ambiguous conversion of this
-    f(0);                       // Unambiguous (static)
-    f(0.0);                     // Unambiguous (only one B2)
-    int B1::* mpB1 = &D::i;     // Unambiguous
-    int D::* mpD = &D::i;       // Ambiguous conversion
-  }
-};
-```
-— *end example*]
-## Virtual functions <a id="class.virtual">[[class.virtual]]</a>
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
 A class that declares or inherits a virtual function is called a
-*polymorphic class*.
 If a virtual member function `vf` is declared in a class `Base` and in a
 class `Derived`, derived directly or indirectly from `Base`, a member
-function `vf` with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and ref-qualifier (or absence of same) as `Base::vf`
-is declared, then `Derived::vf` is also virtual (whether or not it is so
-declared) and it *overrides*[^5] `Base::vf`. For convenience we say that
-any virtual function overrides itself. A virtual member function `C::vf`
-of a class object `S` is a *final overrider* unless the most derived
-class ([[intro.object]]) of which `S` is a base class subobject (if
-any) declares or inherits another member function that overrides `vf`.
-In a derived class, if a virtual member function of a base class
-subobject has more than one final overrider the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
@@ -621,10 +384,23 @@ struct D : B {
 };
 ```
 — *end example*]
 Even though destructors are not inherited, a destructor in a derived
 class overrides a base class destructor declared virtual; see
 [[class.dtor]] and  [[class.free]].
 The return type of an overriding function shall be either identical to
@@ -632,11 +408,11 @@ the return type of the overridden function or *covariant* with the
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
 the following criteria:
 - both are pointers to classes, both are lvalue references to classes,
-  or both are rvalue references to classes[^6]
 - the class in the return type of `B::f` is the same class as the class
   in the return type of `D::f`, or is an unambiguous and accessible
   direct or indirect base class of the class in the return type of
   `D::f`
 - both pointers or references have the same cv-qualification and the
@@ -647,13 +423,13 @@ the following criteria:
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
 complete at the point of declaration of `D::f` or shall be the class
 type `D`. When the overriding function is called as the final overrider
 of the overridden function, its result is converted to the type returned
-by the (statically chosen) overridden function ([[expr.call]]).
-[*Example 5*:
 ``` cpp
 class B { };
 class D : private B { friend class Derived; };
 struct Base {
@@ -684,39 +460,39 @@ void g() {
   Base* bp = &d;                // standard conversion:
                                 // Derived* to Base*
   bp->vf1();                    // calls Derived::vf1()
   bp->vf2();                    // calls Base::vf2()
   bp->f();                      // calls Base::f() (not virtual)
-  B*  p = bp->vf4();            // calls Derived::pf() and converts the
                                 // result to B*
   Derived*  dp = &d;
-  D*  q = dp->vf4();            // calls Derived::pf() and does not
                                 // convert the result to B*
-  dp->vf2();                    // ill-formed: argument mismatch
 }
 ```
 — *end example*]
 [*Note 3*: The interpretation of the call of a virtual function depends
 on the type of the object for which it is called (the dynamic type),
 whereas the interpretation of a call of a non-virtual member function
 depends only on the type of the pointer or reference denoting that
-object (the static type) ([[expr.call]]). — *end note*]
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
-function cannot be a non-member ([[dcl.fct.spec]]) function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
-virtual function declared in one class can be declared a `friend` in
-another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
-pure ([[class.abstract]]) in that class, or both; no diagnostic is
-required ([[basic.def.odr]]).
-[*Example 6*:
 Here are some uses of virtual functions with multiple base classes:
 ``` cpp
 struct A {
@@ -739,22 +515,22 @@ void foo() {
 //   A*  ap = &d;                  // would be ill-formed: ambiguous
   B1*  b1p = &d;
   A*   ap = b1p;
   D*   dp = &d;
   ap->f();                      // calls D::B1::f
-  dp->f();                      // ill-formed: ambiguous
 }
 ```
 In class `D` above there are two occurrences of class `A` and hence two
 occurrences of the virtual member function `A::f`. The final overrider
 of `B1::A::f` is `B1::f` and the final overrider of `B2::A::f` is
 `B2::f`.
 — *end example*]
-[*Example 7*:
 The following example shows a function that does not have a unique final
 overrider:
 ``` cpp
@@ -768,26 +544,26 @@ struct VB1 : virtual A {        // note virtual derivation
 struct VB2 : virtual A {
   void f();
 };
-struct Error : VB1, VB2 {       // ill-formed
 };
 struct Okay : VB1, VB2 {
   void f();
 };
 ```
 Both `VB1::f` and `VB2::f` override `A::f` but there is no overrider of
 both of them in class `Error`. This example is therefore ill-formed.
-Class `Okay` is well formed, however, because `Okay::f` is a final
 overrider.
 — *end example*]
-[*Example 8*:
 The following example uses the well-formed classes from above.
 ``` cpp
 struct VB1a : virtual A {       // does not declare f
@@ -802,14 +578,14 @@ void foe() {
 }
 ```
 — *end example*]
-Explicit qualification with the scope operator ([[expr.prim]])
 suppresses the virtual call mechanism.
-[*Example 9*:
 ``` cpp
 class B { public: virtual void f(); };
 class D : public B { public: void f(); };
@@ -819,35 +595,44 @@ void D::f() { ... B::f(); }
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
-A function with a deleted definition ([[dcl.fct.def]]) shall not
-override a function that does not have a deleted definition. Likewise, a
-function that does not have a deleted definition shall not override a
-function with a deleted definition.
-## Abstract classes <a id="class.abstract">[[class.abstract]]</a>
 [*Note 1*: The abstract class mechanism supports the notion of a
 general concept, such as a `shape`, of which only more concrete
 variants, such as `circle` and `square`, can actually be used. An
 abstract class can also be used to define an interface for which derived
 classes provide a variety of implementations. — *end note*]
-An *abstract class* is a class that can be used only as a base class of
-some other class; no objects of an abstract class can be created except
-as subobjects of a class derived from it. A class is abstract if it has
-at least one *pure virtual function*.
 [*Note 2*: Such a function might be inherited: see
 below. — *end note*]
-A virtual function is specified *pure* by using a *pure-specifier* (
-[[class.mem]]) in the function declaration in the class definition. A
-pure virtual function need be defined only if called with, or as if
-with ([[class.dtor]]), the *qualified-id* syntax ([[expr.prim]]).
 [*Example 1*:
 ``` cpp
 class point { ... };
@@ -861,43 +646,36 @@ public:
 };
 ```
 — *end example*]
-[*Note 3*: A function declaration cannot provide both a
-*pure-specifier* and a definition — *end note*]
 [*Example 2*:
 ``` cpp
 struct C {
-  virtual void f() = 0 { };     // ill-formed
 };
 ```
 — *end example*]
-An abstract class shall not be used as a parameter type, as a function
-return type, or as the type of an explicit conversion. Pointers and
-references to an abstract class can be declared.
-[*Example 3*:
-``` cpp
-shape x;                        // error: object of abstract class
-shape* p;                       // OK
-shape f();                      // error
-void g(shape);                  // error
-shape& h(shape&);               // OK
-```
-— *end example*]
 A class is abstract if it contains or inherits at least one pure virtual
 function for which the final overrider is pure virtual.
-[*Example 4*:
 ``` cpp
 class ab_circle : public shape {
   int radius;
 public:
@@ -921,15 +699,15 @@ public:
 would make class `circle` non-abstract and a definition of
 `circle::draw()` must be provided.
 — *end example*]
-[*Note 4*: An abstract class can be derived from a class that is not
 abstract, and a pure virtual function may override a virtual function
 which is not pure. — *end note*]
 Member functions can be called from a constructor (or destructor) of an
-abstract class; the effect of making a virtual call ([[class.virtual]])
-to a pure virtual function directly or indirectly for the object being
 created (or destroyed) from such a constructor (or destructor) is
 undefined.

+## Derived classes <a id="class.derived">[[class.derived]]</a>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
 ```
 ``` bnf
 base-specifier:
     attribute-specifier-seqₒₚₜ class-or-decltype
+    attribute-specifier-seqₒₚₜ virtual access-specifierₒₚₜ class-or-decltype
+    attribute-specifier-seqₒₚₜ access-specifier virtualₒₚₜ class-or-decltype
 ```
 ``` bnf
 class-or-decltype:
+    nested-name-specifierₒₚₜ type-name
+    nested-name-specifier template simple-template-id
     decltype-specifier
 ```
 ``` bnf
 access-specifier:
+    private
+    protected
+    public
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
+A *class-or-decltype* shall denote a (possibly cv-qualified) class type
+that is not an incompletely defined class [[class.mem]]; any
+cv-qualifiers are ignored. The class denoted by the *class-or-decltype*
+of a *base-specifier* is called a *direct base class* for the class
+being defined. During the lookup for a base class name, non-type names
+are ignored [[basic.scope.hiding]]. A class `B` is a base class of a
+class `D` if it is a direct base class of `D` or a direct base class of
+one of `D`’s base classes. A class is an *indirect base class* of
+another if it is a base class but not a direct base class. A class is
+said to be (directly or indirectly) *derived* from its (direct or
+indirect) base classes.
+[*Note 1*: See [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
 Unless redeclared in the derived class, members of a base class are also
 considered to be members of the derived class. Members of a base class
 other than constructors are said to be *inherited* by the derived class.
 Constructors of a base class can also be inherited as described in
 [[namespace.udecl]]. Inherited members can be referred to in expressions
 in the same manner as other members of the derived class, unless their
+names are hidden or ambiguous [[class.member.lookup]].
+[*Note 2*: The scope resolution operator `::` [[expr.prim.id.qual]] can
+be used to refer to a direct or indirect base member explicitly. This
 allows access to a name that has been redeclared in the derived class. A
 derived class can itself serve as a base class subject to access
 control; see  [[class.access.base]]. A pointer to a derived class can be
 implicitly converted to a pointer to an accessible unambiguous base
+class [[conv.ptr]]. An lvalue of a derived class type can be bound to a
+reference to an accessible unambiguous base class
+[[dcl.init.ref]]. — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
 Here, an object of class `Derived2` will have a subobject of class
 `Derived` which in turn will have a subobject of class `Base`.
 — *end example*]
+A *base-specifier* followed by an ellipsis is a pack expansion
+[[temp.variadic]].
 The order in which the base class subobjects are allocated in the most
+derived object [[intro.object]] is unspecified.
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
+“directly derived from” (see Figure [[fig:class.dag]]). An arrow
+need not have a physical representation in memory. A DAG of subobjects
+is often referred to as a “subobject lattice”.
+<a id="fig:class.dag"></a>
+![Directed acyclic graph \[fig:class.dag\]](images/figdag.svg)
  — *end note*]
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
+[*Note 5*: A base class subobject might have a layout [[basic.stc]]
 different from the layout of a most derived object of the same type. A
+base class subobject might have a polymorphic behavior [[class.cdtor]]
+different from the polymorphic behavior of a most derived object of the
+same type. A base class subobject may be of zero size [[class]];
+however, two subobjects that have the same class type and that belong to
+the same most derived object must not be allocated at the same address
+[[expr.eq]]. — *end note*]
+### Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
 [*Note 1*: The use of more than one direct base class is often called
 multiple inheritance. — *end note*]
 ```
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
+specified by the semantics of initialization by constructor
+[[class.base.init]], cleanup [[class.dtor]], and storage layout (
+[[class.mem]], [[class.access.spec]]). — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
 [*Example 2*:
 ``` cpp
 class X { ... };
+class Y : public X, public X { ... };             // error
 ```
 ``` cpp
 class L { public: int next;  ... };
 class A : public L { ... };
 A base class specifier that does not contain the keyword `virtual`
 specifies a *non-virtual base class*. A base class specifier that
 contains the keyword `virtual` specifies a *virtual base class*. For
 each distinct occurrence of a non-virtual base class in the class
+lattice of the most derived class, the most derived object
+[[intro.object]] shall contain a corresponding distinct base class
 subobject of that type. For each distinct base class that is specified
 virtual, the most derived object shall contain a single base class
 subobject of that type.
 [*Note 4*:
 For an object of class type `C`, each distinct occurrence of a
 (non-virtual) base class `L` in the class lattice of `C` corresponds
 one-to-one with a distinct `L` subobject within the object of type `C`.
 Given the class `C` defined above, an object of class `C` will have two
+subobjects of class `L` as shown in Figure [[fig:class.nonvirt]].
+<a id="fig:class.nonvirt"></a>
+![Non-virtual base \[fig:class.nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
 subobject is meant. The body of function `C::f` could refer to the
 member `next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
 Without the `A::` or `B::` qualifiers, the definition of `C::f` above
+would be ill-formed because of ambiguity [[class.member.lookup]].
 — *end note*]
 [*Note 5*:
 class A : virtual public V { ... };
 class B : virtual public V { ... };
 class C : public A, public B { ... };
 ```
+<a id="fig:class.virt"></a>
+![Virtual base \[fig:class.virt\]](images/figvirt.svg)
 For an object `c` of class type `C`, a single subobject of type `V` is
 shared by every base class subobject of `c` that has a `virtual` base
 class of type `V`. Given the class `C` defined above, an object of class
+`C` will have one subobject of class `V`, as shown in Figure
+[[fig:class.virt]].
 — *end note*]
 [*Note 6*:
 in the class lattice of `AA` correspond to a single `B` subobject within
 the object of type `AA`, and every other occurrence of a (non-virtual)
 base class `B` in the class lattice of `AA` corresponds one-to-one with
 a distinct `B` subobject within the object of type `AA`. Given the class
 `AA` defined above, class `AA` has two subobjects of class `B`: `Z`’s
+`B` and the virtual `B` shared by `X` and `Y`, as shown in Figure
+[[fig:class.virtnonvirt]].
+<a id="fig:class.virtnonvirt"></a>
+![Virtual and non-virtual base \[fig:class.virtnonvirt\]](images/figvirtnonvirt.svg)
 — *end note*]
+### Virtual functions <a id="class.virtual">[[class.virtual]]</a>
+A non-static member function is a *virtual function* if it is first
+declared with the keyword `virtual` or if it overrides a virtual member
+function declared in a base class (see below).[^7]
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
 A class that declares or inherits a virtual function is called a
+*polymorphic class*.[^8]
 If a virtual member function `vf` is declared in a class `Base` and in a
 class `Derived`, derived directly or indirectly from `Base`, a member
+function `vf` with the same name, parameter-type-list [[dcl.fct]],
 cv-qualification, and ref-qualifier (or absence of same) as `Base::vf`
+is declared, then `Derived::vf` *overrides*[^9] `Base::vf`. For
+convenience we say that any virtual function overrides itself. A virtual
+member function `C::vf` of a class object `S` is a *final overrider*
+unless the most derived class [[intro.object]] of which `S` is a base
+class subobject (if any) declares or inherits another member function
+that overrides `vf`. In a derived class, if a virtual member function of
+a base class subobject has more than one final overrider the program is
+ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
 };
 ```
 — *end example*]
+A virtual function shall not have a trailing *requires-clause*
+[[dcl.decl]].
+[*Example 5*:
+``` cpp
+struct A {
+  virtual void f() requires true;       // error: virtual function cannot be constrained[temp.constr.decl]
+};
+```
+— *end example*]
 Even though destructors are not inherited, a destructor in a derived
 class overrides a base class destructor declared virtual; see
 [[class.dtor]] and  [[class.free]].
 The return type of an overriding function shall be either identical to
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
 the following criteria:
 - both are pointers to classes, both are lvalue references to classes,
+  or both are rvalue references to classes[^10]
 - the class in the return type of `B::f` is the same class as the class
   in the return type of `D::f`, or is an unambiguous and accessible
   direct or indirect base class of the class in the return type of
   `D::f`
 - both pointers or references have the same cv-qualification and the
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
 complete at the point of declaration of `D::f` or shall be the class
 type `D`. When the overriding function is called as the final overrider
 of the overridden function, its result is converted to the type returned
+by the (statically chosen) overridden function [[expr.call]].
+[*Example 6*:
 ``` cpp
 class B { };
 class D : private B { friend class Derived; };
 struct Base {
   Base* bp = &d;                // standard conversion:
                                 // Derived* to Base*
   bp->vf1();                    // calls Derived::vf1()
   bp->vf2();                    // calls Base::vf2()
   bp->f();                      // calls Base::f() (not virtual)
+  B*  p = bp->vf4();            // calls Derived::vf4() and converts the
                                 // result to B*
   Derived*  dp = &d;
+  D*  q = dp->vf4();            // calls Derived::vf4() and does not
                                 // convert the result to B*
+  dp->vf2();                    // error: argument mismatch
 }
 ```
 — *end example*]
 [*Note 3*: The interpretation of the call of a virtual function depends
 on the type of the object for which it is called (the dynamic type),
 whereas the interpretation of a call of a non-virtual member function
 depends only on the type of the pointer or reference denoting that
+object (the static type) [[expr.call]]. — *end note*]
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
+function cannot be a non-member [[dcl.fct.spec]] function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
+virtual function declared in one class can be declared a friend (
+[[class.friend]]) in another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
+pure [[class.abstract]] in that class, or both; no diagnostic is
+required [[basic.def.odr]].
+[*Example 7*:
 Here are some uses of virtual functions with multiple base classes:
 ``` cpp
 struct A {
 //   A*  ap = &d;                  // would be ill-formed: ambiguous
   B1*  b1p = &d;
   A*   ap = b1p;
   D*   dp = &d;
   ap->f();                      // calls D::B1::f
+  dp->f();                      // error: ambiguous
 }
 ```
 In class `D` above there are two occurrences of class `A` and hence two
 occurrences of the virtual member function `A::f`. The final overrider
 of `B1::A::f` is `B1::f` and the final overrider of `B2::A::f` is
 `B2::f`.
 — *end example*]
+[*Example 8*:
 The following example shows a function that does not have a unique final
 overrider:
 ``` cpp
 struct VB2 : virtual A {
   void f();
 };
+struct Error : VB1, VB2 {       // error
 };
 struct Okay : VB1, VB2 {
   void f();
 };
 ```
 Both `VB1::f` and `VB2::f` override `A::f` but there is no overrider of
 both of them in class `Error`. This example is therefore ill-formed.
+Class `Okay` is well-formed, however, because `Okay::f` is a final
 overrider.
 — *end example*]
+[*Example 9*:
 The following example uses the well-formed classes from above.
 ``` cpp
 struct VB1a : virtual A {       // does not declare f
 }
 ```
 — *end example*]
+Explicit qualification with the scope operator [[expr.prim.id.qual]]
 suppresses the virtual call mechanism.
+[*Example 10*:
 ``` cpp
 class B { public: virtual void f(); };
 class D : public B { public: void f(); };
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
+A function with a deleted definition [[dcl.fct.def]] shall not override
+a function that does not have a deleted definition. Likewise, a function
+that does not have a deleted definition shall not override a function
+with a deleted definition.
+A `consteval` virtual function shall not override a virtual function
+that is not `consteval`. A `consteval` virtual function shall not be
+overridden by a virtual function that is not `consteval`.
+### Abstract classes <a id="class.abstract">[[class.abstract]]</a>
 [*Note 1*: The abstract class mechanism supports the notion of a
 general concept, such as a `shape`, of which only more concrete
 variants, such as `circle` and `square`, can actually be used. An
 abstract class can also be used to define an interface for which derived
 classes provide a variety of implementations. — *end note*]
+A virtual function is specified as a *pure virtual function* by using a
+*pure-specifier* [[class.mem]] in the function declaration in the class
+definition.
 [*Note 2*: Such a function might be inherited: see
 below. — *end note*]
+A class is an *abstract class* if it has at least one pure virtual
+function.
+[*Note 3*: An abstract class can be used only as a base class of some
+other class; no objects of an abstract class can be created except as
+subobjects of a class derived from it ([[basic.def]],
+[[class.mem]]). — *end note*]
+A pure virtual function need be defined only if called with, or as if
+with [[class.dtor]], the *qualified-id* syntax [[expr.prim.id.qual]].
 [*Example 1*:
 ``` cpp
 class point { ... };
 };
 ```
 — *end example*]
+[*Note 4*: A function declaration cannot provide both a
+*pure-specifier* and a definition. — *end note*]
 [*Example 2*:
 ``` cpp
 struct C {
+  virtual void f() = 0 { };     // error
 };
 ```
 — *end example*]
+[*Note 5*: An abstract class type cannot be used as a parameter or
+return type of a function being defined [[dcl.fct]] or called
+[[expr.call]], except as specified in [[dcl.type.simple]]. Further, an
+abstract class type cannot be used as the type of an explicit type
+conversion ([[expr.static.cast]], [[expr.reinterpret.cast]],
+[[expr.const.cast]]), because the resulting prvalue would be of abstract
+class type [[basic.lval]]. However, pointers and references to abstract
+class types can appear in such contexts. — *end note*]
 A class is abstract if it contains or inherits at least one pure virtual
 function for which the final overrider is pure virtual.
+[*Example 3*:
 ``` cpp
 class ab_circle : public shape {
   int radius;
 public:
 would make class `circle` non-abstract and a definition of
 `circle::draw()` must be provided.
 — *end example*]
+[*Note 6*: An abstract class can be derived from a class that is not
 abstract, and a pure virtual function may override a virtual function
 which is not pure. — *end note*]
 Member functions can be called from a constructor (or destructor) of an
+abstract class; the effect of making a virtual call [[class.virtual]] to
+a pure virtual function directly or indirectly for the object being
 created (or destroyed) from such a constructor (or destructor) is
 undefined.

Diff to HTML by rtfpessoa