【C++】继承 -- 详解（上）https://developer.aliyun.com/article/1514706?spm=a2c6h.13148508.setting.19.4b904f0ejdbHoA
五、继承与友元
友元关系 不能 继承，也就是说基类友元不能访问子类私有和保护成员。
class Student; // 基类 class Person { public: friend void Display(const Person& p, const Student& s); // 声明该函数是基类的友元 protected: string _name; // 姓名 }; // 派生类 class Student : public Person { protected: int _stuNum; // 学号 }; void Display(const Person& p, const Student& s) { cout << p._name << endl; // 你是基类的友元，访问基类对象是可以的 cout << s._stuNum << endl; // 友元不继承你不能访问派生类对象，这里会报错，显示不可访问 } int main() { Person p; Student s; Display(p, s); return 0; }
六、继承与静态成员
基类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个 static 成员实例 。
//无论继承多少层，大家用的始终是同一个变量 // 基类 class Person { public : Person () {++ _count ;} protected : string _name ; // 姓名 public : static int _count; // 统计人的个数 }; int Person :: _count = 0; class Student : public Person { protected : int _stuNum ; // 学号 }; class Graduate : public Student { protected : string _seminarCourse ; // 研究科目 }; void TestPerson() { Student s1 ; Student s2 ; Student s3 ; Graduate s4 ; cout << " 人数 :" << Person ::_count << endl; Student ::_count = 0; cout << " 人数 :" << Person ::_count << endl; }
七、复杂的菱形继承及菱形虚拟继承
1、单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
2、多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。
3、菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有 数据冗余 和 二义性 的问题。 在 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"; // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; return 0; }
虚拟继承 可以解决菱形继承的二义性和数据冗余的问题。
如上面的继承关系，在 Student 和 Teacher 的继承 Person 时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地 方去使用。
注意：virtual 不是在 Assistant 处加，而是在菱形中间腰部 (Student 和 Teacher) 的位置加。
class Person { public : string _name ; // 姓名 }; class Student : virtual public Person { protected : int _num ; //学号 }; class Teacher : virtual public Person { protected : int _id ; // 职工编号 }; class Assistant : public Student, public Teacher { protected : string _majorCourse ; // 主修课程 }; int main() { Assistant a ; a._name = "Peter"; //这个时候_name其实只有一个 // 这下面两个显示访问其实访问的都是一个变量 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; 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; }
下图是菱形继承的内存对象成员模型：这里可以看到数据冗余。
下图是菱形虚拟继承的内存对象成员模型：这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个 A 同时属于 B 和 C，那么 B 和 C 如何去找到公共的 A 呢？
这里是通过了 B 和 C 的两个指针，指向的一张表，这张表是什么呢？
B 和 C 中还各自多了 4 个字节的地址，我们再通过其它内存窗口查看 B 和 C 中那两个地址放的到底是什么，发现 B 和 C 中各自那所谓多余的 4 个字节指向的空间中存储了 十进制：20（十六进制：14 00 00 00） 和 十进制：12（十六进制：0c 00 00 00），其实它们一点都不多余，其代表的含义是对于 A 的偏移量 —— 0x005EF75C + 20 = 0x005EF770；0x005EF764 + 14 = 0x005EF770；，官方来讲对于 0x005EF75C 和 0x005EF764 所指向的内存 2 和内存 3，称之为虚基表。
这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 A。
为什么 D 中 B 和 C 部分要去找属于自己的 A ？那么看看当下面的赋值发生时，d 是不是要去找出 B/C 成员中的 A 才能赋值过去？
D d; B b; B* p1 = &d; // B对象指针 -> D对象，把D对象切片给B对象指针 p1->_a; // 指针访问虚基类A的成员＿ａ B* p2 = &b; // B对象指针 -> B对象 p2->_a; // 指针访问虚基类A的成员＿ａ
（1）为什么需要偏移量？
指针是无法识别自己指向的是哪个类的对象，即可能指向自己，也可能指向子类，比如上面这段代码，B 对象和 D 对象中的虚基类成员 _a 的偏移量是不一样的，所以我们也只能通过偏移量来计算出 _a 的位置。
B 或 C 的对象、对象指针、对象引用访问继承的虚基类 A 的对象中的成员 _a，都要取偏移量计算 _a 的位置。
（2）为什么不在 0x005EF75C、0x005EF764 直接存偏移量？
这样也是可以的，但是使用虚基表来存储的原因是：
还有其它场景 —— 在引入多态时 0x00BC5F50 和 0x00BC5F5C 处还需要再存储一个值。
（3）virtual 已经能解决菱形继承所带来的问题了，为什么还是不建议使用？
在解决问题的同时，效率也降低了，它的这个对象模型变的更加复杂。之前是编译器编译完直接就可以找到，因为它们是紧挨着的，而现在却必须得通过指针来找到偏移量，再与现在的地址进行相加才可以找到。
下面是上面的 Person 关系菱形虚拟继承的原理解释：
八、继承的总结和反思
- 很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
- 多继承可以认为是 C++ 的缺陷之一，很多后来的 OO 语言都没有多继承，如 Java。
- 继承和组合
- public 继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
- 组合是一种 has-a 的关系。假设 B 组合了 A，每个 B 对象中都有一个 A 对象。
- 优先使用 对象组合 ，而不是类继承 。
可参考下面这篇博客：
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语 “白箱” 是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为 黑箱复用 （black-box reuse），因为对象的内部细节是不可见的。对象只以 “黑箱” 的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
// Car和BMW Car和Benz构成is-a的关系 class Car{ protected: string _colour = "白色"; // 颜色 string _num = "粤DK0896"; // 车牌号 }; class BMW : public Car{ public: void Drive() { cout << "好开-操控" << endl; } }; class Benz : public Car{ public: void Drive() { cout << "好坐-舒适" << endl; } }; // Tire和Car构成has-a的关系 class Tire{ protected: string _brand = "Michelin"; // 品牌 size_t _size = 17; // 尺寸 }; class Car{ protected: string _colour = "白色"; // 颜色 string _num = "粤DK0896"; // 车牌号 Tire _t; // 轮胎 };
