💬 欢迎讨论：在阅读过程中有任何疑问，欢迎在评论区留言，我们一起交流学习！
👍 点赞、收藏与分享：如果你觉得这篇文章对你有帮助，记得点赞、收藏，并分享给更多对C++感兴趣的朋友
文章目录
前言
本文我们来补充C++的语法。我们知道，面向对象编程的核心特性有封装、继承、多态。
封装在我们学习类和对象的时候已经学习过了，如有遗忘要及时复习哦！
🚀：类和对象
本文我们将深入浅出的探究继承的底层。
一、何为继承？
1. 1继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
我们通常称被继承的类为基类，继承后的类为派生类。
继承示例：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
//student类继承person类
class Student : public Person
{
protected:
int _stuid; // 学号
};
//teacher类继承person类
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
继承后，父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。
我们使用监视窗口查看Student和Teacher对象并观察代码运行结果
可以发现：Student和Teacher对象中拥有了Person的成员。
1.2 继承的定义
class 基类名 {
// 基类成员
};
class 派生类名 : 访问控制 基类名 {
// 派生类成员
};
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。
1.3 继承方式与范围限定符
继承方式也分为公有继承、保护继承、私有继承：
因此，继承方式与范围限定符两两组合，构成了9种继承基类成员的访问方式：
不难看出：
- 它们的范围权限是依据较小权限的。
基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符、继承方式)。
public > protected > private
- 基类private成员在派生类中无论以什么方式继承都是不可见的。
注意：private成员其实也还是继承到了派生类对象中的，但派生类对象没有任何办法去访问它。 - 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。
注意：最好显示的写出继承方式 - 一般情况下，我们只使用public继承，几乎很少使protetced/private继承
我们平时几乎只会遇到这两种情况（图中红框）
二、基类和派生类对象赋值转换
派生类对象可以直接将其父类的部分赋值给基类的对象、基类的指针、基类的引用。
有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
注意：基类对象不能赋值给派生类对象，指针和引用是可以相互赋值的。
总而言之，向上转换（子->父）都是可以的，向下转换（父->子）对象不可以。
值的一提的是：这里的赋值（类型强制转换）并不会产生临时变量。
三、继承中的作用域
在继承体系中基类和派生类都有独立的作用域。
当子类和父类存在同名成员时，访问子类同名成员时会屏蔽父类的该同名成员，这种情况就是隐藏，或叫重定义
注意：只要求同名，并不要求参数或返回值相同
实际中，在继承体系里面最好不要定义同名的成员。
例题：
两个fun构成什么关系？
a、隐藏/重定义 b、重载 c、重写/覆盖 d、编译报错
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);
};
答案：a (父子类域中，成员函数名相同就构成隐藏)
B中的fun和A中的fun不是构成重载，因为不是在同一作用域
B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
四、派生类的默认成员函数
在派生类中，默认成员函数是如何调用的呢？派生类的成员分为继承的基类成员和自身的成员，对于初始化及清理工作，它们的构造函数和析构函数是如何调用的呢？都由派生类的默认成员函数来完成吗？
答案是NO！
为此，有以下规则需要我们注意：
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
- 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
- 派生类对象初始化先调用基类构造再调派生类构造（构造顺序：先父后子）。
- 派生类对象析构清理先调用派生类析构再调基类的析构（析构顺序：先子后父）。
- 由于多态的原因（多态下篇会学习），基类与派生类的析构函数的函数名被特殊处理了，统一处理成了destructor，导致两函数名相同，构成隐藏。如果显示调用基类析构，无法保证调用顺序先子后父（容易出问题：子类未析构前调用已析构的父类成员）。因此，不建议手动的去显示调用基类的析构。
这里我们大致可以感受到：继承似乎就是在子类中声明了一个父类的匿名对象作为一个成员
五、继承与友元及静态成员
- 友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
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;
}
void main()
{
Person p;
Student s;
Display(p, s);
}
这里代码会报错，因为友元关系不能继承，因此无法访问子类的保护与私有成员。
- 基类定义了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;
}
这里虽有多个派生类，但只有一个静态成员，它们共用这一个静态成员
六、复杂的菱形继承及菱形虚拟继承
6.1 菱形继承
- 单继承：一个子类只有一个直接父类时称这个继承关系为单继承
- 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
- 菱形继承：菱形继承是多继承的一种特殊情况：一个类（Assistant）继承两个基类（Student和Teacher），如果这两个基类都派生于同一个基类（Person），则构成菱形继承。
注意：菱形继承不一定要必须构成菱形，符合这个性质的都属于菱形继承
观察下图，发现菱形继承存在的问题：
数据冗余：存在多份相同的成员，在Assistant的对象中Person成员会有两份
二义性：相同的成员在子类中可以有不同的信息，但在父类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 ; // 主修课程
};
void Test ()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a ;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
6.2 虚拟继承
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
在“菱形腰部”的继承方式前添加一个关键字virtual
示例如下：
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 ; // 主修课程
};
相信你们会十分好奇，虚拟继承是如何解决的呢？
俗话说得好，授之以鱼不如授之以渔，我们来一探究竟！
6.3 虚拟继承解决数据冗余和二义性的原理
为了研究虚拟继承原理，我给出了一个简单的菱形继承继承体系，再借助内存窗口来观察对象成员的模型。
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;
}
未使用虚拟继承时，菱形继承的数据冗余现象：
菱形虚拟继承时：
可以发现，已经不存在数据冗余了，_a成员被存储在d的成员之后，但_a原来的位置并没有清除，似乎是分别存储了两个地址，我们输入这两个地址，看看到底存储了什么
B：
存了一个值：20
A：
存了一个值：12
那么，这两个值是什么呢？细心观察可以发现，这两个值就是当前位置相对于_a成员的偏移量。
而这个地址指向的就是一个虚基表（存储基类偏移量的表）。
问题：为什么前后都是0呢?
给未来的成员偏移量预留空间
编译器的访问顺序就是：先取得偏移量，再计算_a在对象中的地址，再访问。
问题：那么为什么要设计虚基表呢？不存储地址而是存储偏移量难道不好吗？
这里这是一个简化的菱形继承，假如有多个数据冗余的成员，难道我们要对每个成员都提供偏移量在对象内部吗？因此，利用虚基表用存储各个成员的偏移量，可以节省存储空间，当需要访问这些成员，再去通过虚基表的地址，拿到偏移量即可。
下面是上面的Person关系菱形虚拟继承的原理解释：
- 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计多继承，一定不要设
计出菱形继承。否则在复杂度及性能上都有问题。 - 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，比如Java。
完~
下篇预告：多态