菱形继承与解决方案

转载自：http://blog.csdn.net/xiaolewennofollow/article/details/52203891

在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_fuck()
    {
        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_fuck(); //print_fuck具有二义性，系统不知道是调用B类还是C类的print_fuck()
    return 0;
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

编译：

# wenxiaole at localhost in ~ [11:34:26]
$ 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_fuck' found in multiple
      base-class subobjects of type 'A':
    class D -> class B -> class A
    class D -> class C -> class A
    d.print_fuck(); //print_fuck具有二义性，系统不知道是调用B类还是C类的...
      ^
test.cpp:12:10: note: member found by ambiguous name lookup
    void print_fuck()
         ^
2 errors generated.
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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

#include <iostream>
using namespace std;

class A
{
public:
    A(int ax):a(ax)
    {

    }

    void print_fuck()
    {
        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_fuck();
    d.C::print_fuck();
    return 0;
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

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

# wenxiaole at localhost in ~ [12:01:46]
$ g++ test.cpp

# wenxiaole at localhost in ~ [12:02:00]
$ ./a.out
abc
abc
 
 
1
2
3
4
5
6
7

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

#include <iostream>
using namespace std;

class A
{
public:
    A(int ax):a(ax)
    {

    }

    void print_fuck()
    {
        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_fuck();
    return 0;
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

编译运行

# wenxiaole at localhost in ~ [12:17:36]
$ g++ test.cpp

# wenxiaole at localhost in ~ [12:17:39]
$ ./a.out
abc