C++ 中的继承详解(下)
目录
5、继承与友元(了解)
6、继承与静态成员
7、复杂的菱形继承及菱形虚拟继承(了解)
8、继承的总结和反思
5、继承与友元(了解)
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。
举个栗子：
class Student6;
class Person6
{
public:
friend void Display(const Person6 &p, const Student6 &s);
protected:
string _name; // 姓名
};
class Student6 : public Person6
{
friend void Display(const Person6 &p, const Student6 &s); // 加上这句代码就能解决下面的报错
// 一个函数可以是多个类的友元
protected:
int _stuNum; // 学号
};
void Display(const Person6 &p, const Student6 &s)
{
cout << p._name << endl;
// cout << s._stuNum << endl; // 这句会报错
}
void Test6()
{
Person6 p;
Student6 s;
Display(p, s);
}6、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。
无论派生出多少个子类，都只有一个static成员实例。
举个栗子：
class Person7
{
public:
Person7() { ++_count; }
protected:
string _name; // 姓名
public:
static int _count; // 统计人的个数。
};
int Person7::_count = 0;
class Student7 : public Person7
{
protected:
int _stuNum; // 学号
};
class Graduate : public Student7
{
protected:
string _seminarCourse; // 研究科目
};
void Test7()
{
// _count 静态成员只有一份，所有类共用
// 父类的静态成员属于当前类，也属于当前类的所有派生类
Student7 s1;
cout << " 人数 :" << Person7::_count << endl;
Student7 s2;
cout << " 人数 :" << Person7::_count << endl;
Student7 s3;
cout << " 人数 :" << Person7::_count << endl;
Graduate s4;
cout << " 人数 :" << Person7::_count << endl;
Student7::_count = 0;
cout << " 人数 :" << Person7::_count << endl;
cout << &Person7::_count << endl;
cout << &Student7::_count << endl;
}7、复杂的菱形继承及菱形虚拟继承(了解)
单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。
菱形继承：菱形继承是多继承的一种特殊情况(有问题的多继承)。
菱形继承的问题：
从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。
class Person8 // 父类
{
public:
Person8()
{
++_count;
}
string _name; // 姓名
static int _count;
};
int Person8::_count = 0;
class Student8 : virtual public Person8 // 虚拟继承可以解决菱形继承的二义性和数据冗余的问题。
{
protected:
int _num; // 学号
};
class Teacher8 : virtual public Person8 // 需要注意的是，虚拟继承不要在其他地方去使用，就在有继承公共基类的那几个类用！！！
{
protected:
int _id; // 职工编号
};
class Assistant : public Student8, public Teacher8 // 菱形继承(特殊的多继承)
{
protected:
string _majorCourse; // 主修课程
};
void Test8()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
cout << Person8::_count << endl; // 没有虚拟继承之前这个打印的是2
a._name = "peter"; // 没有虚拟继承之前这句代码会报错，编译器不知道你要访问的是 Student8 的 _name 还是 Teacher8 的 _name。
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student8::_name = "xxx"; // 有了虚拟继承之后，这里的_name就只有一份了 // 注：有了虚拟继承之后，代码也还是可以这样写
a.Teacher8::_name = "yyy";
}总结：多继承看起来很合理，但是有多继承就可能会有菱形继承，菱形继承有问题。
所以：为了解决菱形继承导致的数据冗余问题，出现了虚拟继承的概念。
虚拟继承解决数据冗余和二义性(就像你的身份证上不能有两个名字来代表你)的原理。
注：要借助内存窗口才能搞明白。
为了研究虚拟继承原理，下面给出了一个简化的(上面的太复杂了，不方便观察)菱形继承继承体系。
class A9
{
public:
int _a;
};
// class B9 : public A9
class B9 : virtual public A9
{
public:
int _b;
};
// class C9 : public A9
class C9 : virtual public A9
{
public:
int _c;
};
class D9 : public B9, public C9
{
public:
int _d;
};
void Test9()
{
D9 d;
// 加了虚拟继承后，在内存窗口中，&d 会发现，D 原本存放继承于 B9、C9 中的 _a 的空间变成了存放两个地址(指向虚基表)，而 _a 则被放到了一个公共的地方。
// 下面的每一种对 _a 的修改方式，都是影响那个公共的 _a。
d.B9::_a = 1;
d.C9::_a = 2;
d._a = 0;
d._b = 3;
d._c = 4;
d._d = 5;
// 注意：即使用了虚拟继承之后，B9和C9 中还是有自己的 _a
B9 b;
b._a = 1;
C9 c;
c._a = 7;
}总结：虚拟继承在内存里的体现就是 在 D 对象中，把继承于 B9 和 C9 这两部分中冗余的那部分数据(_a)放在了一块公共的空间,而 D 中原本存放继承于 B9 和 C9 中的冗余数据(_a)的空间则改为了存放虚基表的地址。这就是虚拟继承！！
注：虚基表里存放有偏移量(用于切片赋值)。
注：偏移量是存在虚基表里的第二个位置的，虚基表的第一个位置存的是其相对于虚函数表的偏移量(跟多态里的菱形虚拟继承有关)。
注：偏移量，一个从该位置到存放_a的公共区域的那个位置的距离。(有时候可能会有两个偏移量，多出来的那个偏移量是该位置到其虚表的距离(这是多态的部分))
补充一个小问题：为什么不直接在 d 对象中的继承于 B9 和 C9 的那部分数据中原本存放冗余的那部分数据(_a)的空间 存放偏移量(距离)？而是要存一个地址，让这个地址指向的那块地方去存这个偏移量(距离)呢？
答：这跟多态有关(这个地址实际上就是虚基表的地址)
补充：偏移量的作用：切片赋值的时候有用。
补充：数据的声明顺序就是其在内存中的存储顺序(例如类中的初始化列表的初始化顺序就是这个原理)
总结：实践中可以设计多继承，但要注意别设计菱形继承，菱形继承太复杂了，容易出各种问题。
补充：实际中能碰到的菱形继承也非常的少，但库里却有一个菱形继承，就是io流。
补充：面试时有关这个知识点的问题大概就是以下这几种
1、C++为什么有多继承？Java为什么没有？
答：因为祖师爷一开始设计多继承时，觉得多继承不错，挺好的，当时没想到会有菱形继承这样的问题，通过C++的发展史也能知道，多继承和虚拟继承并不是同一个C++版本发布的，而是先发布了多继承，后来才发布了虚拟继承用来解决菱形继承这个问题。Java没有多继承的原因就是吸取了C++为了解决菱形继承这个问题，而付出了很大的代价的这个教训，所以Java干脆就不要多继承了，只有单继承。
2、多继承的问题是什么？
答：多继承本身是没什么问题的，但是有了多继承就可能会写出菱形继承，菱形继承就会导致 二义性和数据冗余 这两个问题的出现。
3、菱形继承的问题是什么？如何解决这个问题？
答：菱形继承的问题是：二义性和数据冗余。
解决方法是：采用虚拟继承。
4、底层的角度是如何解决的数据冗余和二义性？
答：这两个问题是相辅相成的，所以解决了数据冗余(二义性)就相当于解决了二义性(数据冗余)的问题。
解决方法就是：上面的第一个总结(虚拟继承)。
注意：菱形继承只是一种形象上的说法，只要有数据冗余和二义性这两个问题就可以算是菱形继承。
补充：被共享的基类(A)也会被称之为虚基类。
补充：使用了虚拟继承的类(B9、C9)的对象模型会因此发生改变。
8、继承的总结和反思
1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般设计多继承时，一定要注意不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。
3. 继承和组合(都是一种复用)
- public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
- 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
- 优先使用对象组合，而不是类继承。
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white - box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
- 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black - box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
- 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，也可以用组合，尽量用组合。
举个组合的栗子：
class A10
{
private:
int _a;
};
class B10
{
private:
A _aa; // 这就叫组合，把A作为B的一个成员变量，这就叫组合
int _b;
};补充：
程序设计要尽量做到高内聚，低耦合最好。
低耦合：类和类之间、模块和模块之间关系不那么紧密，关联不高。
高耦合：类和类之间、模块和模块之间关系很紧密，关联很高(你修改其中一个类/模块，都可能会影响到另一个类/模块，牵一发而动全身)。
补充：如果一个程序写的已经是高耦合的了，这种时候出现了一个bug，你改了可能就会导致另一个bug的出现，已经没法再写下去了，这时候迫不得已就需要重构了。
高内聚：一个 类/模块 里放的东西尽量都是关系很紧密的东西。
总结：组合是只能用那个类的 公有 的成员，继承是能用那个类的 公有+保护 的成员，所以组合的耦合度更低。
总结：
- 适合 is-a 关系，就用继承 (ex：学生是一个人)
- 适合 has-a 关系，就用组合 (ex：汽车有一个轮胎)
- is-a 和 has-a 的关系都可以，就用组合 (ex：栈是一个特殊的链表，栈里有一个链表)