【C++】多态 - 为C++增容添彩 _ 多态实例_【内附代码和图片】_[进阶篇_复习专用]

川长思鸟来 2024-04-01 09:28 7阅读 0赞

> **快速导航**
> 
> 1.多态的概念
> 
> 1.1概念
> 
> 1.2现实生活中的实例
> 
> 2.多态的定义及实现
> 
> 2.1多态的条件
> 
> 2.2虚函数重写的条件 
> 
> 2.3虚函数重写的两个特例
> 
> 2.3.1特例一
> 
> 2.3.2特例二 
> 
> 2.4 C++11 final&override
> 
> 2.4.1 final的两种用法
> 
> 2.4.2 override
> 
> 2.5 重载、覆盖(重写)、隐藏(重定义)的对比
> 
> 3.抽象类
> 
> 3.1纯虚函数重写&实例化对象
> 
> 3.2接口继承&实现继承 
> 
> 4.多态的原理
> 
> 4.1虚函数表
> 
> 4.2多态的本质原理
> 
> 4.2.1符合多态的两个条件func1()
> 
> 4.2.2不符合多态的条件(普通调用func2)
> 
> 4.2.3虚表共用 
> 
> 5.虚表的打印
> 
> 5.1单继承中的虚表打印
> 
> 5.2多继承中的虚表打印

## 1.多态的概念 ##

### 1.1概念 ###

> 多态：多种形态，具体说就是去完成某种行为，当不同的对象去完成时会产生不同的状态。

### 1.2现实生活中的实例 ###

**1.买车票**

> 在窗口买票的时候，我们会看到学生半价和军人优先的标语：
> 
> ![39c038f1f47c472aa6286da3263cfd06.png][]
> 
> 无论是学生、军人，还是一般的乘客，想要完成的行为都是一样的，都是买票；但是学生、军人、一般乘客在买票时对应的是三种不同的形态。

**2.支付宝扫码领红包**

![02aa8b5c0e5841bd9461f7cb50c452ce.png][]

> 不同的用户扫码领到的红包是有一定的范围的：
> 
> ![367a9d5f31514456bed7f632ef5b7d49.png][]
> 
> 三种用户都扫了红包，但是得到的红包金额大不相同，这也是一种多态行为的体现。

## 2.多态的定义及实现 ##

### 2.1多态的条件 ###

1.  **被调用的函数是虚函数，而且子类对虚函数进行重写**
2.  **父类的指针/引用调用虚函数**

> 上面提到了虚函数重写，下面来谈一谈什么是虚函数？
> 
> **虚函数：成员函数的前面加上virtual关键字。(必须是成员函数，写在全局函数前面会报错)**
> 
> ![867b4cc96b4b49b490830a82b178435b.png][]

### 2.2虚函数重写的条件 ###

1.  必须是虚函数
2.  父类和子类中函数的**函数名、参数、返回值**相同

class Person {
    public:
    	virtual void BuyTicket() 
    	{
    		cout << "买票-全价" << endl; 
    	}
    };
    class Student : public Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票-半价" << endl;
    	}
    };
    void Test(Person& p)
    {
    	p.BuyTicket();
    }
    int main()
    {
    	Person p;
    	Student s;
    	Test(p);
    	Test(s);
    	return 0;
    }

### 2.3虚函数重写的两个特例 ###

#### 2.3.1特例一 ####

> 父类中的虚函数，子类继承之后，没有写virtual，此时还是重写。(接口继承)

![83c03081e62f4140bee3304ddf096d86.png][]

![20465181b11a4b2984e31289189b8421.png][]

#### 2.3.2特例二 ####

> 函数返回值不同，父类虚函数返回父类对象的指针或者引用，子类虚函数返回子类对象的指针或者引用时，称为协变。

class Person {
    public:
    	virtual Person& BuyTicket() 
    	{
    		cout << "买票-全价" << endl; 
    		return *this;
    	}
    };
    class Student : public Person
    {
    public:
    	virtual Student& BuyTicket()
    	{
    		cout << "买票-半价" << endl;
    		return *this;
    	}
    };

> 调用的时候使用父类对象接受：
> 
> ![ef3777d8205a4ffb9972a0c57b6fdf1c.png][]
> 
> 协变条件下依然满足多态的条件。

### 2.4 C++11 final&override ###

#### 2.4.1 final的两种用法 ####

**1. final修饰虚函数，表示该虚函数不能再被重写。**  
![2ec27d6d270347148874db5352989e0c.png][]

**2.final修饰类，表示该类不能被继承。**

![ff3ef6e53f964a8f958a658ed7d771f5.png][]

#### 2.4.2 override ####

作用：**检查子类虚函数是否完成重写，如果未完成重写会报错。**

class Car
    {
    public:
    	virtual void Drive(){}
    };
    class Benz :public Car
    {
    public:
    	virtual void Drive() override{ cout << "Benz-舒适" << endl; }
    };

### 2.5 重载、覆盖(重写)、隐藏(重定义)的对比 ###

**思维导图**

![6f6dd359198c4e31b0f743c654d4b157.png][]

## 3.抽象类 ##

> 抽象类：在虚函数的后面加上 = 0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类，抽象类是不能实例化出对象的。
> 
> 例如植物、动物都是一种抽象类，是不能实例化出对象的，只有具体指的是某一种植物/动物时，才能实例化出对象。

class Botany
    {
    public:
    	virtual void GetName() = 0;
    	string _name;
    };
    int main()
    {
    	Botany b;
    	return 0;
    }

> ![7b58f830a4ad4cbb86e42a13a4efd665.png][]
> 
> 无法实例化抽象类，抽象类无法实例化。

### 3.1纯虚函数重写&实例化对象 ###

抽象类确实不能实例化对象，但是如果子类中对纯虚函数完成重写，那么就可以实例化出新对象。

class Rose:public Botany
    {
    public:
    	virtual void GetName()
    	{
    		cout << _name << endl;
    	}
    };
    int main()
    {
    	Rose r1;
    	r1._name = "玫瑰花";
    	r1.GetName();
    	return 0;
    }

> ![dc6b6491d1c943c0a4ee4e7bd88f031c.png][] 子类重写了纯虚函数之后，确实能够进行实例化。

### 3.2接口继承&实现继承 ###

> 虚函数的继承是一种接口继承，子类继承的是父类虚函数的接口，目的是为了重写函数的实现，达到多态的目的。
> 
> 普通函数的继承是一种实现继承，子类继承了父类的接口和函数实现，子类可以直接使用函数。

## 4.多态的原理 ##

### 4.1虚函数表 ###

**一道笔试题：**

class Base
    {
    public:
    	virtual void Func1()
    	{
    		cout << "Func1()" << endl;
    	}
    private:
    	int _b = 1;
    };
    int main()
    {
    	Base b;
        cout << sizeof(b) << endl;
    	return 0;
    }

> ![ec8d98d5ce014ef29043dfad9529aad8.png][]
> 
> 代码的执行结果是8，这里有很多人就会有疑问了，对象中只存储成员变量，成员函数存储在公共代码区；
> 
> 那么结果为什么是8，而不是4呢？
> 
> **因为除了\_b成员，还多了一个\_vfptr放在对象的中，对象中的这个指针叫做虚函数表指针。**
> 
> **一个有虚函数的类中至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中。**
> 
> ![e09948e20ff449a8a40f1725e663111a.png][]

### 4.2多态的本质原理 ###

> 多态调用：程序运行时去指向对象的虚表中找到函数的地址，进行调用。

void func1(Person& p)//符合重载
    {
    	p.BuyTicket();
    }
    
    void func2(Person p)
    {
    	p.BuyTicket();
    }
    int main()
    {
    	Person p;
    	Student s;
    
    	func1(p);
    	func1(s);
    
    	func2(p);
    	func2(s);
    	return 0;
    }

#### 4.2.1符合多态的两个条件func1() ####

![0ee49014047e4603908aa5a4fc6a1d99.png][]

虚函数表指针指向的函数地址不同，调用的是不同的函数：

![0b195e10e3744362889db93673a94680.png][]

>  **运行时，会到指向对象的虚表中找到对应的虚函数地址，进行调用。**

#### 4.2.2不符合多态的条件(普通调用func2) ####

![635ee850409c4f04a27a0efeccfee707.png][]

> **普通的函数调用：编译链接时确定函数的地址，运行时直接调用。**

#### 4.2.3虚表共用 ####

class Person {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票-全价" << endl;
    	}
    };
    class Student : public Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票-半价" << endl;
    	}
    };
    int main()
    {
    	Person p1;
    	Person p2;
    
    	Student s1;
    	Student s2;
    	return 0;
    }

> ![1a21c701b0e54891a7accba4bd44471b.png][]
> 
> **同一类型的对象共用一个虚表。**

> ![76754b509d884b70924099eb62d0b4d7.png][]
> 
> **不管子类中是否完成了重写，子类虚表跟父类虚表都不是同一个(VS2019下)。**

## 5.虚表的打印 ##

### 5.1单继承中的虚表打印 ###

class Base {
    public:
    	virtual void func1() { cout << "Base::func1" << endl; }
    	virtual void func2() { cout << "Base::func2" << endl; }
    private:
    	int a;
    };
    class Derive :public Base {
    public:
    	virtual void func1() { cout << "Derive::func1" << endl; }
    	virtual void func3() { cout << "Derive::func3" << endl; }
    	virtual void func4() { cout << "Derive::func4" << endl; }
    private:
    	int b;
    };
    int main()
    {
    	Base b;
    	Derive d;
    	return 0;
    }

打印虚表需要用到指针内容，主要考验指针内容的理解。

下面通过VS2019的监视窗口看一下虚表：

![3a01f2ca65d44e68b884aabbbb79c358.png][]

观察监视窗口可以发现我们看不到func3和func4，这里其实是编译器的监视窗口故意隐藏了这两个函数，也可以认为是VS2019的小bug。

既然监视窗口看不到具体的虚表，那么我们可以使用代码来打印虚表中的函数。

> 思路：
> 
> 1.  取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
> 2.  先取b的地址，强转成一个int\*的指针
> 3.  再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
> 4.  再强转成VFPTR\*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组
> 5.  虚表指针传递给PrintVTable进行打印虚表

typedef void(*VFPTR) ();//把函数指针重命名为VFPTR,注意不能这样写：typedef void(*)() VFPTR
    void PrintVTable(VFPTR vTable[], int len)//形参实际上是一个二级指针
    {
    	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    	cout << " 虚表地址>" << vTable << endl;
    	for (int i = 0; i < len; ++i)
    	{
    		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    		VFPTR f = vTable[i];
    		f();//函数指针后面加()，可以直接调用函数
    		cout << endl;
    	}
    	cout << endl;
    }
    int main()
    {
    	Base b;
    	Derive d;
    	VFPTR * vTableb = (VFPTR*)(*(int*)&b);
    	PrintVTable(vTableb, 2);
    	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTabled, 4);
    	return 0;
    }

> ![19ac57e3c8984bc9a5671ddb93330f85.png][]
> 
> 通过打印结果，我们确实可以看到子类虚函数表中的4个虚函数地址 。

### 5.2多继承中的虚表打印 ###

class Base1 {
    public:
    	virtual void func1() { cout << "Base1::func1" << endl; }
    	virtual void func2() { cout << "Base1::func2" << endl; }
    private:
    	int b1;
    };
    class Base2 {
    public:
    	virtual void func1() { cout << "Base2::func1" << endl; }
    	virtual void func2() { cout << "Base2::func2" << endl; }
    private:
    	int b2;
    };
    class Derive : public Base1, public Base2 {
    public:
    	virtual void func1() { cout << "Derive::func1" << endl; }
    	virtual void func3() { cout << "Derive::func3" << endl; }
    private:
    	int d1;
    };
    typedef void(*VFPTR) ();
    void PrintVTable(VFPTR vTable[], int len)
    {
    	cout << " 虚表地址>" << vTable << endl;
    	for (int i = 0; i < len; ++i)
    	{
    		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    		VFPTR f = vTable[i];
    		f();
    	}
    	cout << endl;
    }

现在的问题是：func3在Base1的虚表中还是Base2的虚表中？

既然不知道在哪一个虚表中，那就分别打印虚表的三个函数地址，看看哪一个虚表能够调用到func3，那func3就在哪一个虚表中。

int main()
    {
    	Derive d;
    	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTableb1, 3);
    	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));//指向第二个虚表
    	PrintVTable(vTableb2, 3);
    	return 0;
    }

> ![c18e3ab28fb540e28e7cf24690d4150c.png][]
> 
> **结论：多继承派生类的未重写的虚函数放在第一个继承父类部分的虚函数表中。**

**总结：继承和多态的内容还是相对复杂的，想要掌握的话一定要自己去理解代码并且尝试自己去使用编译器的调试窗口来辅助自己理解，当然也要注意复习，不然知识肯定是会遗忘的！！！**

[39c038f1f47c472aa6286da3263cfd06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7950b498bede418eb2d48f69e836bff6.png
[02aa8b5c0e5841bd9461f7cb50c452ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/aa41e2121f354d02b2da083af9054108.png
[367a9d5f31514456bed7f632ef5b7d49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8c47adcf0e9f4fda8febf4143cf4e0fc.png
[867b4cc96b4b49b490830a82b178435b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/544057a1f9c64d46986c71af4162e3b8.png
[83c03081e62f4140bee3304ddf096d86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/031658cf5f934b75886206f020d7920e.png
[20465181b11a4b2984e31289189b8421.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7e41d38fb7d746a3924f56336c7a1d45.png
[ef3777d8205a4ffb9972a0c57b6fdf1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/786e25fc770041d3897d5d988af31ca3.png
[2ec27d6d270347148874db5352989e0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/59e65e8d305c4c6d9fb7ca33e44357fb.png
[ff3ef6e53f964a8f958a658ed7d771f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5c02dff6342e480ca6809a88caab6062.png
[6f6dd359198c4e31b0f743c654d4b157.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/12a9751831bf48419f6ac7b889c8eb45.png
[7b58f830a4ad4cbb86e42a13a4efd665.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e73f8c534b9b488ea2b017cf79b5d807.png
[dc6b6491d1c943c0a4ee4e7bd88f031c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8d33e2fe79e5445f82340c27e50daab3.png
[ec8d98d5ce014ef29043dfad9529aad8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2aaa0eb88f7740babd229e0bbc7a0aff.png
[e09948e20ff449a8a40f1725e663111a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/00415c93971c4c7d8e52a643fbdf1409.png
[0ee49014047e4603908aa5a4fc6a1d99.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bd04a35ecd4f44dcb21f24687ecec9c2.png
[0b195e10e3744362889db93673a94680.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e7d68817c00948d596d69cd52a797163.png
[635ee850409c4f04a27a0efeccfee707.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/18e9a31fcee7435196bb2a9fb21cc1f1.png
[1a21c701b0e54891a7accba4bd44471b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/df587a6f29a04b2a9d7d22a2ef708f3f.png
[76754b509d884b70924099eb62d0b4d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3bc75c71781f466f9eb4478d5c79e2c9.png
[3a01f2ca65d44e68b884aabbbb79c358.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e997ee7b2b214ece9061a7e0b91766e6.png
[19ac57e3c8984bc9a5671ddb93330f85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/132591134d8446a3a08005bcf943704a.png
[c18e3ab28fb540e28e7cf24690d4150c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/de4b334532484ff78257480e3f02d5bb.png