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

Files changed (1) hide show

tmp/tmp8zwnch72/{from.md → to.md} +78 -80

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

@@ -1,7 +1,9 @@
 ## Derived classes <a id="class.derived">[[class.derived]]</a>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
 base-clause:
@@ -36,42 +38,41 @@ access-specifier:
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
-A *class-or-decltype* shall denote a (possibly cv-qualified) class type
 that is not an incompletely defined class [[class.mem]]; any
 cv-qualifiers are ignored. The class denoted by the *class-or-decltype*
 of a *base-specifier* is called a *direct base class* for the class
-being defined. During the lookup for a base class name, non-type names
-are ignored [[basic.scope.hiding]]. A class `B` is a base class of a
-class `D` if it is a direct base class of `D` or a direct base class of
-one of `D`’s base classes. A class is an *indirect base class* of
-another if it is a base class but not a direct base class. A class is
-said to be (directly or indirectly) *derived* from its (direct or
-indirect) base classes.
 [*Note 1*: See [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
-Unless redeclared in the derived class, members of a base class are also
-considered to be members of the derived class. Members of a base class
-other than constructors are said to be *inherited* by the derived class.
-Constructors of a base class can also be inherited as described in
-[[namespace.udecl]]. Inherited members can be referred to in expressions
-in the same manner as other members of the derived class, unless their
-names are hidden or ambiguous [[class.member.lookup]].
-[*Note 2*: The scope resolution operator `::` [[expr.prim.id.qual]] can
-be used to refer to a direct or indirect base member explicitly. This
-allows access to a name that has been redeclared in the derived class. A
-derived class can itself serve as a base class subject to access
-control; see  [[class.access.base]]. A pointer to a derived class can be
-implicitly converted to a pointer to an accessible unambiguous base
-class [[conv.ptr]]. An lvalue of a derived class type can be bound to a
-reference to an accessible unambiguous base class
-[[dcl.init.ref]]. — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
@@ -107,29 +108,26 @@ derived object [[intro.object]] is unspecified.
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
 “directly derived from” (see Figure [[fig:class.dag]]). An arrow
 need not have a physical representation in memory. A DAG of subobjects
-is often referred to as a “subobject lattice”.
 <a id="fig:class.dag"></a>
 ![Directed acyclic graph \[fig:class.dag\]](images/figdag.svg)
- — *end note*]
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
-[*Note 5*: A base class subobject might have a layout [[basic.stc]]
-different from the layout of a most derived object of the same type. A
-base class subobject might have a polymorphic behavior [[class.cdtor]]
-different from the polymorphic behavior of a most derived object of the
-same type. A base class subobject may be of zero size [[class]];
-however, two subobjects that have the same class type and that belong to
-the same most derived object must not be allocated at the same address
-[[expr.eq]]. — *end note*]
 ### Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
@@ -147,22 +145,22 @@ class D : public A, public B, public C { ... };
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
 specified by the semantics of initialization by constructor
-[[class.base.init]], cleanup [[class.dtor]], and storage layout (
-[[class.mem]], [[class.access.spec]]). — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
 be a direct and an indirect base class. There are limited things that
-can be done with such a class. The non-static data members and member
-functions of the direct base class cannot be referred to in the scope of
-the derived class. However, the static members, enumerations and types
-can be unambiguously referred to. — *end note*]
 [*Example 2*:
 ``` cpp
 class X { ... };
@@ -200,12 +198,12 @@ subobjects of class `L` as shown in Figure [[fig:class.nonvirt]].
 <a id="fig:class.nonvirt"></a>
 ![Non-virtual base \[fig:class.nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
-subobject is meant. The body of function `C::f` could refer to the
-member `next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
@@ -272,25 +270,24 @@ declared with the keyword `virtual` or if it overrides a virtual member
 function declared in a base class (see below).[^7]
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
-A class that declares or inherits a virtual function is called a
 *polymorphic class*.[^8]
-If a virtual member function `vf` is declared in a class `Base` and in a
-class `Derived`, derived directly or indirectly from `Base`, a member
-function `vf` with the same name, parameter-type-list [[dcl.fct]],
-cv-qualification, and ref-qualifier (or absence of same) as `Base::vf`
-is declared, then `Derived::vf` *overrides*[^9] `Base::vf`. For
-convenience we say that any virtual function overrides itself. A virtual
-member function `C::vf` of a class object `S` is a *final overrider*
-unless the most derived class [[intro.object]] of which `S` is a base
-class subobject (if any) declares or inherits another member function
-that overrides `vf`. In a derived class, if a virtual member function of
-a base class subobject has more than one final overrider the program is
-ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
@@ -316,11 +313,11 @@ void foo() {
 ``` cpp
 struct A { virtual void f(); };
 struct B : A { };
 struct C : A { void f(); };
-struct D : B, C { };            // OK: A::f and C::f are the final overriders
                                 // for the B and C subobjects, respectively
 ```
 — *end example*]
@@ -390,20 +387,20 @@ A virtual function shall not have a trailing *requires-clause*
 [[dcl.decl]].
 [*Example 5*:
 ``` cpp
 struct A {
   virtual void f() requires true;       // error: virtual function cannot be constrained[temp.constr.decl]
 };
 ```
 — *end example*]
-Even though destructors are not inherited, a destructor in a derived
-class overrides a base class destructor declared virtual; see
-[[class.dtor]] and  [[class.free]].
 The return type of an overriding function shall be either identical to
 the return type of the overridden function or *covariant* with the
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
@@ -420,14 +417,15 @@ the following criteria:
   as or less cv-qualification than the class type in the return type of
   `B::f`.
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
-complete at the point of declaration of `D::f` or shall be the class
-type `D`. When the overriding function is called as the final overrider
-of the overridden function, its result is converted to the type returned
-by the (statically chosen) overridden function [[expr.call]].
 [*Example 6*:
 ``` cpp
 class B { };
@@ -448,11 +446,11 @@ struct No_good : public Base {
 class A;
 struct Derived : public Base {
     void vf1();     // virtual and overrides Base::vf1()
     void vf2(int);  // not virtual, hides Base::vf2()
     char vf3();     // error: invalid difference in return type only
-    D*   vf4();     // OK: returns pointer to derived class
     A*   vf5();     // error: returns pointer to incomplete class
     void f();
 };
 void g() {
@@ -481,12 +479,12 @@ object (the static type) [[expr.call]]. — *end note*]
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
 function cannot be a non-member [[dcl.fct.spec]] function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
-virtual function declared in one class can be declared a friend (
-[[class.friend]]) in another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
 pure [[class.abstract]] in that class, or both; no diagnostic is
 required [[basic.def.odr]].
@@ -595,14 +593,13 @@ void D::f() { ... B::f(); }
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
-A function with a deleted definition [[dcl.fct.def]] shall not override
-a function that does not have a deleted definition. Likewise, a function
-that does not have a deleted definition shall not override a function
-with a deleted definition.
 A `consteval` virtual function shall not override a virtual function
 that is not `consteval`. A `consteval` virtual function shall not be
 overridden by a virtual function that is not `consteval`.
@@ -624,12 +621,12 @@ below. — *end note*]
 A class is an *abstract class* if it has at least one pure virtual
 function.
 [*Note 3*: An abstract class can be used only as a base class of some
 other class; no objects of an abstract class can be created except as
-subobjects of a class derived from it ([[basic.def]],
-[[class.mem]]). — *end note*]
 A pure virtual function need be defined only if called with, or as if
 with [[class.dtor]], the *qualified-id* syntax [[expr.prim.id.qual]].
 [*Example 1*:
@@ -663,17 +660,18 @@ struct C {
 [*Note 5*: An abstract class type cannot be used as a parameter or
 return type of a function being defined [[dcl.fct]] or called
 [[expr.call]], except as specified in [[dcl.type.simple]]. Further, an
 abstract class type cannot be used as the type of an explicit type
-conversion ([[expr.static.cast]], [[expr.reinterpret.cast]],
-[[expr.const.cast]]), because the resulting prvalue would be of abstract
-class type [[basic.lval]]. However, pointers and references to abstract
-class types can appear in such contexts. — *end note*]
-A class is abstract if it contains or inherits at least one pure virtual
-function for which the final overrider is pure virtual.
 [*Example 3*:
 ``` cpp
 class ab_circle : public shape {
@@ -700,11 +698,11 @@ 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

 ## Derived classes <a id="class.derived">[[class.derived]]</a>
+### General <a id="class.derived.general">[[class.derived.general]]</a>
 A list of base classes can be specified in a class definition using the
 notation:
 ``` bnf
 base-clause:
 ```
 The optional *attribute-specifier-seq* appertains to the
 *base-specifier*.
+The component names of a *class-or-decltype* are those of its
+*nested-name-specifier*, *type-name*, and/or *simple-template-id*. A
+*class-or-decltype* shall denote a (possibly cv-qualified) class type
 that is not an incompletely defined class [[class.mem]]; any
 cv-qualifiers are ignored. The class denoted by the *class-or-decltype*
 of a *base-specifier* is called a *direct base class* for the class
+being defined. The lookup for the component name of the *type-name* or
+*simple-template-id* is type-only [[basic.lookup]]. A class `B` is a
+base class of a class `D` if it is a direct base class of `D` or a
+direct base class of one of `D`’s base classes. A class is an
+*indirect base class* of another if it is a base class but not a direct
+base class. A class is said to be (directly or indirectly) *derived*
+from its (direct or indirect) base classes.
 [*Note 1*: See [[class.access]] for the meaning of
 *access-specifier*. — *end note*]
+Members of a base class are also members of the derived class.
+[*Note 2*: Constructors of a base class can be explicitly inherited
+[[namespace.udecl]]. Base class members can be referred to in
+expressions in the same manner as other members of the derived class,
+unless their names are hidden or ambiguous [[class.member.lookup]]. The
+scope resolution operator `::` [[expr.prim.id.qual]] can be used to
+refer to a direct or indirect base member explicitly, even if it is
+hidden in the derived class. A derived class can itself serve as a base
+class subject to access control; see  [[class.access.base]]. A pointer
+to a derived class can be implicitly converted to a pointer to an
+accessible unambiguous base class [[conv.ptr]]. An lvalue of a derived
+class type can be bound to a reference to an accessible unambiguous base
+class [[dcl.init.ref]]. — *end note*]
 The *base-specifier-list* specifies the type of the *base class
 subobjects* contained in an object of the derived class type.
 [*Example 1*:
 [*Note 3*:  A derived class and its base class subobjects can be
 represented by a directed acyclic graph (DAG) where an arrow means
 “directly derived from” (see Figure [[fig:class.dag]]). An arrow
 need not have a physical representation in memory. A DAG of subobjects
+is often referred to as a “subobject lattice”. — *end note*]
 <a id="fig:class.dag"></a>
 ![Directed acyclic graph \[fig:class.dag\]](images/figdag.svg)
 [*Note 4*: Initialization of objects representing base classes can be
 specified in constructors; see  [[class.base.init]]. — *end note*]
+[*Note 5*: A base class subobject can have a layout different from the
+layout of a most derived object of the same type. A base class subobject
+can have a polymorphic behavior [[class.cdtor]] different from the
+polymorphic behavior of a most derived object of the same type. A base
+class subobject can be of zero size; however, two subobjects that have
+the same class type and that belong to the same most derived object
+cannot be allocated at the same address [[intro.object]]. — *end note*]
 ### Multiple base classes <a id="class.mi">[[class.mi]]</a>
 A class can be derived from any number of base classes.
 — *end example*]
 [*Note 2*: The order of derivation is not significant except as
 specified by the semantics of initialization by constructor
+[[class.base.init]], cleanup [[class.dtor]], and storage layout
+[[class.mem]], [[class.access.spec]]. — *end note*]
 A class shall not be specified as a direct base class of a derived class
 more than once.
 [*Note 3*: A class can be an indirect base class more than once and can
 be a direct and an indirect base class. There are limited things that
+can be done with such a class; lookup that finds its non-static data
+members and member functions in the scope of the derived class will be
+ambiguous. However, the static members, enumerations and types can be
+unambiguously referred to. — *end note*]
 [*Example 2*:
 ``` cpp
 class X { ... };
 <a id="fig:class.nonvirt"></a>
 ![Non-virtual base \[fig:class.nonvirt\]](images/fignonvirt.svg)
 In such lattices, explicit qualification can be used to specify which
+subobject is meant. The body of function `C::f` can refer to the member
+`next` of each `L` subobject:
 ``` cpp
 void C::f() { A::next = B::next; }      // well-formed
 ```
 function declared in a base class (see below).[^7]
 [*Note 1*: Virtual functions support dynamic binding and
 object-oriented programming. — *end note*]
+A class with a virtual member function is called a
 *polymorphic class*.[^8]
+If a virtual member function F is declared in a class B, and, in a class
+D derived (directly or indirectly) from B, a declaration of a member
+function G corresponds [[basic.scope.scope]] to a declaration of F,
+ignoring trailing *requires-clause*s, then G *overrides*[^9]
+F. For convenience we say that any virtual function overrides itself. A
+virtual member function V of a class object S is a *final overrider*
+unless the most derived class [[intro.object]] of which S is a base
+class subobject (if any) has another member function that overrides V.
+In a derived class, if a virtual member function of a base class
+subobject has more than one final overrider the program is ill-formed.
 [*Example 1*:
 ``` cpp
 struct A {
 ``` cpp
 struct A { virtual void f(); };
 struct B : A { };
 struct C : A { void f(); };
+struct D : B, C { };            // OK, A::f and C::f are the final overriders
                                 // for the B and C subobjects, respectively
 ```
 — *end example*]
 [[dcl.decl]].
 [*Example 5*:
 ``` cpp
+template<typename T>
 struct A {
   virtual void f() requires true;       // error: virtual function cannot be constrained[temp.constr.decl]
 };
 ```
 — *end example*]
+The *ref-qualifier*, or lack thereof, of an overriding function shall be
+the same as that of the overridden function.
 The return type of an overriding function shall be either identical to
 the return type of the overridden function or *covariant* with the
 classes of the functions. If a function `D::f` overrides a function
 `B::f`, the return types of the functions are covariant if they satisfy
   as or less cv-qualification than the class type in the return type of
   `B::f`.
 If the class type in the covariant return type of `D::f` differs from
 that of `B::f`, the class type in the return type of `D::f` shall be
+complete at the locus [[basic.scope.pdecl]] of the overriding
+declaration or shall be the class type `D`. When the overriding function
+is called as the final overrider of the overridden function, its result
+is converted to the type returned by the (statically chosen) overridden
+function [[expr.call]].
 [*Example 6*:
 ``` cpp
 class B { };
 class A;
 struct Derived : public Base {
     void vf1();     // virtual and overrides Base::vf1()
     void vf2(int);  // not virtual, hides Base::vf2()
     char vf3();     // error: invalid difference in return type only
+    D*   vf4();     // OK, returns pointer to derived class
     A*   vf5();     // error: returns pointer to incomplete class
     void f();
 };
 void g() {
 [*Note 4*: The `virtual` specifier implies membership, so a virtual
 function cannot be a non-member [[dcl.fct.spec]] function. Nor can a
 virtual function be a static member, since a virtual function call
 relies on a specific object for determining which function to invoke. A
+virtual function declared in one class can be declared a friend
+[[class.friend]] in another class. — *end note*]
 A virtual function declared in a class shall be defined, or declared
 pure [[class.abstract]] in that class, or both; no diagnostic is
 required [[basic.def.odr]].
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 — *end example*]
+A deleted function [[dcl.fct.def]] shall not override a function that is
+not deleted. Likewise, a function that is not deleted shall not override
+a deleted function.
 A `consteval` virtual function shall not override a virtual function
 that is not `consteval`. A `consteval` virtual function shall not be
 overridden by a virtual function that is not `consteval`.
 A class is an *abstract class* if it has at least one pure virtual
 function.
 [*Note 3*: An abstract class can be used only as a base class of some
 other class; no objects of an abstract class can be created except as
+subobjects of a class derived from it
+[[basic.def]], [[class.mem]]. — *end note*]
 A pure virtual function need be defined only if called with, or as if
 with [[class.dtor]], the *qualified-id* syntax [[expr.prim.id.qual]].
 [*Example 1*:
 [*Note 5*: An abstract class type cannot be used as a parameter or
 return type of a function being defined [[dcl.fct]] or called
 [[expr.call]], except as specified in [[dcl.type.simple]]. Further, an
 abstract class type cannot be used as the type of an explicit type
+conversion
+[[expr.static.cast]], [[expr.reinterpret.cast]], [[expr.const.cast]],
+because the resulting prvalue would be of abstract class type
+[[basic.lval]]. However, pointers and references to abstract class types
+can appear in such contexts. — *end note*]
+A class is abstract if it has at least one pure virtual function for
+which the final overrider is pure virtual.
 [*Example 3*:
 ``` cpp
 class ab_circle : public shape {
 `circle::draw()` must be provided.
 — *end example*]
 [*Note 6*: An abstract class can be derived from a class that is not
+abstract, and a pure virtual function can override a virtual function
 which is not pure. — *end note*]
 Member functions can be called from a constructor (or destructor) of an
 abstract class; the effect of making a virtual call [[class.virtual]] to
 a pure virtual function directly or indirectly for the object being

Diff to HTML by rtfpessoa