1.0 场景引入：
在现实生活中，假设要定义一个学生管理系统，包含有各种角色。
比如有：学生、老师、保安大叔、宿管阿姨，等等角色，我们就要定义这四个类，但是这四个类有很多重复的成员变量，比如姓名、年龄、身份号码等，包括一些重复的成员函数，比如去食堂吃饭都要刷卡识别身份信息等行为。
每个类都要定义这些，是不是就重复冗余了呢？能不能很好的去复用？
C++提供了继承来很好的解决类似的问题。
1. 继承的概念及定义
1.1 继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类（子类）。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承是类设计层次的复用。
代码示例：
class Person { public: void Print() { cout << "name=" << _name << endl; cout << "age=" << _age << endl; } protected: string _name = "zhangsan";//姓名 int _age = 18;//年龄 }; class Student:public Person//复用了Person { protected: int _stuid;//学号 }; class Teacher :public Person//复用了Person { protected: int _jobid;//工号 }; int main() { Student s; Teacher t; s.Print(); t.Print(); return 0; }说明：这里Student和Teacher复用了Person。继承后父类的成员（成员函数+成员变量）都会成为子类的一部分。
调监视窗口看Student和Teacher对象可以看到对Person成员变量的复用。
Student和Teacher对象通过调用Print函数可以看到对Person成员函数的复用。
1.2 继承的定义
1.2.1 继承的格式
Person是父类，也叫基类，Student是子类，也叫派生类。
1.2.2 继承方式和访问限定符
1.2.3 继承基类成员访问方式的变化
总结：
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过
最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡
使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
面使用，实际中扩展维护性不强。
2. 基类和派生类对象赋值转换
1.派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。就是把派生类中父亲的那部分“切割”赋值过去。
派生类的成员包含两部分，一部分是继承的父类的成员，一部分是自己的成员，切片就是把那部分父类的成员赋值给父类。
2.基类对象不能赋值给派生类对象。
3.基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI 的dynamic_cast 来进行识别后进行安全转换。(后续再补充）。
3. 继承中的作用域
1.在继承体系中基类和派生类都有独立的作用域。
2.子类和父类中有同名成员，子类成员将屏蔽对父类同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类：：基类成员显示访问）
代码示例：
class Person { protected: int _num = 111; }; class Student :public Person { public: void Print() { cout << _num << endl; //cout << Person::_num <<endl;//访问父类的_num。 } protected: int _num = 999; }; int main() { Student s; s.Print(); return 0; }说明：
a.这里的Person父类和Student子类中有同名的成员变量_num。那么这里会不会报错呢？
答案是不会报错，因为他们两个分别在父类和子类这两个独立的作用域里面。
b.那么输出的结果是什么呢？
答案是999，因为子类隐藏了父类的同名成员_num，所以直接访问访问不到父类的_num。
c.如果就是要想要输出111呢？
指定父类的作用域即可，使用“Person::_num”来显示访问。
3. 需要注意的是如果是成员函数的隐藏，只需要 函数名相同就构成隐藏 。
class A { public: void func() { } }; class B :public A { public: void func(int i) { cout << "func(int i)->" << i << endl; } }; int main() { B b; b.func(10); //b.A::func();//调用父类的func return 0; }说明：
a.这里的“func（）”和“func（int i）”是什么关系？
A.重载 B.重写 C.重定义 D.以上都不对
答案是C，重定义，也叫隐藏。因为父类和子类的这两个函数函数名相同，就构成了隐藏。
b.输出结果是什么？
答案是func(int i)-> 10。因为子类隐藏了父类的func，直接访问访问不到。
c.如果就是要调用父类的func()呢?
指定作用域即可，"b.A::func()"来访问。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。
4. 派生类的默认成员函数
默认的构造函数包括：我们不写编译器自动生成的、全缺省的、无参的。我们重点关注构造、拷贝构造、赋值和析构这四个默认成员函数即可。
class Person { public: Person(const char* name = "zhangsan")//构造函数 :_name(name) { cout << "Person()" << endl; } Person(const Person& p)//拷贝构造 :_name(p._name) { cout << "Person(const Person& p)" << endl; } Person& operator=(const Person& p)//operator赋值 { if (this != &p) { _name = p._name; cout << "Person& operator=(const Person& p)" << endl; } } ~Person()//析构 { cout << "~Person()" << endl; } private: string _name;//姓名 }; class Student :public Person { private: int _stuid;//学号 };
派生类的成员包含两部分，一部分是继承了的父类的成员，一部分是自己的成员。
1.构造函数：
这里我们并没有定义Person类的对象，为什么会调用Person的构造和析构函数呢？
说明：
子类对象要完成初始化，也分为两部分，一部分是父类的，一部分是自己的，父类的那部分成员就要调父类的构造函数来完成初始化，自己的那部分调自己的构造函数来初始化，析构也一样。
上述代码示例中，我们并没有写Student的构造函数，那么编译器就会生成默认的，这个默认的就会调父类的默认构造函数来初始化父类的成员。
如果父类没有默认的构造函数就不行：
如果自己写一个子类的构造函数初始化父类的成员这里也不行：
如果父类没有默认的构造函数或者我们就像在子类的构造函数初始化父类的成员呢？
此时就必须在子类的构造函数的初始化列表阶段显式调用。
2.拷贝构造：
说明：
子类的拷贝构造跟构造一样，分两部分，父类的成员去调父类的拷贝构造完成初始化，自己的成员调自己的拷贝构造完成初始化。
上述代码，我们并没有写Student的拷贝构造，那么编译器就会生成默认的，这个默认的就会去调父类的拷贝构造去拷贝父类那部分的成员 ，自己的成员调这个默认的完成自己成员的拷贝构造。
注意：这里Student的成员是一个整型，默认的拷贝构造并不会有什么问题，假设是一个数组呢？就会涉及深浅拷贝的问题，所以我们还要学会自己实现。
如果我们要自己写，在Student子类的拷贝构造中完成对父类的拷贝呢？
同样，也需要显式的调用父类的拷贝构造。
但是我们看父类的拷贝构造，需要接收的是一个Person类的对象。而我们Student显式调用父类拷贝构造的时候这里传的是Student类的对象s。有问题吗？
没问题，这里就发生了切片，也就是子类对象可以赋值给父类的对象/引用/指针。子类对象s就赋值给了父类p的引用。
3.赋值
说明：
子类的赋值也是同样的道理。同样如果涉及深浅拷贝的问题，我们还要自己实现赋值重载。
如果我们要自己写，在子类的赋值重载中完成对父类成员的赋值呢？
同样要显式调用父类的赋值重载。
但是这里程序崩溃了。为什么呢？
调试发现是栈溢出了，把堆栈调出来了以后发现，这里调用了很多operator=(const Student& s)。为什么会出现这样的问题呢？
答案是：这里Student子类在使用"operator=(s)"调用父类赋值重载的时候"会自己调用自己，并没有调用父类的。因为，这里隐藏了父类的赋值，函数名相同就构成了隐藏（重定义）。
指定父类的作用域即可。
4.析构
说明：
同理，我们并没有实现子类的析构函数，编译器会生成默认的，这个默认的会调用父类的析构函数完成清理父类的成员，自己的成员调用这个默认的完成清理。
如果自己写，在子类的析构函数中析构父类呢？
但是这里的析构函数怎么调不动呢？
答案是：这里的"~Person()"和"~Student()"虽然函数名不同，但是也构成了隐藏。
子类的析构函数和父类的析构函数构成了隐藏，他们的名字会被编译器处理成destructor（涉及到多态。随后再细讲）。
所以限定作用域即可，但是，这里输出的结果好像又不对，多了一个"~Person()"父类的析构，这是什么问题？是不是应该去掉一个？
这里应该去掉第一个"~Person()"析构。
正确写法是，不需要我们写父类的析构函数。因为子类的析构函数结束以后会编译器会自动调用父类的析构函数，只有这样才能保证先析构子类后析构父类。
完整代码演示：
class Person { public: Person(const char* name="zhangsan") //Person(const char* name) :_name(name) { cout << "Person()" << endl; } Person(const Person& p) :_name(p._name) { cout << "Person(const Person& p)" << endl; } Person& operator=(const Person& p) { if (this != &p) { _name = p._name; cout << "Person& operator=(const Person& p)" << endl; } return *this; } ~Person() { cout << "~Person()" << endl; } private: string _name;//姓名 }; class Student :public Person { public: Student(const char* name, int stuid) :Person(name) ,_stuid(stuid) { cout << "Student()" << endl; } Student(const Student& s) :Person(s) ,_stuid(s._stuid) { cout << "Student(const Student& s)" << endl; } Student& operator=(const Student& s) { cout << "Student& operator=(const Student& s)" << endl; if (this != &s) { Person::operator=(s); _stuid = s._stuid; } return *this; } ~Student() { //Person::~Person(); cout << "~Student()" << endl; } private: int _stuid;//学号 }; int main() { //Student s; Student s1("jack", 1); Student s2(s1); Student s3("luoxi", 2); s1 = s3; return 0; }
答：让它的构造函数为私有。
如果B要继承A，b就必须去调用父类A的构造函数完成父类成员部分的初始化，但是由于A的构造函数是private的，private成员无论以什么方式继承在子类中都是不可见的。所以，这里就生成不了对象b。
5. 继承与友元
class Student;//前向声明，Person类在声明Display时可能还没有Student的定义， //这里通过前向声明告诉编译器Student是一个类。 class Person { public: friend void Display(const Person& p, const Student& s); protected: string _name; int _id; }; class Student:public Person { protected: int _stuid; }; void Display(const Person& p, const Student& s) { cout << p._name << endl; cout << s._stuid << endl; } int main() { Person p; Student s; Display(p, s); return 0; }
如果此时基类友元想访问子类的成员，只需要在子类中也包含Display的声明即可，让友元关系各自是各自的。
class Student:public Person { friend void Display(const Person& p, const Student& s); protected: int _stuid; };
6. 继承与静态成员
基类定义了static静态成员，那么整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。
代码示例：
class Person { public: Person() { } static int _count; }; int Person::_count = 0; class Student : public Person {}; int main() { Person p; Student s; p._count = 1; s._count = 2; Person::_count++; cout << Person::_count << endl; cout << Student::_count << endl; return 0; }
7. 复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
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";//报错。对_name的访问不明确 // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; }
class Student : virtual public Personclass Teacher : public virtual Personint main() { Assistant a; a._name = "perter"; return 0; }
我们调用监视窗口看到，这里看似还是有三个Person，但是实际上他们指向的Person实际上是同一个。
8. 虚拟继承解决数据冗余和二义性的原理
为了方便研究虚拟继承原理，我们给出一个简单的菱形继承体系，再借助内存窗口观察对象的成员模型（对象在内存中是怎么存的）。
代码示例：
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; cout << sizeof(d) << endl; d.B::_a = 1; d.C::_a = 2; d._b = 3; d._c = 4; d._d = 5; return 0; }
菱形继承的内存对象成员模型：
可以看到，是有数据冗余的，a存在两份。
这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B、C和D，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A
为什么D中B和C部分要去找属于自己的A？那么大家看看当下面的赋值发生时，d是不是要去找出B/C成员中的A才能赋值过去？D d; B b = d; C c = d; //对于父类B中的_b，d可以直接赋值过去，但对于B中的_a呢？ //B中的_a在哪个位置？这时候就要去计算偏移量找到_a的地址这里还有一个问题，在原本的菱形继承中，d的大小为20字节，使用了虚继承之后，d的大小变成了48字节，不是说虚继承解决了数据冗余吗？怎么还比原来占用的空间还大呢？
是因为，虽然解决了A数据的冗余，A只有一份，按理应该为16字节，但是，这里两个虚基表指针又占用了8个字节的空间，所以应该为24个字节。（额外可能编译器还添加了填充字节以确保对象的正确对齐，通常是为了提高内存访问速度）。
当比如此时_a的大小为1000时，就可以感觉到明显的优势了。
9. 继承的总结和反思
1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承， 底层实现就很复杂 。所以一般不建议设计出多继承，一定不要设 计出菱形继承。否则在复杂度及性能上都有问题。2. 多继承可以认为是C++的缺陷之一。3. 继承和组合：
- public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
10. 笔试面试题
1. C++的缺陷有哪些？2. 什么是菱形继承？菱形继承的问题是什么？怎么解决？2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的？3. 继承和组合的区别？什么时候用继承？什么时候用组合？
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
