七. 菱形继承 & 菱形虚拟继承
🌈菱形继承
💠单继承：一个子类只有一个直接父亲
💠 多继承：一个子类有两个及两个以上的直接父亲
多继承看起来合理，其实就是坑，C++作为"第一个吃螃蟹的人"（Java后面的语言就避开了），带来了菱形继承，也就说助教对象中有两份Person，会有数据冗余和二义性的问题
二义性可以通过指定作用域勉强搞定
#include<string> using namespace std; class Person { public: string _name; //姓名 }; class Student : public Person { protected: int _stuid; //学号 }; class Teacher : public Person { protected: int _teacherid; //工号 }; class Assistant : public Student, public Teacher { protected: string _majorCourse; //主修课程 }; int main() { //二义性：对_name的访问不明确 Assistant a; //a._name = "peter"; //nope~ 错误示范，请勿模仿 //需要显示指定访问哪个父类的成员 a.Student::_name = "蛋哥"; a.Teacher::_name = "杭哥"; return 0; }
那么数据冗余咋办呢？
🌈菱形虚拟继承
注意是在腰上添加virtual，不要乱用
class Person { public: string _name; //姓名 }; class Student : virtual public Person { protected: int _stuid; //学号 }; class Teacher :virtual public Person { protected: int _teacherid; //工号 }; class Assistant : public Student, public Teacher { protected: string _majorCourse; //主修课程 }; int main() { Assistant a; //无需指定，访问的是同一个 a._name = "蛋哥"; a.Student::_name = "杭哥"; a.Person::_name = "基哥"; return 0; }
🌈菱形虚拟继承的原理
为了研究原理：虚继承究竟是如何解决数据冗余的
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; }
先来实验不采用虚拟继承时，是有数据冗余 & 二义性问题的(且先继承的在前，后继承的在后) ——
💦 当观察虚拟继承时，可以观察到， A成员的确只存储了一份，在对象的最底下——
此处我们发现：虚继承并没有节省空间，但是我们转换思路，a是一个int a[10000]数组，再那就节省了4万字节
但是B和C中是什么？推测是地址，众所周知，当前机器采取的是小端存储(低位存低地址，高位存高地址)，我们再打开内存窗口来看这地址存的什么 ——
D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A(虚基类)呢？就是通过了B和C的两个指针虚基表指针)，指向的虚基表(找虚基类的表)。虚基表中存的偏移量，通过偏移量可以找到下面的A
Person关系菱形虚拟继承的原理 ——
A一般叫做虚基类，在D中，A放到一个公共位置，有时B需要找A、C需要找A，就要通过虚基表中的偏移量来计算。那为什么要找呢？考虑以下场景
//此时的B对象一部分是继承A的，一部分是自己的 B d; B* Pb = &d; //切片，要找_a C c = d; C* pb = &d;
当我们求得bb的大小时候发现 ——
B bb; cout << sizeof(bb) << endl; bb._a = 1; bb._b = 2;
同时我们发现这种存储方式是十分巧妙的
void func(B* ptr) { cout << ptr ->_a << endl; } func(&d); func(&bb);
此处不知道ptr是指向父类还是子类的_a，但是父类和子类的存储结构都是保持一致的，_a都是放在最下面的位置。
注意：有公共祖先类就会构成菱形继承，那么virtual加在哪里呢？
注意虚拟继承是放在腰上，要解决的是A 的二义性和数据冗余问题
八. 总结
很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java
💞继承和组合
继承和组合都是一种复用，只不过访问的方式有所不同，组合只能访问公有
// Car和BMW Car构成is-a的关系 //继承—— 白箱复用(white-box reuse) class Car{ protected: string _colour = "白色"; // 颜色 string _num = "粤A0DU95"; // 车牌号 }; class BMW : public Car{ public: void Drive() {cout << "好开-操控" << endl;} };
// Tire和Car构成has-a的关系(轮胎和车) //组合 - 黑箱复用(black-box reuse) class Tire{ protected: string _brand = "Michelin"; // 品牌 size_t _size = 17; // 尺寸 }; class Car{ protected: string _colour = "白色"; // 颜色 string _num = "粤A0DU95"; // 车牌号 Tire _t; // 轮胎 };
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
如果既符合继承和组合，优先使用对象组合，而不是类继承
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合
另外我们希望，模块之间的关系最好是 低耦合高内聚，方便维护。继承(A和B)，耦合度高，依赖性强，任意一个成员的改变都会对我有影响；组合(C和D)，耦合度低，依赖关系较弱 （继承就是跟团游 ，组合就是自由行）
结论：完全符合is-a，就用继承；完全符合has-a，就用组合；既是is-a，又是has-a，优先用组合而不是继承
九. 常见面试题
1️⃣如何定义一个不能被继承的类？
父类构造函数私有 —— 子类是不可见；子类对象实例化，无法调用构造函数
C++11 final关键字
//方法一：父类构造函数私有 class A { private: A() {} protected: int _a; }; class B : public A { }; int main() { B bb; return 0; }
方法二：final关键字
2️⃣ 多继承中指针偏移问题
下面说法正确的是( )
class Base1 { public: int _b1; }; class Base2 { public: int _b2; }; class Derive : public Base1, public Base2 { public: int _d; }; int main(){ Derive d; Base1* p1 = &d; Base2* p2 = &d; Derive* p3 = &d; return 0; }
A：p1 == p2 == p3
B：p1 < p2 < p3
C：p1 == p3 != p2
D：p1 != p2 != p3
E：编译报错
F：运行报错
答案选C
