C++：菱形继承及菱形虚拟继承

复杂的菱形继承及菱形虚拟继承

基于博主的上篇文章大家肯定都知道了继承的相关概念。那么我们再来了解一下复杂的菱形继承及菱形虚拟继承。

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况

菱形继承会导致数据的冗余和二义性的问题，具体看下方解释：

class Person
{
public:
	string _name;//姓名
};
class Student : public Person
{
protected:
	int _num;//学号
};
class Teacher : public Person
{
protected:
	int _id;//职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse;//主修课程
};
void Test()
{
	Assistant a;
	//a._name = "小荔枝";//这样会有二义性无法明确知道访问的是哪一个
	
	//需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "小栗子";
	a.Teacher::_name = "小李子";
}

因为Student和Teacher都继承了Person类，因此里面都有成员变量_name，Assistant又继承了Student和Teacher，因此Assistant定义出来的对象里都有两个_name，这样访问的时候会产生二义性，访问_name到底是Student里的_name还是Teacher里的_name，那为了不产生二义性就加上域作用限定符，但是依然会有数据冗余的问题。

当我们定义Assistant对象时，内部会有如下的成员，如下图：

那么如何解决这一问题呢？那就是采用虚继承。
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。虚继承就是在继承方式前面加上virtual关键字。如下：

class Student : virtual public Person
{
protected:
	int _num;
};
class Teacher : virtual public Person
{
protected:
	int _id;
};

虚拟继承解决数据冗余和二义性的原理

具体分析依照如下代码：

class A
{
public:
	int _a;
};
class B : virtual public A
{
public:
	int _b;
};
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

如上，B继承了A，C继承了A，D继承了B和C，因此这里是一个菱形继承。
如果不加virtual关键字的话，会造成数据冗余和二义性的问题。不加virtual关键字调用监视窗口查看内存：
此时sizeof对象d大小为20。

我们发现有两个_a，赋值的时候指定作用域时可以不一样。我们的理解可能就是明明都是同一个_a可是为什么还可以赋不同的值，这就是数据冗余和二义性。

那么加上virtual关键字呢？（虚继承）
此时sizeof对象d大小为24。为什么比不加virtual关键字占得空间还要大呢？那是因为这里给_a重新开了一块空间存放a的值（红色框框(✪ω✪)）。

那么B和C里面原来存放的_a现在存放的是什么呢？我们查看这里的地址，发现如下情况：

实际上B和C里面原来存放的_a，现在存放的是一个地址，查看地址我们发现存放的是当前位置距离_a新开空间位置的偏移量，通过对应的偏移量就可以找到_a的值了，因此，这里的_a就都是同一个_a了，就不会有二义性的问题了。

这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

小反思： 因此很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，应用了虚基表。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

最后大家思考一下这个题应该选什么呢？

class Base1 {
public:
	int _b1;
};
class Base2 {
public:
	int _b2;
};
class Derive : public Base1, public Base2 {
public:
	int _d;
};
int main()
{
	// A. p1 == p2 == p3
	// B. p1 < p2 < p3
	// C. p1 == p3 != p2
	// D. p1 != p2 != p3
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}

应该选择C，ヾ(✿ﾟ▽ﾟ)ノ我猜你一定选对辽！！

其实就是这样的一个情况，所以就是p1 == p3 != p2啦：