转载自: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.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();
^
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函数中的修改,再次编译并且运行,发现无报错。
$ g++ test.cpp
$ ./a.out
abc
abc
下面我们使用 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
编译运行
$ g++ test.cpp
$ ./a.out
abc