C++学习：3多态

Posted 2021-10-28 想文艺一点的程序员

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++学习：3多态相关的知识，希望对你有一定的参考价值。

前面我们已经大概分析了：封装和继承。

封装：将成员变量私有化，然后提供读写的接口供别人进行调用。
继承：子类继承父类的成员变量。

先来分析一个 父类指针 和 子类指针

首先明确指针的目的是为了指向对象，所以就会有， 父类指针指向子类对象，和 子类指针指向父类对象。
父类指针指向子类对象：父类指针可以指向子类对象，是安全的，开发中经常用到（继承方式必须是public）
子类指针指向父类对象：子类指针指向父类对象是不安全的（后面分析为什么是不安全的）

提供一个好记忆的办法：

父类指针指向子类对象：学生属于一个人，所以人可以指向学生。
子类指针指向父类对象：人不一定都是学生，所以学生不能指向人。

分析安全问题：

父类指针指向子类对象是安全的

访问范围：父类指针只能访问父类当中成员变量。
拥有范围：子类对象当中肯定拥有父类的全部成员变量。

子类指针指向父类对象是不安全的

访问范围：子类指针不仅可以访问父类当中的全部成员，而且可以访问自己的独立的成员。
拥有范围：父类对象当中，肯定不会包含子类当中独特的成员变量。

多态

先来铺垫一个项目：假设我们要写一个动物园训练系统

#include <iostream>
using namespace std;

class Cat
{
public:
	void speak() { cout << "miao miao miao " << endl; }
	void eat() { cout << "miao eat " << endl; }
};

class Dog
{
public:
	void speak() { cout << "wang wang wang " << endl; }
	void eat() { cout << "wang eat " << endl; }
};

class Pig
{
public:
	void speak() { cout << "heng heng heng " << endl; }
	void eat() { cout << "heng eat " << endl; }
};

// 训练猫
void train_Cat(Cat *p)
{
	p->speak();
	p->eat();
}
// 训练狗
void train_Dog(Dog *p)
{
	p->speak();
	p->eat();
}
// 训练猪
void train_Pig(Pig *p)
{
	p->speak();
	p->eat();
}

int main()
{
	train_Cat(new Cat);
	train_Dog(new Dog);
	train_Pig(new Pig);

	getchar();
	return 0;
}
运行结果:
miao miao miao
miao eat
wang wang wang
wang eat
heng heng heng
heng eat

分析：

每个动物训练的项目有很多相同的，比如 吃饭、说话、睡觉 等等
假设我们有上百种动物，我们的 train_xxx 函数就需要写上百个。（非常麻烦）

解决：

抽离出共同的项目，然后将他们放到父类当中。
然后让子类去继承。

1、重写

我理解的重写有几点要求：

1、是子类重新写父类的成员函数。

2、重写函数的参数列表必须相同，（不相同的话就成了重载）

3、返回值、函数名、参数列表，都必须和父类的成员函数，完全一模一样。

本能的认为：p 指向的 Cat 对象，那么调用的函数也应该是 Cat 的成员函数呀。

可以发现结果是不如人意的

分析：产生这种情况的原因：

默认情况下，C++是不存在多态的。
C++编译器只会根据指针类型调用对应的函数
父类的指针，那么就调用父类的成员函数。子类的指针，那么就调用子类的成员函数。

测试：

分析汇编：

根本不会进行对象检查
根本不理会指向的是一个什么对象

2、虚函数

解决办法：使用虚函数 （先不要理解为什么，后面进行分析）

虚函数：被virtual修饰的成员函数

C++中的多态通过虚函数（virtual function）来实现

只要在父类中声明为虚函数
子类中重写的函数也自动变成虚函数（也就是说子类中可以省略virtual关键字）

3、总结多态

我认为的多态：重写函数 + Vritual关键字

子类必须要重写父类的成员函数。
父类的对应的成员函数，必须添加 virtual 关键字。

多态的含义：

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。（函数重写，注意不是重载）
在运行时，可以识别出真正的对象类型，调用对应子类中的函数。（虚函数：可以识别出真正的对象类型）

多态的要素

子类重写父类的成员函数（override）
父类指针指向子类对象
利用父类指针调用重写的成员函数

注意：重写和 Vitual 缺一个都不能构成多态。

缺重写：本身就只有一个函数，根本就没有多种形态。
缺Vitual：识别不了对应的对象。

4、虚函数表

虚函数的实现原理是虚表，这个虚表里面存储着最终需要调用的虚函数地址，这个虚表也叫虚函数表

问题：虚函数表在哪块内存里面？

答：在系统给分配的一块内存里面。

问题：怎么找到虚函数表？

答：在每个对象的内存当中有一个指针，指向这个虚函数表。

分析这 12 个字节分别是什么：

最前面的4个字节：存放虚函数表的地址值。
后面的 8 个字节：存放成员变量。

分析虚表里面的值：

0-3 字节：speak（）函数的首地址
4-7 字节：eat（）函数的首地址

注意：所有的 Pig 对象（不管在全局区、栈、堆）共用同一份虚表.

再次分析多态的原理：

（1）如果对象里面没有指向虚函数表的指针，父类指针就根本找不到虚函数表，那么就根本无法调用子类重写的函数。

（2）如果有了 virtual 关键字，那么对象里面就有了 指向虚函数表的指针，父类指针就可以顺着找到子类重写的函数。

5、虚表的汇编

首先了解一点：

call 的类型有两种情况

直接 call：以 E8 开头，直接调用指定函数地址的函数。
间接 call：以 FF 开头，直接调用 eax 当中放的地址，随之 eax 的值发生改变，调用的地址也发生改变。

通过指针来间接调用：

虚函数的作用：

挺高动态性，函数可以进行动态调用。而不是编译的时候就弄好了。

6、虚表的细节

（1）每一个类，都有自己独立的虚表。 同一类的对象共用一个虚表。

（2）调用虚函数的时候，子类当中没有重写该函数，那么调用哪个函数呢？

调用的是父类的成员函数
虚表里面仍然还有 2 个函数地址。（8 个字节）
只是第一个并不是子类的，而是父类的成员函数。

（3）疑问3：当我们是父类指针，指向父类对象的时候，会产生虚表嘛？

也是通过虚表，进行动态调用的。

总结：真正实现的多态，对父类对象和子类对象一视同仁。

只要有虚函数，无论子类还是父类都会生成虚表。
都是通过对象前四个字节，间接找到虚表的地址，从而调用虚函数。

（4）父类被声明为虚函数，子类会自动变为虚函数。

而子类被声明为虚函数，父类并不会自动变为虚函数。

（5）子类有的方法，父类当中没有这个方法，那会怎么调用？

如果父类当中没有这个方法，就不能通过父类指针来进行多态调用。

再会到多态的本质：

子类必须重写该父类的函数。（所以当父类当中没有这个方法，子类就构不成重写）
将对应的函数变为虚函数
最后，通过父类指针来通过对象当中前 4 个的虚函数指针，来实现动态调用。

7、调用父类的成员函数实现

铺垫：

我们重写父类函数的目的有两种情况：

第一种：

父类函数的思想逻辑，我们一点也不想要
我们要全部自己重新写

第二种：

父类函数的思想逻辑，我们可以参考一点
保留父类当中的代码，我们只写一部分自己独特的思想逻辑

8、虚析构函数

如果有多态，应该将析构函数声明为虚函数（虚析构函数）。

为什么要这样做呢？

分别分析以下的两种情况：

不变为虚函数：

不会有虚表产生，就是直接调用，根本不会去找子类的析构函数。

delete 父类指针的时候，只会调用父类的析构函数，并不会调用子类的析构函数，析构不完整。

变为虚函数：

产生虚表，将析构函数放到虚表当中，指针就可以找到子类的析构函数。

delete父类指针时，才会先调用子类的析构函数，然后调用父类的析构函数，保证析构的完整性 。

9、纯虚函数、抽象类

首先不要被唬住，不难就是一个定义而已。

铺垫有一种情况：

父类当中的函数很抽象，我们无法具体的进行实现，所以将他设置为 纯虚函数。

纯虚函数：没有函数体，且初始化为0的虚函数，用来定义接口规范。

怎么理解定义接口规范：（提示其他人怎么编写代码）

比如作为一个动物，应该有这些最基本的函数（eat、speak、run）。
告诉子类，你们应该自己实现这个函数。具体怎么实现，自己去写。

抽象类：

含有纯虚函数的类，不可以实例化（不可以创建对象）。（只要有一个纯虚函数，那么就不可以实例化）
抽象类也可以包含非纯虚函数、成员变量
如果父类是抽象类，子类没有完全重写纯虚函数，那么这个子类依然是抽象类。

多继承

很多编程语言都没有这个特性，因为太复杂了。

多继承：C++允许一个类可以有多个父类（不建议使用，会增加程序设计复杂度）

分析下列代码：

1、有一个 Student 类，属性为 score，方法为 study。

2、有一个 Worker 类，属性为 salary，方法为 work。

这时候出现一个 Undergraduate 类，是一个大学生，他可以一边做学生，也可以一边兼职打工。

3、Undergraduate 类，有自己独特的属性 grade （年级），独特的方法 play。

Undergraduate 将他所有的父类成员变量都继承了过来。

1、多继承体系下的构造函数调用

2、多继承的虚表

如果子类继承的多个父类都有虚函数，那么子类对象就会产生对应的多张虚表

3、同名函数、成员变量的调用

同名函数的调用

同名变量的调用：

4、菱形继承

不要被唬住，就是继承模式看起来像是一个菱形。

问题：

1、成员变量的冗余、重复。

Student、Worker 都继承了 m_age ，所以 Student 和 Worker 都有 m_age 成员变量。故每个都有两个成员变量。
Undergraduate 里面就有 5 个成员变量，一共20个字节。其中有 2 份m_age

struct Undergraduate {
    int m_age;
    int m_score;
    int m_age;
    int m_salary;
    int m_grade;
}

2、二义性：我们不知道 m_age 来自于 Student 还是 Worker

5、虚继承

虚继承可以解决菱形继承带来的问题

写代码：

两个东西必须同时虚继承同一个类

虚继承分析各个对象的内存分布：

注意：

一但是虚继承，会将虚基类的成员变量放到最后面。
一但是虚继承，对象内存当中，会多出 4 个字节（虚表指针）。（此虚表指针并不是指向虚函数的虚表指针）

虚表的内容：

0：虚表指针与本类起始的偏移量。（虚表指针放在本类起始的第一个）

8/20：虚基类第一个成员变量 与本类起始的偏移量 （虚基类第一个成员变量 在本类当中的什么位置）

内存大小：

Student/Worker 类占有 12 个字节。
Undergraduate 类占有 24 个字节。

6、多继承的应用

假设有一个兼职中心，招聘兼职，岗位如下：

1、保姆：要求扫地、做饭

2、老师：要求踢足球、打篮球

应聘的角色：

1、在校大学生

2、上班族

分析：

招聘机构定义接口规范，标明保姆需要会什么，老师需要会什么。
然后应聘者自己去继承，从而实现这些接口。

#include <iostream>
using namespace std;

class JobBaomu {

	virtual void clean() = 0; // 保姆必须符合这两个条件，但是你具体怎么做饭、怎么打扫自己实现
	virtual void cook() = 0;
};

class JobTeacher {
	virtual void playFootball () = 0;
	virtual void playBasketball () = 0;
};
// 学生这两个职业都可以胜任，所以可以都继承下来
class Student : public JobBaomu, public JobTeacher {
	int m_score;
public:
	// 这些需要我们自己来实现
	void clean() {
	}

	void cook() {
	}

	void playFootball() {
	}

	void playBasketball() {
	}

};

class Worker {
	int m_salary；


};


int main()
{


	getchar();
	return 0;
}