前言：

我们在学习C++的第一节课就了解到C++是一门面向对象的语言，面向对象的语言有三大特性：

封装、继承、多态

此前我们学习了封装，比如模拟实现vector，string或者迭代器等，不仅有利于我们的维护和管理，也可以降低用户的使用层本（如iterator将各个容器历遍访问的底层进行了封装，外部调用的形式是一样的，其实内部实现不一样）。

同时面向对象不止三大特性，还有其他特性，例如：反射（C++没有，java有），抽象。

本文将介绍面向对象编程的另一大特性：继承。

继承是在更高的维度来设计类。

（一）继承的概念和定义

（1）继承的引入

假如我们要实现一个图书管理系统，我们可能要封装学生类，教师类等：

我们发现：

有的数据和方法（函数）是这两个角色共有的------重复设计了
有的数据和方法（函数）是每个角色独有的

我们写代码讲究的是复用

例如，我们多个成员要重复调用同一段代码，我们会封装一个函数以来调用，以达到复用的效果；

再如，我们模拟实现如vector等容器时，top等接口函数需要返回const类型的值和普通类型的值，但其实内部实现一样，我们会想办法用一个模板参数来传参区分.......

所以为了要解决上述的问题，C++用继承的方式对共同的类进行提取。

（2）继承的概念及定义

概念：

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保

持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象

程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继

承是类设计层次的复用。

继承的定义格式：

上面我们看到Person是父类，也称作基类。Student（Teacher）是子类，也称作派生类。

（3）继承的方式

我们注意到上面学生类的写法是class Student: public Person。这里的public就是一种继承的方式。

C++给出了三种继承的方式：

之前我们学习过访问限定符和这里很相似：

父类成员有三种访问限定符，子类继承父类又有三种继承方式，两两一组合，所以组合出来就有9种组合方式！

继承基类成员访问方式的变化：

总结：

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

总结提炼：

先将基类的私有成员和公有/保护成员分成两类去看待
基类的私有成员在子类都是不可见
基类中其他成员的访问方式是（成员在基类的访问限定符，继承方式）当中，权限小的那一个
权限关系我们可以认为是：public > protected > private

父类的私有成员也会被继承过来，只是语法限制其不能访问。
不可见意思是：在类外面和类里面都不能访问。
之前我们学的，保护和私有都是在类外面不能访问，在类里面可以访问，没有区别
但是在继承这里是有区别的，如果父类的成员是保护（protected）且继承关系不是private，子类可以用，如果父类成员是私有（private）子类不能用。

证明父类私有成员确实被继承下来的程序：



class Person
{
protected:
	//private:

	string _name; //姓名
	string _tel; //电话
	string _address; //地址
};

class Student : public Person
{
protected:

	int _age;
	string _stuId;
};

int main()
{
	Student s;
	cout << sizeof(s) << endl;

	return 0;

无论父类成员是私有（private）还是保护（protected）子类的大小都是一样的 --> 116

（二）基类和派生类对象赋值转换

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。

这里有个形象的说法叫切片（或者切割）。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再讲解，这里先了解一下）

这个过程是天然支持的没有类型转换。

切片举例：

class Person
{
public:
	string _name; //姓名
	string _tel;  //电话
	string _address; //地址

	int _age; //年龄
};

class Student : public Person
{
	string _stuId;
};

class Teacher : public Person
{
	string _workId;
};

int main()
{
	Person p;
	Student s;
	s._name = "张三";
	s._tel = "12345";
	s._address = "学校";

	p = s;
	Person& rp = s;
	Person* ptr = &s;

	return 0;
}

对象赋值切片可以理解为是将值依次赋值过去。

如何理解引用和指针的切片？

rp是子类当中，父类那一部分的别名
指针是指向子类中父类的那一部分，但是指针类型向后看的大小是切出来的一部分

并且这三者地址是一样的：

赋值兼容的规则是建立在 public（公有）继承的基础上

因为成员变量在继承下来时，可能已经变成了保护的或者是私有的
赋值给父类对象有可能就变成父类的公有成员了，这样不太合理

父类/基类对象赋值给子类/派生类对象是不可以的

只能向上去赋值（切片），不能向下赋值
也就是说子能给父，父不能给子
通过强转的话，对象不能强转，基类/父类的指针可以强转成子类/派生类的指针或者是引用也可以（过程涉及到dynamic_cast了解 – 这样才安全），以后学习会讲到
实际当中很少遇到父类转子类，基本上都是子类转父类。

（三）继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。

成员变量同名的隐藏：

class Person
{
protected:
	string _name = "小李子";
	int _num = 111;			
};

class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "子类的身份证号:" << _num << endl; 

		//告诉编译器直接去父类中找
		cout << "父亲类的身份证号:" << Person::_num << endl;

	}
protected:
	int _num = 999; 
};

int main()
{
	Student s1;
	s1.Print();

	return 0;
};

s1中有两个_num，一个是继承父类的，一个是自己的：

成员函数同名的隐藏：

//成员函数同名 -- 两个func的关系是隐藏
class A
{
public:
	void func()
	{
		cout << "A::func()" << endl;
	}
};

class B : public A
{
public:
	void func()
	{
		cout << "B::func()" << endl;
	}
};

int main()
{
	B b;
	b.func();

	//指定作用域去调用
	b.A::func();

	return 0;
}