目录
目录
继承的概念及定义
封装：数据和方法放到类里面
继承：继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。
继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
如下面这些职业都有相同的信息，我们可以把共有的数据和方法提取到一个类中，这个类叫父类
继承的意义：复用，体现的是类设计定义层次的复用
继承定义
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类
继承关系和访问限定符
继承举例
把权限放开
继承关系
类成员/继承方式 public继承 protected继承 private继承 基类的public成员 派生类的public成员 派生类的protected
成员派生类的private
成员基类的protected
成员派生类的protected
成员派生类的protected
成员派生类的private
成员基类的private成
员在派生类中不可见 在派生类中不可见 在派生类中不可 见 总结：
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过
最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡
使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
面使用，实际中扩展维护性不强
验证：
保护遇公有是保护
公有遇保护是保护，保护遇保护还是保护
遇私有
基类的私有成员在派生类不可见
不可见：隐身了，类里面，类外面都无法访问
换成保护，程序可以运行，保护是在类外面无法访问，在类里面可以访问
私有成员的意义：不想被子类继承的成员，可以设计成私有
基类中想给子类复用，但是又不想暴露直接访问的成员，就应该定义成保护
如果不写继承方式，class默认私有继承，struct默认公有继承
继承中的作用域
1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。父类和子类有各自的域，可以定义同一个变量，子类会出现俩个_name，有一个是继承父类的有一个是自己创建的，如果子类访问_name，访问的是自己创建的_name，类似于局部优先原则
访问的是子类的num
如果想要访问父类的num,我们要指定作用域
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
使用过程中，尽量不要定义同一成员
class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { A::fun(); cout << "func(int i)->" << i << endl; } }; void Test() { B b; b.fun(10); }; int main() { Test(); return 0; }B是继承的A，俩者都有fun函数，但俩个fun不构成函数重载，重载必须在同一作用域，这俩个不在同一作用域，这俩个fun构成隐藏关系，成员函数只要函数名相同就构成隐藏，跟参数无关
也可这样访问A里面的fun,指定作用域即可
继承不会把函数拷贝到子类中，子类生成对象，对象中没有成员函数，有成员，成员函数是放在公共代码段的，当去找成员函数的时候，编译器会有域的限制。对象当中不存储成员函数，只存储成员变量。
基类和派生类对象赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片
或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这里先了解一下）
子类可以赋值给父类，虽然是不同类型，但不是隐式类型转换，这是语法天然支持的，这个过程一般被称为切割
这样也可以
如果换成私有或保护继承
我们可以把子类对象看作是一个特殊的父类对象，Student B;Person A=B; 是把子类对象拷贝给父类对象
基类对象不能赋值给派生类对象（父类对象不能赋值给子类对象）
强制类型转换也会报错
基类的指针可以通过强制类型转换赋值给派生类的指针（后面博客写）
子类的默认成员函数
构造函数
父类
class Person { public: Person(const char* name = "peter") : _name(name) { cout << "Person()" << endl; } Person(const Person& p) : _name(p._name) { cout << "Person(const Person& p)" << endl; } Person& operator=(const Person& p) { cout << "Person operator=(const Person& p)" << endl; if (this != &p) _name = p._name; return *this; } ~Person() { cout << "~Person()" << endl; } protected: string _name; // 姓名 };创建子类对象，运行程序（此时子类里没有任何函数），我们发现调用了父类的构造和析构
子类默认生成的构造函数：1.对于自己的成员，跟类和对象一样（内置类型不处理，自定义类型调用自己的默认构造函数）
2.对于继承的父类成员，必须调用父类的构造函数初始化。
如果父类没有默认构造，则会报错
这种情况，我们要自己写一个
这俩种情况都会报错
继承的父类成员要调用父类的构造函数，子类的成员可以自己处理
我们用像匿名对象的用法（注意不是匿名对象）就可以解决这个问题 ，因为子类对象可以赋值给父类对象
拷贝构造
编译器生成默认拷贝构造：1.自己成员，跟类和对象一样（内置类型值拷贝，自定义类型调用自己拷贝构造）
2.继承的父类成员必须调用父类的拷贝构造初始化
这里本来要填Person(s._num)，但是这样写会报错，用赋值转换即可解决
赋值重载
编译器生成默认拷贝构造：1.自己成员，跟类和对象一样（内置类型值赋值，自定义类型调用自己赋值）
2.继承的父类成员必须调用父类的赋值
这样写会报错，栈溢出，出现了递归调用，因为赋值重载子类和父类是同名函数，形成了隐藏关系，子类无法访问父类的赋值重载，子类一直在调用自己的赋值重载，所以栈溢出
我们指定一下即可
析构函数
编译器默认生成的析构函数，如果是子类继承的父类成员调用父类的析构函数，子类自己的成员调用自己的析构函数，但无论如何调用仍然遵守内置类型不处理，自定义类型调用自己的析构函数。
我们这没有new或malloc空间，不需要显示的写析构函数
这样写会报错
这是因为子类的析构函数和父类的析构函数构成隐藏，但函数名不同为什么会出现隐藏？
这是因为后面多态的需要析构函数名字会统一处理成desructor()
指定作用域后就可以调用
看下面打印结果
这有俩个对象，调用了2次构造，Student的析构是2个，Person的析构是4个，相当于父类的析构是双倍的，这是因为我们显示的调用了父类的析构，系统还自己自动调用了Person析构，所以是双倍，这里多次析构不报错是因为我们写的析构函数啥都没敢，如果是释放空间，肯定会报错
子类继承了父类，父类的先构造，子类后构造，子类先析构，父类后析构，如果我们自己写父类的析构就可能会无法保证这个顺序，所以系统帮我们调用了父类的析构
总结
1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能
保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系
继承与静态成员
基类定义了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; } int main() { TestPerson(); return 0; }
继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
这里是父类的友元，继承的时候不会把友元关系继承下来，如果基类友元想访问子类私有成员和保护成员，我们在子类中写友元即可
复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况。
如何定义一个不能被继承的类？
父类构造函数私有化
1.子类对象实例化，无法调用构造函数
C++11打了个补丁，新增关键字final（最终类），如果添加了这个关键字，在没实例化对象的时候就会报错
习题：多继承中指针偏移问题？下面说法正确的是( C)
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
先继承的在前面，后继承的在后面，base1在前，bas2在后
p3表示整个地址
菱形继承问题
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余（比如构造的时候会初始化俩次）和二义性的问题（Assistant的对象访问_name的时候不知道要访问谁的）。在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; // 主修课程 };
解决办法：指定作用域
但冗余还没有解决。
用虚进程可解决，加virtual关键字，在腰部这块加上该关键字
用这种方式访问到的是同一个_name
菱形虚拟进程解决了数据冗余和二异性，日常使用时不推荐这种继承方式
class A { public: int _a; }; class B : public A { public: int _b; }; class C : public A { public: int _c; }; class D : public B, public C { public: int _d; };
第一个小蓝框来自B，第二个小蓝框来自C，整个大框来是d整体
菱形虚拟继承后
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; };
_a既没放在3个蓝框里面，而是重新找了一个空间， 此时只有一个_a
看似多了个空间，实际节省了空间，如果a很大是4000字节，数据冗余会浪费很多空间
添加关键字后，多出来的这块空间 存的是0
但是这些位置下面存了一些值
14 00 00 00表示20
0C 00 00 00表示12
这俩个数字表示跟_a的距离（偏移量）
画红线部分加20，正好表示公共a
当菱形继承遇到切割或切片问题，b对象有一个成员是自己的，_a本来是切割下来的，但是此时加了关键字，_a大家共有，共有后如何找到_a进行切割？
这个时候就会找到这个地址然后+20，再切片切过去
这里用pb去访问_a,pc去访问_a如何访问？
找到地址+偏移量即可
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() { B b; cout << sizeof B; return 0; }
注意此时B并不是8，而是12 ，这是因为多出来的4个字节要存地址，指向一个表，这个表里存的是偏移量
继承的总结和反思
1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
优先使用对象组合，而不是类继承 。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。
继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。
派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被
封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用
继承，可以用组合，就用组合