搞清楚[继承]，易如反掌

穷不失义，达不离道。——孔丘《论语》

继承

1、简单理解
2、继承
- 2、1、继承的概念
- 2、2、继承定义
- 2、3、基类和派生类对象赋值转换
- 2、4、继承中的作用域
- 2、5、派生类默认成员函数
- 2、6、继承中的特点
- - 2、6、1、友元
  - 2、6、2、静态成员
  - 2、6、3、菱形继承及菱形虚拟继承
3、总结

1、简单理解

封装，继承和多态是C++中不可或缺的组成部分。
封装： 数据和方法放在一起，把想给你访问的定义为公有，不想的定义为私有。就例如：一个类型放到另一个类型里面，通过typedef成员函数调整，封装另一个全新的类型。
继承： 面对对象复用的重要方式->类设计层面上的复用
继承不算是模版，对于模版来说，模版只是一个单纯的一个类，不同的类型，数据类型的不同而已，但是继承不只是类型的区别。
请看一下的图形，第一个表示的是模版的含义，而第二个是继承的含义。
在这里插入图片描述

多态： 通俗来说，就是多种形态，具体点就是去完成某个行为，不同对象去完成会产生不同的状态。如果想要更具体的案例，那么现实生活中到处都是，就比如买火车票，不同身份的人买的价格都会不一样，相同的人买几等座价格也是不一样的，这就是一个比较典型的多态案例。

继承和多态更细节的地方会在下面说，这里只是简单的概括一下主体。

2、继承

2、1、继承的概念

继承机制是面向对象程序设计使代码能够复用的重要手段，能够允许程序员在保持原有类的特性的基础之上就行扩展，增加内容和功能，这样产生的类成为派生类。继承展现了面对对象程序设计的层次结构，体现了由简单到复杂的认知过程。
与函数的复用相类似，继承是类设计层次的复用。

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; 
}

2、2、继承定义

在这里插入图片描述
派生类和基类的名字是根据程序员自行定义的，无所谓叫什么。
其中继承方式有三种，分别是private，protect和public。
当然继承方式和访问限定符的共同作用下才能知道成员变量或者是成员函数到底有了怎么样子的改变。
在这里插入图片描述

总结:

基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

2、3、基类和派生类对象赋值转换

派生类对象 能够直接赋值给基类的对象/基类的指针/基类的引用。也能够俗称是切片或者是切割。形象的说明，在赋值的时候是派生类是将整个对象就行部分切割之后再赋值给基类，保证基类的正确性，没有多余的部分。
在这里插入图片描述

==基类对象不能赋值给派生类。==很显而易见的是基类的成员并没有多余派生类，如果赋值给派生类，一些部分显而易见的会产生问题，包括但不限于随机赋值，也指针的出现。

2、4、继承中的作用域

每一个成员都有自己的作用域，函数有函数的作用域，变量有变量的作用域，乃至main函数也有自己的作用域，所以继承中的作用域也很重要。
1、继承中的基类和派生类都有独立的作用域。
2、当子类和父类中存在同名函数时，子类成员将会屏蔽父类对同名函数的直接访问，这种情况也叫做隐蔽，也叫重定义
3、成员名相同，就构成隐蔽
4、在设计过程中继承体系最好不要定义同名的成员
这段代码中包含了函数名相同时，出现的隐蔽现象，同时也说明了如果隐蔽了该如何调用基类中的成员函数。

#include<iostream>
#include<string>
using namespace std;
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; // 学号
};
void Test()
{
	Student s1;
	s1.Print();
};
int main()
{
	Test();
	return 0;
}

在这里插入图片描述
这样的结果也能够说明，隐蔽的效果和消除隐蔽的方法。
需要注意的是！这里是隐蔽而不是函数重载，重载和隐蔽是两码事！

2、5、派生类默认成员函数

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
派生类的operator=必须要调用基类的operator=完成基类的复制。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
构造时，基类构造再到派生类。析构时显示派生类析构然后再是基类。

2、6、继承中的特点

2、6、1、友元

在基类的定义中可能存在友元，友元的存在在继承中又有什么样的特性呢？
首先，友元是不能够继承的 简单点意思就是你爸爸的朋友不是你的朋友。基类的友元不能够访问子类的私有和保护成员。

2、6、2、静态成员

如果在基类中定义了一个static静态成员，那么整个继承体系中只会有一个这样的成员，无论多少个子类，访问的都是同一个static成员。

2、6、3、菱形继承及菱形虚拟继承

在刚刚讲过的所有的案例中，我们的继承都是按照类似线性的关系来进行继承，但是难免在现实中存在多继承的情况出现。所以一个典型的菱形继承就值得我们来了解并且来分析其中可能存在的问题。
在这里插入图片描述

这样子的菱形继承就会存在问题，导致一个数据到最后一个类的时候可能会有两个不同的值，不知道该怎么继承，所以菱形继承的问题就是在
1）数据冗余 2）二异性
虽然解决二异性的问题能够在数据前加上限定符来特指某个类中的数据，但是对于数据冗余的问题还是没有解决。
所以这个时候，就需要通过virtual，虚继承的方式来解决问题。
virtual在继承过程中就需要加上，如不是最后的时候才加上。
在这里插入图片描述
从内存中能够观察到D对象内部，A，B与C到底怎么储存的，能够类似于类中的函数一样，将A中的a放在最后一个类似于公共的区域，让a只存在一个，改变修改相同的一个a。
那么其中B与C第一行中的那串地址又能代表什么呢，为什么每个的第一行都是一串奇奇怪怪的地址，这究竟是怎么做到能够找到a的地址的呢？其实就是因为这第一行的地址，才能够让我们找到具体的位置在哪，结下来我们将这串地址放在内存中寻找一下，看看是什么。
在这里插入图片描述
也就是这个样子，找到的位置存放的位置之后可以看到存放的第二个地址的地方的数就是按照从当前位置找到公共位置的地址的距离。这样也就说得通两个地址找到A的位置并且能够得到a的值。
用专业的话来说也就是，通过B，C两个指针指向一张表，这两个表就叫虚基表，两个指针就叫虚基表指针。虚基表中存的偏移量可以找到A。

3、总结

其实继承中复杂的大多是是多继承，多继承中又存在菱形继承，有了菱形继承就又会有菱形虚拟继承，有了菱形虚拟继承底层就会变的复杂。所以一般来说都是不设计多继承，即使有着多继承，也尽量不设计菱形继承，否则在复杂度以及性能上都会存在问题。
并且大多数情况之下，继承也可以换成组合的方式来实现。
都能用选组合，其他情况适合什么用什么。
继承的缺点还存在着高耦合的问题。当继承中改变了就会改变后续继承的偶有元素，这样也会造成不少的麻烦，会对后期的修改有较大部分的影响，导致牵一发而动全身的后果。