虚继承

#include <bits/stdc++.h>
using namespace std;

class Ap {
    public:
        Ap(int a) {
            this->a = a;
            cout << "constructor Ap " << a << endl;
        }
        virtual ~Ap() {}

        int a;
} ;

class A : public Ap {
    public:
        A(int a) : Ap(a) {
            cout << "constructor A " << a << endl;
        }
        virtual ~A() {}

        virtual void F1() {
            cout << "A F1" << endl;
        }

        virtual void F2() {
            cout << "A F2" << endl;
        }
} ;

class B1 : virtual public A {
    public:
        B1(int a) : A(a) {
            cout << "constructor B1 " << a << endl;
        }
        virtual ~B1() {}

        virtual void F1() {
            cout << "B1" << endl;
        }
} ;

class B2 : virtual public A {
    public:
        B2(int a) : A(a) {
            cout << "constructor B2 " << a << endl;
        }
        virtual ~B2() {}

        //virtual void F2() {
            //cout << "B2" << endl;
        //}
} ;

class C : public B1, public B2 {
    public:
        C(int a) : A(a), B1(a), B2(a) {
            cout << "constructor C " << a << endl;
        }
        virtual ~C() {}

        virtual void F2() {
            a = 1;
            cout << "C" << endl;
        }
} ;

void F2(A *p) {
    p->F2();
}

void F1(A *p) {
    p->F1();
}

int main() {
    A a(1);
    B1 b1(2);
    B2 b2(3);
    C c(4);

    cout << a.a << ' ' << b1.a << ' ' << b2.a << ' ' << c.a << endl;
    F1(&c);
    F2(&a);
    F2(&b2);
    F2(&c);
    cout << a.a << ' ' << b1.a << ' ' << b2.a << ' ' << c.a << endl;

    return 0;
}

　　记录一下代码，没有默认构造器的情况下，初始化需要把所有相关的虚函数加进去。

　　因为类A只有一个副本，所以最终只是初始化了一次。

#include <bits/stdc++.h>
using namespace std;

class A {
    public:
        A(int a) {
            cout << "A construct" << endl;
        } 
        ~A() {
            cout << "A destruct" << endl;
        }
} ;

class B : public A {
    public:
        B(int a) : A(a) {
            cout << "B construct" << endl;
        }
        ~B() {
            cout << "B destruct" << endl;
        }
} ;

class C1 : virtual public B {
    public:
        C1(int a) : B(a) {
            cout << "C1 construct" << endl;
        }
        ~C1() {
            cout << "C1 destruct" << endl;
        }
} ;

class C2 : virtual public B {
    public:
        C2(int a) : B(a) {
            cout << "C2 construct" << endl;
        }
        ~C2() {
            cout << "C2 destruct" << endl;
        }
} ;

class D1 : virtual public C1, virtual public C2 {
    public:
        D1(int a) : B(a), C1(a), C2(a) {
            cout << "D1 construct" << endl;
        }
        ~D1() {
            cout << "D1 destruct" << endl;
        }
} ;

class D2 : virtual public C1, virtual public C2 {
    public:
        D2(int a) : B(a), C1(a), C2(a) {
            cout << "D2 construct" << endl;
        }
        ~D2() {
            cout << "D2 destruct" << endl;
        }
} ;

class E1 : virtual public D1, virtual public D2 {
    public:
        E1(int a) : B(a), C1(a), C2(a), D1(a), D2(a) {
            cout << "E1 construct" << endl;
        }
        ~E1() {
            cout << "E1 destruct" << endl;
        }
} ;

class E2 : virtual public D1, virtual public D2 {
    public:
        E2(int a) : B(a), C1(a), C2(a), D1(a), D2(a) {
            cout << "E2 construct" << endl;
        }
        ~E2() {
            cout << "E2 destruct" << endl;
        }
} ;

class F : virtual public E1, virtual public E2 {
    public:
        F(int a) : B(a), C1(a), C2(a), D1(a), D2(a), E1(a), E2(a) {
            cout << "F construct" << endl;
        }
        ~F() {
            cout << "F destruct" << endl;
        }
} ;

int main() {
    F obj(1);

    return 0;
}

——written by LyonLys