多继承与虚继承

多继承

一般情况下，派生类都只有一个基类，称为单继承。除此之外，C++也支持多继承，即一个派生类可以有两个或多个基类。

多继承的定义

多继承的语法如下,假设已经声明了了类A、类B和类C，那么可以这样来声明派生类D：

class D: public A, private B, protected C{
    //类D新增加的成员
}

多继承的构造函数

多继承形式下的构造函数和单继承形式基本相同，只是要在派生类的构造函数中调用多个基类的构造函数，上述类D的构造函数如下：

D(形参列表): A(实参列表), B(实参列表), C(实参列表){
    //其他操作
}

基类构造函数的调用顺序和和它们在派生类构造函数中出现的顺序无关，而是和声明派生类时基类出现的顺序相同。

深入思考

如果上述中的基类A、B、C中含有相同名字的成员变量或者成员函数时，可能就会出现命名冲突，导致编译器不知道是操作哪一个成员变量或者成员函数。解决这个问题通常是使用类名::成员数据的访问形式，如下的例子：

//基类
class BaseA{
public:
    BaseA(int a, int b);
    ~BaseA();
public:
    void show();
protected:
    int m_a;
    int m_b;
};
BaseA::BaseA(int a, int b): m_a(a), m_b(b){
    cout<<"BaseA constructor"<<endl;
}
BaseA::~BaseA(){
    cout<<"BaseA destructor"<<endl;
}
void BaseA::show(){
    cout<<"m_a = "<<m_a<<endl;
    cout<<"m_b = "<<m_b<<endl;
}

//基类
class BaseB{
public:
    BaseB(int c, int d);
    ~BaseB();
    void show();
protected:
    int m_c;
    int m_d;
};
BaseB::BaseB(int c, int d): m_c(c), m_d(d){
    cout<<"BaseB constructor"<<endl;
}
BaseB::~BaseB(){
    cout<<"BaseB destructor"<<endl;
}
void BaseB::show(){
    cout<<"m_c = "<<m_c<<endl;
    cout<<"m_d = "<<m_d<<endl;
}

//派生类
class Derived: public BaseA, public BaseB{
public:
    Derived(int a, int b, int c, int d, int e);
    ~Derived();
public:
    void display();
private:
    int m_e;
};
Derived::Derived(int a, int b, int c, int d, int e): BaseA(a, b), BaseB(c, d), m_e(e){
    cout<<"Derived constructor"<<endl;
}
Derived::~Derived(){
    cout<<"Derived destructor"<<endl;
}
void Derived::display(){
    BaseA::show();  //调用BaseA类的show()函数
    BaseB::show();  //调用BaseB类的show()函数
    cout<<"m_e = "<<m_e<<endl;
}

虚继承

引入虚继承

假如有如下代码：

class Top
{ 
public: 
    int a;
};

class Left : public Top
{ 
public: 
    int b;
}; 

class Right : public Top
{ 
public: 
    int c;
}; 

class Bottom : public Left, public Right
{ 
public: 
    int d;
};

使用UML图，我们可以把这个层次结构表示为：

注意Top被继承了两次，这意味着类型Bottom的一个实例bottom将有两个叫做a的元素（分别为bottom.Left::a和bottom.Right::a）。
Left、Right和Bottom在内存中是如何布局的？
让我们先看一个简单的例子，Left和Right拥有如下的结构：

请注意第一个属性是从Top继承下来的。这意味着在下面两条语句后left和top指向了同一地址，我们可以把Left Object当成Top Object来使用(很明显，Right与此也类似)。代码如下：

Left* left = new Left(); 
Top* top = left;

那Buttom呢？GCC中该类的内存布局如下

如果我们提升Bottom指针，会发生什么事呢？

Bottom* bottom = new Bottom();
Left* left = bottom;

这段代码工作正常。我们可以把一个Bottom的对象当作一个Left对象来使用，因为两个类的内存部局是一样的。那么，如果将其提升为Right呢？会发生什么事？

Right* right = bottom;

经过这一步，我们可以像操作正常Right对象一样使用right指针访问bottom。虽然，bottom与right现在指向两个不同的内存地址。出于完整性的缘故，思考一下执行下面这条语句时会出现什么状况。

Top* top = bottom;

是的，什么也没有。这条语句是有歧义的，编译器将会报错：error: Top' is an ambiguous base ofBottom’

Top* topL = (Left*) bottom;
Top* topR = (Right*) bottom;

执行这两条语句后，topL和left会指向同样的地址，topR和right也会指向同样的地址。

综上所述，就引入的虚继承解决这个问题，可以将上述的代码改成如下的结构：

class Top
{ 
public: 
    int a;
}; 

class Left : virtual public Top
{ 
public: 
    int b;
}; 

class Right : virtual public Top
{ 
public: 
    int c;
}; 

class Bottom : public Left, public Right
{ 
public: 
    int d;
};

这就得到了如下的层次结构：

虽然从程序员的角度看，这也许更加的明显和简便，但从编译器的角度看，这就变得非常的复杂。重新考虑下Bottom的布局，其中的一个（也许没有）可能是：

这个布局的优点是，布局的第一部分与Left的布局重叠了，这样我们就可以很容易的通过一个Left指针访问 Bottom类。可是我们怎么处理以下语句：

Right* right = bottom;

哪个地址是我们赋给right的呢？在赋值以后，我们本应该可以像使用普通right对象指针一样使用right了。但这是不可能的！Right本身的内存布局是完全不同的，因此我们不能像访问”真正的”Right对象一样，来访问向上转换的Bottom对象。而且，也没有其它（简单的）Bottom布局可以使Bottom正常运作。解决办法是复杂的。我们先给出解决方案，之后再来解释它。

你应该注意到了这个图中的两个地方。第一，字段的顺序是完全不同的（事实上，差不多是相反的）。第二，有几个vptr指针。这些属性是由编译器根据需要自动插入的（使用虚拟继承，或者使用虚拟函数的时候）。编译器也在构造器中插入了代码，来初始化这些指针。

vptr (virtual pointers)指向一个 “虚拟表”。类的每个虚拟基类都有一个vptr指针。要想知道这个虚拟表 (vtable)是怎样运用的，看看下面的C++ 代码。

Bottom* bottom = new Bottom();
Left* left = bottom;
int p = left->a;

第二个赋值使left指向了bottom的所在地址（即，它指向了Bottom对象的“顶部”）。我们想想最后一条赋值语句的编译情况（稍微简化了）：

movl left, %eax # %eax = left
movl (%eax), %eax # %eax = left.vptr.Left
movl (%eax), %eax # %eax = virtual base offset
addl left, %eax # %eax = left + virtual base offset
movl (%eax), %eax # %eax = left.a
movl %eax, p # p = left.a

用语言来描述的话，就是我们用left指向虚拟表，并且由它获得了“虚拟基类偏移”(vbase)。这个偏移之后就加到了left，然后left就用来指向Bottom对象的Top部分。从这张图你可以看到Left的虚拟基类偏移是20；如果假设Bottom中的所有字段都是4个字节，那么给left加上20字节将会确实指向a字段。

经过这个设置，我们就可以同样的方法访问Right部分。

Bottom* bottom = new Bottom();
Right* right = bottom; 
int p = right->a;

对top的赋值现在可以编译成像前面Left同样的方式。唯一的不同就是现在的vptr是指向了虚拟表的不同部位：取得的虚拟表偏移是12，这完全正确（确定！）。我们可以将其图示概括：

当然，这个例子的目的就是要像访问真正Right对象一样访问升级的Bottom对象。因此，我们必须也要给Right（和Left）布局引入vptrs：

现在我们就可以通过一个Right指针，一点也不费事的访问Bottom对象了。不过，这是付出了相当大的代价：我们要引入虚拟表，类需要扩展一个或更多个虚拟指针，对一个对象的一个简单属性的查询现在需要两次间接的通过虚拟表（即使编译器某种程度上可以减小这个代价）。

构造顺序

1. 任何虚基类的构造函数按照它们被继承的顺序调用
2. 任何非虚基类的构造函数按照它们被继承的顺序调用
3. 任何成员对象的构造函数按照它们声明的顺序调用
4. 类自己的苟构造函数

参考链接
C++ 多继承和虚继承的内存布局
说说C++多重继承