虚基类和多重继承下构造函数的顺序

1.没有虚基类:

#include <iostream>
#include <cstdio>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A" << endl;
    };
};

class B : public A
{
public:
    B()
    {
        cout << "B" << endl;
    };
};

class C : public A
{
public:
    C()
    {
        cout << "C" << endl;
    };
};

class D : public B, C
{
public:
    D()
    {
        cout << "D" << endl;
    };
};

int main()
{
    B b; //输出: A B 先构造基类,再构造子类
    D d; //输出: A B A C D
    return 0;
}

2.有虚基类:

#include <iostream>
#include <cstdio>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A" << endl;
    };
};

class VB : virtual public A
{
public:
    VB()
    {
        cout << "VB" << endl;
    };
};

class VC : virtual public A
{
public:
    VC()
    {
        cout << "VC" << endl;
    };
};

class VD : public VB, VC
{
public:
    VD()
    {
        cout << "VD" << endl;
    };
};


int main()
{
    VD vd; //输出: A VB VC VD
    //虚基类的subobject总是在最深的地方最先被构造
    return 0;
}

3.存在虚基类的多继承:

#include <iostream>
using namespace std;

class A
{
public:
    A(const string& s)
    {
        cout << "A " << s << endl;
    }
    virtual ~A() {}
};

class B
{
public:
    B(const string& s)
    {
        cout << "B " << s << endl;
    }
    virtual ~B() {}
};

class C
{
public:
    C(const string& s)
    {
        cout << "C " << s << endl;
    }
    virtual ~C() {}
};

class D
{
public:
    D(const string& s)
    {
        cout << "D " << s << endl;
    }
    virtual ~D() {}
};

class E : public A, virtual public B, virtual public C
{
public:
    E(const string& s) : A("from E"), B("from E"), C("from E")
    {
        cout << "E " << s << endl;
    }
};

class F : virtual public B, virtual public C, public D
{
public:
    F(const string& s) : B("from F"), C("from F"), D("from F")
    {
        cout << "F " << s << endl;
    }
};

class G : public E, public F
{
public:
    G(const string& s) : B("from G"), C("from G"), E("from G"),  F("from G")
    {
        cout << "G " << s << endl;
    }
};

int main()
{
    //虚基类的构造函数最先执行
    G g("from main");
}

输出： 

引用

B from G 
C from G 
A from E 
E from G 
D from F 
F from G 
G from main

总结：虚基类构造函数最先被执行，然后按照从左到右，从上到下的顺序依次执行每一个构造函数。