虚函数说明符

#include <iostream>
struct Base {
   virtual void f() {
       std::cout << "base\n";
   }
};
struct Derived : Base {
    void f() override { // 'override' is optional
        std::cout << "derived\n";
    }
};
int main()
{
    Base b;
    Derived d;
 
    // virtual function call through reference
    Base& br = b; // the type of br is Base&
    Base& dr = d; // the type of dr is Base& as  well
    br.f( // prints "base"
    dr.f( // prints "derived"
 
    // virtual function call through pointer
    Base* bp = &b; // the type of bp is Base*
    Base* dp = &d; // the type of dp is Base* as  well
    bp->f( // prints "base"
    dp->f( // prints "derived"
 
    // non-virtual function call
    br.Base::f( // prints "base"
    dr.Base::f( // prints "base"
}

class B {
    virtual void do_f( // private member
 public:
    void f() { do_f( } // public interface
};
struct D : public B {
    void do_f() override; // overrides B::do_f
};
 
int main()
{
    D d;
    B* bp = &d;
    bp->f( // internally calls D::do_f(
}

struct A { virtual void f( };     // A::f is virtual
struct B : A { void f( };         // B::f overrides A::f in B
struct C : virtual B { void f( }; // C::f overrides A::f in C
struct D : virtual B {}; // D does not introduce an overrider, B::f is final in D
struct E : C, D  {       // E does not introduce an overrider, C::f is final in E
    using A::f; // not a function declaration, just makes A::f visible to lookup
};
int main() {
   E e;
   e.f(    // virtual call calls C::f, the final overrider in e
   e.E::f( // non-virtual call calls A::f, which is visible in E
}

struct A {
    virtual void f(
};
struct VB1 : virtual A {
    void f( // overrides A::f
};
struct VB2 : virtual A {
    void f( // overrides A::f
};
// struct Error : VB1, VB2 {
//     // Error: A::f has two final overriders in Error
// };
struct Okay : VB1, VB2 {
    void f( // OK: this is the final overrider for A::f
};
struct VB1a : virtual A {}; // does not declare an overrider
struct Da : VB1a, VB2 {
    // in Da, the final overrider of A::f is VB2::f
};

struct B {
    virtual void f(
};
struct D : B {
    void f(int // D::f hides B::f (wrong parameter list)
};
struct D2 : D {
    void f( // D2::f overrides B::f (doesn't matter that it's not visible)
};
 
int main()
{
    B b;   B& b_as_b   = b;
    D d;   B& d_as_b   = d;    D& d_as_d = d;
    D2 d2; B& d2_as_b  = d2;   D& d2_as_d = d2;
 
    b_as_b.f( // calls B::f()
    d_as_b.f( // calls B::f()
    d2_as_b.f( // calls D2::f()
 
    d_as_d.f( // Error: lookup in D finds only f(int)
    d2_as_d.f( // Error: lookup in D finds only f(int)
}

class B {};
 
struct Base {
    virtual void vf1(
    virtual void vf2(
    virtual void vf3(
    virtual B* vf4(
    virtual B* vf5(
};
 
class D : private B {
    friend struct Derived; // in Derived, B is an accessible base of D
};
 
class A; // forward-declared class is an incomplete type
 
struct Derived : public Base {
    void vf1(    // virtual, overrides Base::vf1()
    void vf2(int // non-virtual, hides Base::vf2()
//  char vf3(    // Error: overrides Base::vf3, but has different
                   // and non-covariant return type
    D* vf4(      // overrides Base::vf4() and has covariant return type
//  A* vf5(      // Error: A is incomplete type
};
 
int main()
{
    Derived d;
    Base& br = d;
    Derived& dr = d;
 
    br.vf1( // calls Derived::vf1()
    br.vf2( // calls Base::vf2()
//  dr.vf2( // Error: vf2(int) hides vf2()
 
    B* p = br.vf4( // calls Derived::vf4() and converts the result to B*
    D* q = dr.vf4( // calls Derived::vf4() and does not convert
                     //  the result to B*
 
}

class Base {
 public:
    virtual ~Base() { /* releases Base's resources */ }
};
 
class Derived : public Base {
    ~Derived() { /* releases Derived's resources */ }
};
 
int main()
{
    Base* b = new Derived;
    delete b; // Makes a virtual function call to Base::~Base()
              // since it is virtual, it calls Derived::~Derived() which can
              // release resources of the derived class, and then calls
              // Base::~Base() following the usual order of destruction
}

struct V {
    virtual void f(
    virtual void g(
};
 
struct A : virtual V {
    virtual void f( // A::f is the final overrider of V::f in A
};
struct B : virtual V {
    virtual void g( // B::g is the final overrider of V::g in B
    B(V*, A*
};
struct D : A, B {
    virtual void f( // D::f is the final overrider of V::f in D
    virtual void g( // D::g is the final overrider of V::g in D
 
    // note: A is initialized before B
    D() : B((A*)this, this) 
    {
    }
};
 
// the constructor of B, called from the constructor of D 
B::B(V* v, A* a)
{
    f( // virtual call to V::f (although D has the final overrider, D doesn't exist)
    g( // virtual call to B::g, which is the final overrider in B 
 
    v->g( // v's type V is base of B, virtual call calls B::g as before
 
    a->f( // a’s type A is not a base of B. it belongs to a different branch of the
            // hierarchy. Attempting a virtual call through that branch causes
            // undefined behavior even though A was already fully constructed in this
            // case (it was constructed before B since it appears before B in the list
            // of the bases of D). In practice, the virtual call to A::f will be
            // attempted using B's virtual member function table, since that's what
            // is active during B's construction)
}

 © cppreference.com