目录
前言：
正文：
1.继承的概念及定义
1.1继承的概念
1.2继承的本质
2.继承的定义
2.1继承格式
2.2继承关系和访问限定符
3 继承中的作用域
3.1隐藏
4 基类和派生类对象赋值转换
4.1切片
5 派生类中的默认成员函数
5.1隐式调用
5.2显示调用
6 友元和继承
7 继承与静态成员
8 菱形继承
8.1菱形继承的问题
8.2原因
8.3解决方案
9 补充
前言：
进入到c++面向对象的第二大板块继承，对此做一个复习巩固。所有的OO（面向对象）类型的语言都具备三大基本特征：封装-继承-多态，在累和对象复习篇章已经介绍了封装，今天主要复盘一下继承。
正文：
1.继承的概念及定义
1.1继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
需要注意的是：
- 被继承对象：父类/基类（base）
- 继承方：子类/派生类（derive）
1.2继承的本质
继承的本质就是 代码复用，只不过是类层次的复用，比如我定义了一个人的类，包含打印显示函数，作为学生我也有人的特征，我就可以继承这个类，作为教职工我也有人的特征，也可以继承这个类，这样就避免了代码的复写。比如：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; //年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
//以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}我们可以看到两个子类都具备父类中 public属性且相互不干扰。
2.继承的定义
2.1继承格式
继承的格式很简单，子类：继承方式 父类，例如 上面那个例子 class Sdudent ：public Person，需要注意的是 java中继承符号为 extern。
2.2继承关系和访问限定符
继承方式有 共有继承（public）保护继承（protect）和私有继承（private）当然相应的访问限定符也是一样。如下图所示：
需要注意的是：
权限大小：公有 > 保护 > 私有
保护protected比较特殊，只有在 继承 中才能体现它的价值，否则与 私有 作用一样
访问权限和继承方式各有三种，排列组合就是9种，如下所示：
| 父类成员 / 继承权限 | public | protected | private |
| 父类的 public 成员 | 外部可见，子类中可见 | 外部不可见，子类中可见 | 外部不可见，子类中可见 |
| 父类的 protected 成员 | 外部不可见，子类中可见 | 外部不可见，子类中可见 | 外部不可见，子类中可见 |
| 父类的 private 成员 | 都不可见 | 都不可见 | 都不可见 |
总结：无论是哪种继承方式，父类中的 private 成员始终不可被 [子类 / 外部] 访问；当外部试图访问父类成员时，依据 min(父类成员权限, 子类继承权限)，只有最终权限为 public 时，外部才能访问。
假设不注明继承权限，
class默认为private，struct默认为public，最好是注明继承权限
小case：
实际使用中。权限是可以很好保护成员的，如何设计一个不能被继承的类呢？
答：我们只要将我们不想被继承的类设置为私有，这样该类就不能被继承了，代码如下：
class base
{
private：
base();
~base();
}；
class derived public base
{};
int main()
{
derived d;
return 0;
}
3 继承中的作用域
3.1隐藏
隐藏也叫重定义，也可叫做重写（覆盖） 。子类中只要出现和父类中同名的成员就叫重定义不考虑返回值，参数。假设出现同名函数时，默认会将父类的同名函数隐藏调，进而执行子类的同名函数，
//父类
class Base
{
public:
void func() { cout << "Base val: " << val << endl; }
protected:
int val = 123;
};
//子类
class Derived : public Base
{
public:
int func()
{
cout << "Derived val: " << val << endl;
return 0;
}
private:
int val = 668;
};
int main()
{
Derived d;
d.func();
return 0;
}
执行结果：
此时，父子类中的方法和成员均被隐藏，执行的是子类方法，输出的是子类成员
只修改子列方法名为funa
int funA()
{
cout << "Derived val: " << val << endl;
return 0;
}
执行结果：
函数名不同，不构成隐藏，结果是 父类方法+子类成员。
只修改子类成员为 num
int num = 668;
执行结果：
隐藏也消失了，执行结果：子类方法+父类成员
综上所述，当子类中的方法出现 隐藏 行为时，优先执行 子类 中的方法；当子类中的成员出现 隐藏 行为时，优先选择当前作用域中的成员（局部优先）
这已经证明了 父子类中的作用域是独立存在的
如何显式的使用父类的方法或成员？
- 利用域作用限定符
::进行访问范围的限制
4 基类和派生类对象赋值转换
4.1切片
将 父类对象 看作一个结构体，子类对象 看作结构体Plus 版
将 子类对象 中多余的部分去除，留下 父类对象 可接收的成员，最后再将 对象 的指向进行改变就完成了 切片
5 派生类中的默认成员函数
派生类（子类）也是 类，同样会生成 六个默认成员函数（用户未定义的情况下）
不同于单一的 类，子类 是在 父类 的基础之上创建的，因此它在进行相关操作时，需要为 父类 进行考虑。
5.1隐式调用
子类在继承父类后，构建子类对象时 会自动调用父类的 默认构造函数，子类对象销毁前，还会自动调用父类的 析构函数。
class Person
{
public:
Person() { cout << "Person()" << endl; }
~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:
Student() { cout << "Student()" << endl; }
~Student() { cout << "~Student()" << endl; }
};
int main()
{
Student s;
return 0;
}
注意： 自动调用是由编译器完成的，前提是父类存在对应的默认成员函数；如果不存在，会报错
5.2显示调用
因为存在 隐藏 的现象，当父子类中的函数重名时，子类无法再自动调用父类的默认成员函数，此时会引发 浅拷贝 相关问题
class Person
{
public:
Person() { cout << "Person()" << endl; }
void operator=(const Person& P) { cout << "Person::operator=()" << endl; }
~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:
Student() { cout << "Student()" << endl; }
void operator=(const Student&) { cout << "Student::operator=()" << endl; }
~Student() { cout << "~Student()" << endl; }
};
int main()
{
Student s1;
cout << "================" << endl;
Student s2;
s1 = s2;
return 0;
}
此时可用通过 域作用限定符 :: 显式调用父类中的函数
总的来说，子类中的默认成员函数调用规则可以概况为以下几点：
1.子类的构造函数必须调用父类的构造函数，初始化属于父类的那一部分内容；如果没有默认构造函数，则需要显式调用。
2.子类的拷贝构造、赋值重载函数必须要显式调用父类的，否则会造成重复析构问题
3.父类的析构函数在子类对象销毁后，会自动调用，然后销毁父类的那一部分
注意：
子类对象初始化前，必须先初始化父类那一部分
*子类对象销毁后，必须销毁父类那一部分
不能显式的调用父类的析构函数（因为这不符合栈区的规则），父子类析构函数为同名函数 destructor，构成隐藏，如果想要满足我们的析构需求，就需要将其变为虚函数，构成重写
析构函数必须设为 虚函数，这是一个高频面试题，同时也是 多态 中的相关知识
6 友元和继承
友元关系不能被继承
场景：友元函数 Print 可以访问父类中的私有成员，但子类继承父类后，友元函数无法访问子类中的私有成员
class Base
{
friend void Print();
private:
static const int a = 10;
};
class Derived : public Base
{
private:
static const int b = 20;
};
void Print()
{
cout << Base::a << endl;
cout << Derived::b << endl;
}
int main()
{
Print();
return 0;
}
爸爸的朋友不可以是儿子的朋友，如果要想成为儿子的朋友，需要在儿子家里声明为友元。
总结：友元关系不能被继承
7 继承与静态成员
静态成员是唯一存在的，无论是否被继承
静态变量为于静态区，不同于普通的堆栈区，静态变量的声明周期很长，通常是程序运行结束后才会被销毁，因此 假设父类中存在一个静态变量，那么子类在继承后，可以共享此变量
用计数的demo证明一下：
class Base
{
friend void Print();
public:
Base() { num++; }
static int num; //静态变量
};
int Base::num = 0; //初始化静态变量
class Derived : public Base
{
public:
Derived() { num++; }
};
void Print()
{
cout << Base::num << endl;
}
int main()
{
Derived d1;
Derived d2;
Derived d3;
Print();
return 0;
}
由此可见：静态成员是唯一存在的，并且被子类共享
8 菱形继承
单继承：一个子类只能继承一个父类
多继承：一个子类可以继承多个父类（两个及以上）
C++ 支持多继承，即支持一个子类继承多个父类，使其基础信息更为丰富，但凡事都有双面性，多继承 在带来巨大便捷性的同时，也带来了个巨大的坑：菱形继承问题
注：其他面向对象的高级语言为了避免出现此问题，直接规定了不允许出现多继承
8.1菱形继承的问题
class Person
{
public:
string _name; //姓名
};
//本科生
class Undergraduate : public Person
{};
//研究生
class Postgraduate : public Person
{};
//毕业生
class Graduate : public Undergraduate, public Postgraduate
{};
int main()
{
Graduate g1;
g1._name = "zhangsan";
return 0;
}
8.2原因
Undergraduate 中继承了 Person 的 _name，Postgraduate 也继承了 Person 的 _name
Graduate 多继承 Undergraduate 、Postgraduate 后，同时拥有了两个 _name，使用时，无法区分
8.3解决方案
方法一：通过域访问限制符 ::
Graduate g1;
g1.Undergraduate::_name = "zhangsan";
cout << g1.Undergraduate::_name << endl;
这种方法并没有从本质上解决数据冗余的问题
方法二：虚继承
虚继承是专门用来解决 菱形继承 问题的，与多态中的虚函数没有直接关系
虚继承：在菱形继承的腰部继承父类时，加上 virtual 关键字修饰被继承的父类
class Person
{
public:
string _name; //姓名
};
//本科生
class Undergraduate : virtual public Person
{};
//研究生
class Postgraduate : virtual public Person
{};
//毕业生
class Graduate : public Undergraduate, public Postgraduate
{};
int main()
{
Graduate g1;
g1._name = "zhangsan";
cout << g1._name << endl;
return 0;
}
虚继承是如何解决菱形继承问题的？
- 利用 虚基表 将冗余的数据存储起来，此时冗余的数据合并为一份
- 原来存储 冗余数据 的位置，现在用来存储 虚基表指针
虚继承底层是如何解决菱形继承问题的？
对于冗余的数据位，改存指针，该指针指向相对距离
对于冗余的成员，合并为一个，放置后面，假设想使用公共的成员（冗余成员），可以通过相对距离（偏移量）进行访问
这样就解决了数据冗余和二义性问题
为何在冗余处存指针？指针指向空间有预留一个位置，可以用于多态
因此虚继承用的是第二个位置
新建对象进行兼容赋值时，对象指向指针处该指针（偏移量）指向的目标位置不定
无论最终位置在何处，最终汇编指令都一样（得益于偏移量的设计模式）
虚函数是否会造成空间浪费？不会，指针大小固定为 4/8 字节
指针所指向的空间（虚基表）是否浪费空间？可以忽略不计，所有对象共享
假设存在多个共享成员，需要新增指针（偏移量），因为这些成员都是连续的，找到第一个，即可找到其他即使涉及内存对齐问题，编译器也会根据规则做出调整
注意：为了解决 菱形继承 问题，想出了 虚继承 这种绝妙设计，但在实际使用中，要尽量避免出现 菱形继承问题
9 补充
继承是面向对象三大特性之一，非常重要，需要对各种特性进行学习
关于多继承时，哪个父类先被初始化的问题
谁先被声明，谁就会先被初始化，与继承顺序无关
除了可以通过继承使用父类中的成员外，还可以通过 组合 的方式进行使用
公有继承：is-a —> 高耦合，可以直接使用父类成员
组合：has-a —> 低耦合，可以间接使用父类成员
实际项目中，更推荐使用 组合 的方式，这样可以做到 解耦，避免因父类的改动而直接影响到子类
当然，使用哪种方式还要取决于具体场景，具体问题具体分析
//父类
class A {};
//继承
class B : public A
{
//直接继承，直接使用
};
//组合
class C
{
private:
A _aa; //创建 A 对象，使用成员及方法
}
可能有的人问 继承 到底有什么用？答案很简单，为后面的 多态 实现铺路，也就是说，多态的实现离不开继承！
关于之前的 适配器 模式，除了可以使用 组合 的方式进行适配外，还可以通过 继承 的方式进行适配
queue->deque、listreverse_iterator->iterator在通过后者实现前者时，可以通过 组合，也可以通过 继承
