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

Files changed (1) hide show

tmp/tmp4ms8fnt1/{from.md → to.md} +56 -35

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

@@ -1,25 +1,29 @@
-## 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 {
@@ -113,10 +117,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
@@ -124,11 +141,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
@@ -139,13 +156,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 {
@@ -176,39 +193,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 {
@@ -231,22 +248,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
@@ -260,26 +277,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
@@ -294,14 +311,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(); };
@@ -311,10 +328,14 @@ 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.

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

Diff to HTML by rtfpessoa