复杂的菱形继及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承是多继承的一种特殊状态
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
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; // 主修课程
};
int main()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
//a._name = "peter";//不指定访问哪个父类会报错
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决。
//现在多一个似乎问题也不大，但如果person特别大呢？
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";//这里会存在两个名字，但继承的前提是具有共性，所以这里的两个名字其实是不合理的
return 0;
}
菱形继承会导致数据冗余，要解决数据冗余就要进行虚拟继承，虚拟继承又有一堆机制。菱形继承的根源来自多继承，所以Java语法中，直接删除多继承这个语法了。
下面来说说虚拟继承，所谓虚拟继承就是在会产生冗余数据类(Person)的派生类(Student, Teacher)中加上virtual关键字
class Student : virtual public Person
{
protected:
int _num; //学号
};
class Teacher : virtual public Person
{
protected:
int _id; // 职工编号
};
顺便说一下，当数据的情况复杂到一定程度，vs编译器的监视窗口就不一定准确了(vs2013对下面的代码显示不准确，vs2019能正确显示，但是要深入了解虚拟继承如何解决问题，还是得用内存窗口)，这时要想得到准确的数据就要使用内存窗口。所以下面来看看菱形虚拟继承是如何解决问题的
class A
{
public:
int _a;
};
// class B : public A
class B : virtual public A
{
public:
int _b;
};
// class C : public A
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;
}
先来看看正常的菱形继承在内存中的样子：
D先继承B，B就在前面。
下面看看虚拟菱形继承在内存中的样子
可以看见新的_a放在了新的位置，一个即不属于B，也不属于C的区域。
对比两种菱形继承的对象模型
菱形继承和菱形虚拟继承的区别就在于调整了对象模型。
咋一看菱形虚拟继承并没有减小空间，反而变大了，那么菱形虚拟继承中B,C存储的不明数据是什么呢？其实是指针，用于指向_a所在的位置，这样当A太大时，就可以不用构建两个A，而是通过两个指针去指向A所处的位置。从而达到节省空间的目的。
在内存中输入这个指针：
输入第一个指针就得到了两个指针的情况。可以看到两个指针直接指向的位置都为0，直接指向位置的下一个位置则是两个数字，B为20，C为12，这个20,12实际上是偏移量，用来指向_a所在的位置，在B中存储指针的位置向下偏移20，就得到_a的位置。C中存储指针的位置向下偏移12，就得到_a的位置。所以这两个数是距离A存储位置的偏移量。
这两个指针直接指向的位置是预留给其他地方使用的。
那为什么要通过偏移量来找A的位置呢？
为了适应各种情况，比如:
B b;
C c;
D d;
b = d;
c = d;
将d赋值给b,c时会发生切片，而d中的_b和_a是分开的，所以需要偏移量来重新定位_a的位置。
还有一种情况：
B* ptr = &d;
ptr->_a = 1;
此时指针能得到的只有B中的信息，必须依靠B中的信息来找到A位置。
那么D如何找_d和_a呢？
_d和_a作为D的成员，编译器可以直接找到，只有通过B去找_a时才会需要偏移量。B和C没有存在自己对象区域中。
虚继承后，A也会被叫做虚基类，B，C中存储的指针也叫虚基表指针，指向虚基表，即图示部分。
如果_a只需要一份，为什么不设置成静态的呢？
静态的就不是一个D一份，而是全部D一份。研究生读研期间既是学生，也可以是老师(助教)，那么作为老师和学生基类的人名只有一份，是一个研究生一个人名，还是所有的研究生一个人名呢？所以_a不能设置成静态的。
虚拟继承后B对象的模型也被修改了，原来是存储一个_b和_a的数据，现在变成了存储_b的数据加上指向_a位置的虚基表指针。这么设计的原因在于：
B* ptr1 = &d;
B* ptr2 = &b;
cout << ptr1->_a << endl;
cout << ptr2->_a << endl;
cout << ptr1->_b << endl;
cout << ptr2->_b << endl;
作为指针的ptr1和ptr2并不知道自己指向的位置是通过d切片得来的，还是直接取b的地址得来的。对指针来说，目的只有通过得到的地址访问对应的数据，如果B对象的模型不修改，就会导致和D中B对象模型的不一致。那么访问的数据就会出问题。所以这里采用了统一的访问方式，即通过B中的虚基表指针得到对_a的偏移量。
菱形虚拟继承虽然解决了数据冗余和二义性，但作为解决方案是数据模型，也付出了代价：多了两层间接访问。
继承的语法设计偏复杂，用的角度偏简单。
其中1,2重点掌握，在使用时尽量使用公有继承；3了解就行，自己设计继承的时候要避免隐藏；4半重点掌握；5,6很简单；7也作为半重点掌握，要了解菱形虚拟继承的问题，解决起来也复杂，如何解决要了解一下。自己设计的尽量不要使用菱形继承。
下面对继承的反思不只是针对c++，还有所有面向对象的语言，封装，继承，多态是面向对象语言的三大特征。
继承的反思：
1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来设计的编程语言都没有多继承，如Java。
3. 继承和组合
（1）public继承是一种is-a的关系。也就是说派生类对象是一个基类对象。学生是人，鸟是动物。
（2）组合是一种has-a的关系。假设B组合了A，那么每个B对象中有一个A对象。头部有眼睛，电脑有键盘。
上面两幅图，前者是继承关系，后者是组合关系。它们都属于类的复用，但是复用的程度不一样。
有的关系天生适合用继承关系，有的对象天生适合用组合关系。适合is-a的关系推荐使用继承，适合has-a的关系推荐使用组合。
（3）优先使用对象组合，而不是类继承 。
存在用继承适合，用组合也适合的情况(比如stack，queue，priority_queue容器的选择)，这时候优先选择组合。
（4）继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见（指派生类可以直接使用基类的公有成员，保护成员）。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
（5）对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的（指不能直接使用保护成员，可以直接使用公有成员）。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
编程设计功能模块追求：高内聚，低耦合。高内聚指功能模块内部关联性很高，低耦合指模块与模块之间关联度很低。继承会导致高耦合，如果基类成员要修改，大概率导致派生类成员跟着修改。而使用组合耦合度低，只要不更改成员类的公有成员，就不用修改。
在软件工程中会将类与类之间，模块与模块之间的关系画成图画的形式，这种图叫UML图，对以后的学习还是挺有帮助的。
（6）实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
