【C++】菱形继承

我们先来看下菱形继承的基本视图以及基本的代码结构

下面来看下简单的代码以及数据结构：

1. class Person

2. {

3. public:

4. int a_p;

5. };

7. class Studen :public Person

8. {

9. public:

10. int a_st;

11. };

13. class Stuff :public Person

14. {

15. public:

16. int a_sf;

17. };

19. class st_sf :public Stuff, public Studen

20. {

21. public:

22. int a_ss;

23. };

25. int main()

26. {

27. st_sf ss;

28. return 0;

29. }

上述代码简单的很，就是Student(学生)和stuff(工人)都继承了Person类，然后Student和stuff作为Person的派生类，但是他俩又作为了类st_sf 的两基类，在主函数中创建类st_sf 的对象，下面我们来看下创建的st_sf 对象的数据结构是咋样的？

 上图中说到的会导致一些问题，具体是什么问题呢，看下面代码：

1. #include<iostream>

2. using namespace std;

4. class A

5. {

6. public:

7. int val;

8. public:

9. A(int x = 0):val(x){}

10. };

12. class B : public A

13. {

14. public:

15. int num;

16. public:

17. B(int x = 0) : num(x), A(x + 10) {}

18. };

20. class C : public A

21. {

22. public:

23. int sum;

24. public:

25. C(int x = 10) :sum(x), A(x + 10) {}

26. };

28. class D :public B, public C

29. {

30. public:

31. int total;

32. public:

33. D(int x = 10) :total(x), B(x + 10), C(x + 20) {}

34. };

36. int main()

37. {

38. D d(0);

39. return 0;

40. }

在上述代码中我们通过最底层基类A派生出来了B和C，然后B和C又共同派生出来了一个类D,通过实例化D对象来观察上述代码的数据结构视图：

我们可以清晰的看到，构建出来的D对象有歧义了B中的val值为20，C中的val值为30，很明显不符合正常情况，但是呢代码还是正常通过了，这是为什么呢？？

上图中我们给出了产生这种现象的原因，就是因为上述现象，所以 才会有我们刚刚看到的歧义性，那么怎么解决这种问题呢？？？

我们在这里就给出来了一个解决方法：虚继承 

 虚继承会导致我们student和staff对象中存放与Person对象的指针偏移量，但是存放的不是指针，这样就可以避免我们的歧义性问题：

1. class A

2. {

3. public:

4. int val;

5. public:

6. A(int x = 0):val(x){}

7. };

9. class B :virtual public A

10. {

11. public:

12. int num;

13. public:

14. B(int x = 0) : num(x), A(x + 10) {}

15. };

17. class C :virtual public A

18. {

19. public:

20. int sum;

21. public:

22. C(int x = 10) :sum(x), A(x + 10) {}

23. };

25. class D :public B, public C

26. {

27. public:

28. int total;

29. public:

30. D(int x = 10) :total(x), B(x + 10), C(x + 20), A(x + 100) {}

31. };

33. int main()

34. {

35. D d(0);

36. return 0;

37. }

我们看一下引入虚继承之后的代码运行是怎么样的：

 该结果和我们上述画的哪个图结构一样，而且也没有歧义性的结果出现！！！

最后再补充一点东西，不使用虚继承的菱形继承不光会有歧义性结果：

1. //在没有引入虚继承之前，我们不可以这样调用：

2. int main()

3. {

4. D d(0);

5. d.val;//这样不可以调用，因为它的d对象的基类中有两个A中的成员变量，编译器不知道调用哪个

6. //所以编译不通过

7. }

会有val不明确的报错！！！