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

Files changed (1) hide show

tmp/tmp2umh52rf/{from.md → to.md} +59 -16

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

@@ -1,10 +1,12 @@
 ## Virtual functions <a id="class.virtual">[[class.virtual]]</a>
-Virtual functions support dynamic binding and object-oriented
-programming. 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`
@@ -15,10 +17,12 @@ 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.
 ``` cpp
 struct A {
   virtual void f();
 };
 struct B : virtual A {
@@ -33,18 +37,26 @@ void foo() {
   c.f();              // calls B::f, the final overrider
   c.C::f();           // calls A::f because of the using-declaration
 }
 ```
 ``` 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
 ```
 A virtual member function does not have to be visible to be overridden,
 for example,
 ``` cpp
 struct B {
@@ -62,28 +74,36 @@ the function `f(int)` in class `D` hides the virtual function `f()` in
 its base class `B`; `D::f(int)` is not a virtual function. However,
 `f()` declared in class `D2` has the same name and the same parameter
 list as `B::f()`, and therefore is a virtual function that overrides the
 function `B::f()` even though `B::f()` is not visible in class `D2`.
 If a virtual function `f` in some class `B` is marked with the
 *virt-specifier* `final` and in a class `D` derived from `B` a function
 `D::f` overrides `B::f`, the program is ill-formed.
 ``` cpp
 struct B {
   virtual void f() const final;
 };
 struct D : B {
   void f() const;     // error: D::f attempts to override final B::f
 };
 ```
 If a virtual function is marked with the *virt-specifier* `override` and
 does not override a member function of a base class, the program is
 ill-formed.
 ``` cpp
 struct B {
   virtual void f(int);
 };
@@ -91,10 +111,12 @@ struct D : B {
   virtual void f(long) override;  // error: wrong signature overriding B::f
   virtual void f(int) override;   // OK
 };
 ```
 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
@@ -119,10 +141,12 @@ 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]]).
 ``` cpp
 class B { };
 class D : private B { friend class Derived; };
 struct Base {
   virtual void vf1();
@@ -161,27 +185,32 @@ void g() {
                                 // convert the result to B*
   dp->vf2();                    // ill-formed: argument mismatch
 }
 ```
-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]]).
-The `virtual` specifier implies membership, so a virtual function cannot
-be a nonmember ([[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.
 A virtual function declared in a class shall be defined, or declared
-pure ([[class.abstract]]) in that class, or both; but no diagnostic is
 required ([[basic.def.odr]]).
-here are some uses of virtual functions with multiple base classes:
 ``` cpp
 struct A {
   virtual void f();
 };
@@ -211,10 +240,14 @@ void foo() {
 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`.
 The following example shows a function that does not have a unique final
 overrider:
 ``` cpp
 struct A {
@@ -240,10 +273,14 @@ struct Okay : VB1, VB2 {
 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.
 The following example uses the well-formed classes from above.
 ``` cpp
 struct VB1a : virtual A {       // does not declare f
 };
@@ -255,23 +292,29 @@ void foe() {
   VB1a*  vb1ap = new Da;
   vb1ap->f();                   // calls VB2::f
 }
 ```
 Explicit qualification with the scope operator ([[expr.prim]])
 suppresses the virtual call mechanism.
 ``` cpp
 class B { public: virtual void f(); };
 class D : public B { public: void f(); };
-void D::f() { /* ... */ B::f(); }
 ```
 Here, the function call in `D::f` really does call `B::f` and not
 `D::f`.
 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>
+[*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`
 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 {
   virtual void f();
 };
 struct B : virtual A {
   c.f();              // calls B::f, the final overrider
   c.C::f();           // calls A::f because of the using-declaration
 }
 ```
+— *end example*]
+[*Example 2*:
 ``` 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*]
+[*Note 2*:
 A virtual member function does not have to be visible to be overridden,
 for example,
 ``` cpp
 struct B {
 its base class `B`; `D::f(int)` is not a virtual function. However,
 `f()` declared in class `D2` has the same name and the same parameter
 list as `B::f()`, and therefore is a virtual function that overrides the
 function `B::f()` even though `B::f()` is not visible in class `D2`.
+— *end note*]
 If a virtual function `f` in some class `B` is marked with the
 *virt-specifier* `final` and in a class `D` derived from `B` a function
 `D::f` overrides `B::f`, the program is ill-formed.
+[*Example 3*:
 ``` cpp
 struct B {
   virtual void f() const final;
 };
 struct D : B {
   void f() const;     // error: D::f attempts to override final B::f
 };
 ```
+— *end example*]
 If a virtual function is marked with the *virt-specifier* `override` and
 does not override a member function of a base class, the program is
 ill-formed.
+[*Example 4*:
 ``` cpp
 struct B {
   virtual void f(int);
 };
   virtual void f(long) override;  // error: wrong signature overriding B::f
   virtual void f(int) override;   // OK
 };
 ```
+— *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
 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 {
   virtual void vf1();
                                 // 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 {
   virtual void f();
 };
 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
 struct A {
 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
 };
   VB1a*  vb1ap = new Da;
   vb1ap->f();                   // calls VB2::f
 }
 ```
+— *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(); };
+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.

Diff to HTML by rtfpessoa