目录
1.继承的概念及定义
1.1继承的概念
1.2继承的定义
1.2.1定义格式
1.2.2继承关系和访问限定符
1.2.3继承基类成员访问方式的变化
2.基类和派生类对象赋值转换
3.继承中的作用域
4.派生类的默认成员函数
5.继承与友元
6.继承与静态成员
7.复杂的菱形继承及菱形虚拟继承
8.继承的总结和反思
1.继承的概念及定义
1.1继承的概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前都是函数的复用，继承是类设计层次的复用。
#include#include using namespace std; //父类 或基类 class Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } protected: string _name = "zzz"; int _age = 19; }; //子类 或派生类 class Student:public Person { protected: int _stuid; //学号 }; //子类或派生类 class Teacher :public Person { protected: int _jobid;//工号 }; int main() { Student stu; Teacher tea; stu.Print();//直接可以调用 tea.Print(); return 0; }
子类Student和子类Teacher继承父类Person的成员(成员函数+成员变量)都会变成子类的一部分。
1.2继承的定义
1.2.1定义格式
1.2.2继承关系和访问限定符
1.2.3继承基类成员访问方式的变化
这里可以这样理解为权限大小，大的权限会变为小的权限:public>protected>private。
| 类成员/继承方式 | public继承 | protected继承 | private继承 |
| 基类的pubilc成员 | 派生类的public成员 | 派生类protected成员 | 派生类private成员 |
| 基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类private成员 |
| 基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
总结：
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问。
#include#include using namespace std; //父类 或基类 class Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } private: //这里修改为private string _name = "zzz"; int _age = 19; }; class Student :public Person { public: void f() { _age = 20;//基类中的private在派生类中是不可见了(不能使用)，但是也继承了 } protected: int _stuid; //学号 }; int main() { Student stu; stu._age = 20; return 0; }
虽然不可见，但是派生类也继承了：
这里的意义是什么？基类就是有个成员就是不想让你派生类使用，就可以定义为private访问限定符。
2.实际上面的表格我们进行一下总结发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式==Min(成员在基类的访问限定符，继承方式)，public>protected>private。
3.基类private成员在派生类中是不能被访问，如果基类成员不想在类外被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。因为在类和对象那里，private和protected是差不多的根本体现不出来，在基类中private和protected没有区别。
4.在实际运用中一般使用都是public继承，几乎很少使用protected/private继承，也不提倡使用protected/private继承，因为protected/private继承下来的成员都只能在派生类的类里面使用(类外不能访问继承的成员函数)，实际维护性不强。在基类中一般使用public和protected一般不使用private。子类继承方式一般使用public。
5.使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
class默认的不写继承方式，就是private:（ struct依此类推是公有的。）
#include#include using namespace std; //父类 或基类 class Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } protected: string _name = "zzz"; int _age = 19; }; class Student : Person //这里不写继承方式，默认的就是private { public: protected: int _stuid; }; int main() { Student stu; stu.Print(); //这里不可以访问了 return 0; }
继承的成员函数不能访问了：
2.基类和派生类对象赋值转换
切片这里不存在类型转换，是天然的。
注意：
1.派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或者切割(赋值兼容规则)。寓意把派生类中父类那部分切来赋值过去。
#include#include using namespace std; class Person { protected: string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 }; class Student : public Person { public: int _No; // 学号 }; int main() { Person p; Student s; //这里不存在类型转换，是语法天然支持行为：引用那里如果是类型转换了，会产生临时变量(右值常属性)，必须加const 但是没有加const，所以是天然的 //父类=子类赋值兼容 p = s; //派生类对象赋值给基类对象 Person* ptr = &s;//派生类对象地址给基类的指针变量 Person& ref = s;//派生类对象引用给基类的引用变量 return 0; }
2.基类对象不能赋值给派生类对象
强制转换也不行
3.切割或切片是针对public继承方式，其他方式是不行的。因为这里涉及到了权限转换问题。
比如我基类中的成员是public，派生类继承方式是private，在派生类中public都变成了private的访问限定，再把派生类对象切片赋值给基类，涉及到派生类的private访问限定的成员给了基类public访问限定的成员，这涉及到访问权限问题由private变成了public，是不行的。
#include#include using namespace std; class Person { public: //公有的访问限定 string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 }; class Student : private Person//这里是private继承方式 { public: int _No; // 学号 }; int main() { Person p; Student s; p = s; //这里报错，权限转换问题 return 0; }
4.基类的指针或引用可以通过强制类型转换赋值给派生类的指针或引用。但是这里会存在越界访问的问题。
#include#include using namespace std; class Person { protected: string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 }; class Student : public Person { public: int _No; // 学号 }; int main() { Person p; Student s; Student*sp = (Student*)&p; Student& sr = (Student&)p; return 0; }
指针会发生越界(引用也是会发生越界) 很危险。
3.继承中的作用域
1.在继承体系中基类和派生类都有独立的作用域。两个作用域是独立的。
2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。(在子类成员函数中，可以使用 基类::基类成员 显示访问)
3.需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4.注意实际中在继承体系里面最好不要定义同名的成员。
隐藏是针对子类来说的。
当派生类和基类存在成员变量名相同时(隐藏或重定义)，子类会隐藏父类的成员变量，这里和全局变量和局部变量性质一样，就近原则：
#include#include using namespace std; // Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆 class Person { protected: string _name = "小李子"; // 姓名 int _num = 111; // 身份证号 }; class Student : public Person { public: void Print() { cout << " 姓名:" << _name << endl; cout << " 身份证号:" << Person::_num << endl; //直接指明类域，访问父类 cout << " 学号:" << _num << endl; //默认是就近原则，访问的是派生类的 } protected: int _num = 999; // 学号 }; int main() { Student s1; s1.Print(); return 0; };
成员函数只要是函数名相同就构成了隐藏：这两个函数不构成重载，因为函数重载在同一作用域，这里不在同一作用域，而是构成隐藏：
#include#include using namespace std; 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; } }; int main() { B b; b.fun(10);//调用子类的 //b.fun();//这样调用不了父类的，会报错 b.A::fun();//调用父类的 };
4.派生类的默认成员函数
派生类会生成6个默认的成员函数，"默认"的意思就是指我们不写，编译器会自动生成一个，其中4个是重点。
一、默认生成的
1.分析我们不写默认生成的派生类的构造和析构函数：
#include#include using namespace std; 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; // 姓名 }; class Student :public Person { public: protected: int _num; //学号 }; int main() { Student s; return 0; }
这里调用了父类的构造函数和析构函数：
内置类型没有处理，自定义类型调用了它自己默认的构造函数。
总结：我们不写默认生成的派生类的构造和析构：
成员主要是：
1.父类继承下来的成员
父类继承下来的成员：调用父类构造和析构处理
2.自己的(内置类型和自定义类型的成员)
这里的处理和普通类的相同，内置类型不处理，自定义类型的成员调用它自己的默认构造函数。
2.我们不写默认生成的派生类拷贝构造和赋值
#include#include using namespace std; 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; // 姓名 }; class Student :public Person { public: protected: int _num; //学号 string Student_name="hello"; //自定义类型 }; int main() { Student s1; cout << endl; //拷贝构造 Student s2(s1); cout << endl; return 0; }
从父类继承下来的调用父类的拷贝构造：
内置类型完成值拷贝，自定义类型的调用它自己的拷贝构造：
赋值也是一样的。
总结：
成员主要是：
1.父类继承下来的成员
调用父类的拷贝构造和赋值
2.自己的(内置类型和自定义类型的成员)
内置类型完成值拷贝或赋值，自定义类型 调用它自己的拷贝构造和赋值
总结：原则，继承下来的调用父类处理，自己的按普通类基本原则。
二、派生类的这些函数(赋值 拷贝 构造 析构)什么时候需要我们自己写？如果我们要自己写怎么办？如何自己写？
什么时候需要自己写：
1.当基类的构造函数不是默认构造函数的时候(需要传参)，需要我们自己写构造，有默认的编译器会自己调用默认构造函数。
2.如果子类有资源需要释放，就需要自己显示写析构。
3.如果子类存在浅拷贝问题，就需要自己实现拷贝构造和赋值解决浅拷贝问题。
如何自己写：
父类成员调用父类的对应构造、拷贝构造、赋值和析构处理
自己成员按普通类处理。
#include#include using namespace std; class Person { public: 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) { cout << "Person operator=(const Person& p)" << endl; if (this != &p) _name = p._name; return *this; } ~Person() { cout << "~Person()" << endl; } protected: string _name; // 姓名 }; class Student :public Person { public: //构造函数 Student(const char* name="张三",int num=1) : Person("李四") //继承下来的调用父类的构造，只能这样写 ,_num(num) //内置类型 ,Student_name(name) //自定义类型 {} //拷贝构造函数 //s1(s) Student(const Student& s) :_num(s._num) //内置类型直接值拷贝 , Student_name(s.Student_name) //自己内部的自定义类型 去调用它自己的拷贝构造 , Person(s) //父类继承下来的直接传，这里会发生切片,去初始化父类的那部分成员 {} //赋值 Student& operator=(const Student& s) { if (this != &s) { Person::operator=(s);//这里会发生隐藏(函数名相同就会隐藏)，必须指明类域 _num = s._num;//内置内型，值拷贝 Student_name = s.Student_name;//自定义去调用它自己的赋值 } return *this; } //析构函数 ~Student() { cout << "~Student()" << endl; delete[] p; //需要自己清理资源 //父类的: //~Person(); 这样写会报错。 //必须使用Person::~Person(); 为什么会这样呢？ //因为析构函数的名字会被统一处理成destructor(),那么子类的析构函数和父类的就构成了隐藏。 //为什么会统一处理？ 多态章节再看。 //运行后，main:Student s;发现这里调用了2次父类的析构函数，原因是什么？ //因为子类析构函数结束时，会自动调用父类的析构函数 //自定义类型：也是在执行完子类的析构后，编译器会去调用它自己的析构函数 //这里析构的时候会存在一个先后顺序，先构造的后析构，继承下来的父类先构造初始化， //派生类自己内部的后初始化构造。所以先析构派生类内部的，在析构继承下来的。 //派生类对象都是定义在栈里的，因为栈符合先进后出。 //所以自己实现析构函数的时候，不要显示调用父类的析构函数。 //这样才能保证先析构子类，再析构继承下来的父类成员。 } protected: int _num; //学号 string Student_name="hello"; //自定义类型 int* p=new int[10]; //存在需要清理的资源，默认生成的析构不会清理，需要自己写 }; int main() { Student s; return 0; }
最后析构从父类继承下来的成员：
小插曲：验证上面的顺序
这里是先构造了B类内部的成员(A和_b) ,所以先调用B的析构，在B执行完析构函数的最后，会执行A的析构函数，再去析构A。
#includeusing namespace std; class A { public: ~A() { cout << "~A()" << endl; } private: int _a; }; class B { public: ~B() { cout << "~B()" << endl; } //在这个地方会去执行A的析构函数。 private: A a; int _b; }; int main() { B b; return 0; }
总结：子类自己的成员就按以前的方式(普通类)处理，继承的成员调用父类几个默认成员函数处理。
5.继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。你是父类的朋友，但是不一定是我子类的朋友。
#include#include using namespace std; 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; }
直接标红报错。
除非你也是子类的朋友：
#include#include using namespace std; class Student; class Person { public: friend void Display(const Person& p, const Student& s); protected: string _name; // 姓名 }; class Student : public Person { public: friend void Display(const Person& p, const Student& s);//也是子类的朋友 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; }
6.继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。
#include#include using namespace std; 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; // 研究科目 }; int main() { Student s1; Student s2; Student s3; Graduate s4; cout << " 人数 :" << Person::_count << endl; Student::_count = 0; cout << " 人数 :" << Person::_count << endl; //打印地址 cout << &Person::_count << endl; cout << &Student::_count << endl; cout << &Graduate::_count << endl; return 0; }
7.复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题：菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
解决二义性：指明类域
#include#include using namespace std; 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 as; //cout<
虽然这样能解决二义性，但是as对象中还是存在2份相同的Person，数据的冗余性没有解决：
虽然上面解决了二义性，但是数据冗余问题如何解决，是否存在即解决了二义性和数据冗余问题的方法？虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系。在Student和Teacher的继承Person时使用菱形继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
需要注意菱形继承的使用位置：
在冗余类的腰部虚拟继承：
菱形继承：
#include#include using namespace std; 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 as; //cout<
使用的是一个空间(名字为什么又3个，这里和使用引用性质一样，都是同一块空间)：即解决了二义性，也解决了数据冗余问题。
虚拟继承解决数据冗余和二义性的原理
不是虚拟继承的时候：
#includeusing namespace std; 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 //先继承的B 再继承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; }
B和C中各存了一份_a:
虚拟继承：
#includeusing namespace std; class A { public: int _a; }; class B : virtual public A { public: int _b; }; class C : virtual public A { public: int _c; }; class D : public B, public C //先继承的B 再继承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; }
发现B和C里面分别有个数，其实是地址：
分别看下这两个地址里存的什么：存的是偏移量，分别是B到公共A(_a)的偏移量以及C到公共A(_a)的偏移量。
原理图解析：
总结：A一般叫做虚基类，D对象中将A放到了对象组成的最下面，这个A同时属于B和C，那么B和C是通过两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。虚基表内第一行是0，是预留的位置，存储其它东西。所以这里用的是相对位置，而不是公共A的地址(绝对位置)，因为还需要存储其他的东西，绝对位置就没法存储别的东西了，需要另外寻办法。
D d;
B b=d;
C c=d;
这里发生了切片，都是通过虚基表里的偏移量找到公共的A进行B和C的切片赋值。
B*pb=&d;
pb->_a=10;
这里也是通过虚基表里的偏移量找到公共的A。
8.继承的总结和反思
1.很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，所以一般不建议设计出多继承，一定不要设计出菱形继承。否则再复杂度及性能上都有问题。性能上：虚拟继承你存的是公共空间的偏移量，需要去计算才能得到公共空间的位置，因此有性能上的损失。
2.多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承。另外一个缺陷是没有垃圾回收器，new的对象不能自己释放。
3.继承和组合
- public继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象。
- 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
继承： B就是A，比如：人和学生
class A
{
protected:
int _a;
};
class B:public A
{
protected:
int _b;
};
组合：比如：车和轮胎，车有轮胎，不能说车是轮胎。
class A
{
protected:
int _a;
};
class B
{
protected:
A _aa;
int _b;
};
- 优先使用对象组合，而不是类继承。完全符合is-a使用继承，组合也是。当即适合is-a和has-a的时候，优先选择组合。
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语"白箱"是相对可视性而言，在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装(可以直接访问基类的保护和公有成员),基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。白盒测试要求高，因为需要了解很多细节。
- 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义接口。这种复用风格被称为黑箱复用（black-box reuse）,因为对象内部细节是不可见的。对象只以”黑箱“的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装（组合只能访问被组合对象的公有成员）。黑盒测试只用接口就行。
- 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
