C++虚继承中的菱形继承的简单解决

在C++继承中考虑这样一个关系： B与C都是从相同的基类派生的，该基类称为A,然后D多重继承了B和C，因为B和C都包含了A的子对象。所以C包含了A的两个子对象。继承关系如下图：

从继承图形状上看，有时该继承层次结构称为菱形。没有菱形时，多重继承相当简单。但是只要菱形一出现，由于新类中存在重叠的子对象。麻烦就开始了。重叠的子对象增加了存储空间。这种额外开销是否成为一个问题取决我们的设计，但是问题的关键是如何解决菱形继承带来的二义性。代码和编译器的抱怨来解释这个问题比较直观。下面先来分析这样一个错误的代码：

#include <iostream>
using namespace std;

class A{
public:
    A(int ax):a(ax){}
    void print(){
        cout<<"abc"<<endl;
    }
private:
    int a;
};

class B :  public A{
public:
    B(int ax,int bx):A(ax),b(bx){}
private:
    int b;
};

class C :  public A{
public:
    C(int ax,int cx):A(ax),c(cx){}
private:
    int c;
};

class D : public B, public C {
public:
    D(int ax,int bx,int cx, int dx):
    B(ax,bx), C(ax,cx),d(dx){}
private:
    int d;
};

int main(int argc, char const *argv[])
{
    D d(1,2,3,4);
    A *pa = (A*) &d;  //上行转换出现二义性,d中含有两个基类对象A，隐式转换不知道让pa指向哪个子对象
    d.print(); //print具有二义性，系统不知道是调用B类还是C类的print()
    return 0;
}

编译：
$ g++ test.cpp
test.cpp:61:18: error: ambiguous conversion from derived class 'D' to base class
      'A':
    class D -> class B -> class A
    class D -> class C -> class A
    A *pa = (A*) &d;  //上行转换出现二义性。
                 ^~
test.cpp:62:7: error: non-static member 'print' found in multiple
      base-class subobjects of type 'A':
    class D -> class B -> class A
    class D -> class C -> class A
    d.print(); //print具有二义性，系统不知道是调用B类还是C类的...
      ^
test.cpp:12:10: note: member found by ambiguous name lookup
    void print()
         ^
2 errors generated.

注意编译器报错，在代码里的注释我已经解释过这些报错的意思。

---

下面我们来探讨如何解决二义性，首先我们不使用虚继承机制，直接在代码里告诉编译器是使用B类的A子对象还是C类的A子对象即可解决二义性问题。

#include <iostream>
using namespace std;

class A{
public:
    A(int ax):a(ax){}
    void print(){
        cout<<"abc"<<endl;
    }
private:
    int a;
};

class B :  public A{
public:
    B(int ax,int bx):A(ax),b(bx){}
private:
    int b;
};

class C :  public A{
public:
    C(int ax,int cx):A(ax),c(cx){};
private:
    int c;
};

class D : public B, public C {
public:
    D(int ax,int bx,int cx, int dx):
    B(ax,bx), C(ax,cx),d(dx){}
private:
    int d;
};

int main(int argc, char const *argv[])
{
    D d(1,2,3,4);
    A *pa_1 = (A*)(B*)&d;
    A *pa_2 = (A*)(C*)&d; 
    d.B::print();
    d.C::print();
    pa1->print();
    return 0;
}

注意在main函数中的修改，再次编译并且运行，发现无报错。

$ g++ test.cpp
$ ./a.out
abc
abc
abc

---

下面我们使用 C++的虚继承机制来解决菱形继承的问题

简单来说：引入虚继承后D中的子对象B和子对象B共同拥有同一个子对象A，既节约了内存空间，同时避免了二义性。下面给出如何在代码中引入虚继承，注意代码中有注释的地方。

#include <iostream>
using namespace std;

class A{
public:
	A(int ax):a(ax){}
    void print(){
        cout<<"abc"<<endl;
 	}
private:
    int a;
};

class B : virtual public A{    //在继承时加上virtual关键字。 
public:
    B(int ax,int bx):A(ax),b(bx){}
private:
    int b;
};

class C : virtual public A{ //在继承时加上virtual关键字。
public:
    C(int ax,int cx):A(ax),c(cx){}
private:
    int c;
};

class D : public B, public C {
public:
    D(int ax,int bx,int cx, int dx):
    A(ax), B(ax,bx), C(ax,cx),d(dx){} //注意构造函数的书写与上面不同，要显式的初始化虚基类子对象
private:
    int d;
};

int main(int argc, char const *argv[])
{
    D d(1,2,3,4);
    A *pa_1 = (A*)&d; //引入了虚继承后规避了二义性
    A *pa_2 = (A*)&d;  
    d.print();
    return 0;
}

编译运行
$ g++ test.cpp
$ ./a.out
abc