仮想関数指定子

class B {
    virtual void do_f(); // プライベートメンバ。
 public:
    void f() { do_f(); } // パブリック継承。
};
struct D : public B {
    void do_f() override; // B::do_f をオーバーライドします。
};

int main()
{
    D d;
    B* bp = &d;
    bp->f(); // (間接的に) D::do_f() を呼びます。
}

struct A { virtual void f(); };     // A::f は仮想です。
struct B : A { void f(); };         // B::f は A::f を B でオーバーライドします。
struct C : virtual B { void f(); }; // C::f は A::f を C でオーバーライドします。
struct D : virtual B {}; // D はオーバーライダーを導入しません。 B::f が D の最終です。
struct E : C, D  {       // E はオーバーライダーを導入しません。 C::f が E の最終です。
    using A::f; // 関数宣言ではありません。 名前探索で A::f を可視にするだけです。
};
int main() {
   E e;
   e.f();    // 仮想関数呼び出しは e における最終オーバーライダー C::f を呼びます。
   e.E::f(); // 非仮想呼び出しは E で可視な A::f を呼びます。
}

struct A {
    virtual void f();
};
struct VB1 : virtual A {
    void f(); // A::f をオーバーライドします。
};
struct VB2 : virtual A {
    void f(); // A::f をオーバーライドします。
};
// struct Error : VB1, VB2 {
//     // エラー、 A::f は2つの最終オーバーライダーを持ちます。
// };
struct Okay : VB1, VB2 {
    void f(); // OK、これが A::f に対する最終オーバーライダーになります。
};
struct VB1a : virtual A {}; // オーバーライダーを宣言しません。
struct Da : VB1a, VB2 {
    // OK、 Da における A::f の最終オーバーライダーは VB2::f です。
};

struct B {
    virtual void f();
};
struct D : B {
    void f(int); // D::f は B::f を隠蔽します (引数リストが違っています)。
};
struct D2 : D {
    void f(); // D2::f は B::f をオーバーライドします (可視でないことは問題になりません)。
};

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(); // B::f() を呼びます。
    d_as_b.f(); // B::f() を呼びます。
    d2_as_b.f(); // D2::f() を呼びます。

    d_as_d.f(); // エラー、 D における名前探索は f(int) のみを発見します。
    d2_as_d.f(); // エラー、 D における名前探索は 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; // Derived において、 B は D のアクセス可能な基底です。
};

class A; // 前方宣言されたクラスは不完全型です。

struct Derived : public Base {
    void vf1();    // 仮想。 Base::vf1() をオーバーライドします。
    void vf2(int); // 非仮想。 Base::vf2() を隠蔽します。
//  char vf3();    // エラー、 Base::vf3 をオーバーライドしますが、
                   // 異なった共変でない戻り値の型を持ちます。
    D* vf4();      // Base::vf4() をオーバーライドし、共変戻り値型を持ちます。
//  A* vf5();      // エラー、 A は不完全型です。
};

int main()
{
    Derived d;
    Base& br = d;
    Derived& dr = d;

    br.vf1(); // Derived::vf1() を呼びます。
    br.vf2(); // Base::vf2() を呼びます。
//  dr.vf2(); // エラー、 vf2(int) が vf2() を隠蔽します。

    B* p = br.vf4(); // Derived::vf4() を呼び、その結果を B* に変換します。
    D* q = dr.vf4(); // Derived::vf4() を呼び、その結果を B* に変換しません。

}

class Base {
 public:
    virtual ~Base() { /* Base のリソースを解放します。 */ }
};

class Derived : public Base {
    ~Derived() { /* Derived のリソースを解放します。 */ }
};

int main()
{
    Base* b = new Derived;
    delete b; // Base::~Base() の仮想関数呼び出しを行います。
              // これは virtual であるため Derived::~Derived() を呼びます。
              // Derived::~Derived() は派生クラスのリソースを解放することができ、
              // その後、通常の破棄順序に従って Base::~Base() を呼びます。
}

struct V {
    virtual void f();
    virtual void g();
};

struct A : virtual V {
    virtual void f(); // A::f は A における V::f の最終オーバーライダーです。
};
struct B : virtual V {
    virtual void g(); // B::g は B における V::g の最終オーバーライダーです。
    B(V*, A*);
};
struct D : A, B {
    virtual void f(); // D::f は D における V::f の最終オーバーライダーです。
    virtual void g(); // D::g は D における V::g の最終オーバーライダーです。

    // 注: A は B より前に初期化されます。
    D() : B((A*)this, this) 
    {
    }
};

// B のコンストラクタ。 D のコンストラクタから呼ばれます。
B::B(V* v, A* a)
{
    f(); // V::f の仮想呼び出し (D が最終オーバーライダーを持ちますが、 D はまだ存在しません)。
    g(); // B::g の仮想呼び出し (B における最終オーバーライダーです)。

    v->g(); // v の型 V は B の基底であり、仮想呼び出しは前と同様に B::g を呼びます。

    a->f(); // a の型 A は B の基底ではありません。 これは継承階層の別の分岐に属します。
            // その分岐を通した仮想呼び出しの試みは、たとえこの場合 A がすでに完全に
            // 構築されているとしても (D の基底のリスト内で A は B より前に現れるため、
            // A は B より前に構築されます)、未定義動作を発生させます。
            // 実際のところ、 A::f の仮想呼び出しは B の仮想メンバ関数テーブル
            // (B の構築中はそれがアクティブであるため) を用いて試みられます。
}