【C++从0到1】第十七篇：多态

最新推荐文章于 2024-09-17 15:09:23 发布
最新推荐文章于 2024-09-17 15:09:23 发布
阅读量437 收藏 3
点赞数 6
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52809807/article/details/124004873
版权
本文深入探讨了C++中的多态性，包括概念、实现方式、虚函数、抽象类以及多态的原理。通过实例讲解了虚函数的重写、C++11的`override`和`final`关键字的作用，同时对比了重载、覆盖和隐藏的区别。此外，还详细分析了单继承和多继承中虚函数表的结构，并简要提及了菱形继承与虚拟继承。
摘要由CSDN通过智能技术生成

文章目录

一、多态的概念

1.1 概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
在这里插入图片描述

举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

二、 多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
#include <iostream>
using namespace std;

//多态
//静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
//动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person 
{
public:
	//子类中满足三通（函数名，参数，返回自）的虚函数，叫做隐藏（覆盖）
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);

	return 0;
}

在这里插入图片描述
在这里插入图片描述

2.2 虚函数

虚函数：即被virtual修饰的类非静态成员函数称为虚函数。

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

2.3 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

1.不是基类的指针或者引用调用虚函数
在这里插入图片描述
2.不是虚函数
在这里插入图片描述
3.参数列表不同
在这里插入图片描述
虚函数重写的两个例外：

  1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解））
    在这里插入图片描述
    在这里插入图片描述
  2. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
    在这里插入图片描述

普通对像、不管是析构函数是虚函数还是不是析构函数不是虚函数，都会正确调用。
在这里插入图片描述
在这里插入图片描述
补充：
在这里插入图片描述
在这里插入图片描述

2.4 C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰类，表示该类不可以被其他类继承
    在这里插入图片描述
    final：修饰虚函数，表示该虚函数不能再被重写
    在这里插入图片描述

  2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
    在这里插入图片描述
    在这里插入图片描述

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

在这里插入图片描述

三、抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
在这里插入图片描述
抽象类不能实例化出对象
在这里插入图片描述
派生类继承后也不能实例化出对象
在这里插入图片描述
在这里插入图片描述
只有重写纯虚函数，派生类才能实例化出对象
在这里插入图片描述
对于纯虚函数，我们一般只声明，不实现在这里插入图片描述
在这里插入图片描述
为什么会崩溃呢？因为虚函数指针会去虚函数表里面去找。

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

四、多态的原理

4.1 虚函数表

在这里插入图片描述
这是什么原因？
在这里插入图片描述
通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们接着往下分析
在这里插入图片描述

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。

  2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。

  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
    在这里插入图片描述

  5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

  6. 这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。

4.2 多态的原理

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的
Person::BuyTicket，传Student调用的是Student::BuyTicket
在这里插入图片描述
在这里插入图片描述

  1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察下图的绿色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？为什么对象切片就不行呢？而指针和引用切片就可以呢？
    在这里插入图片描述
    在这里插入图片描述
  5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
#include <iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
protected:
	int _a = 1;
};

class Student : public Person
{
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
protected:
	int _b = 2;
};
void Func(Person* p)
{
	p->BuyTicket();
}
int main()
{
	Person mike;
	Func(&mike);
	mike.BuyTicket();
	return 0;
}

// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
…
p->BuyTicket();
// p中存的是mike对象的指针，将p移动到eax中
001940DE mov eax, dword ptr[p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1 mov edx, dword ptr[eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE mov eax, dword ptr[edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的
中取找的。
001940EA call eax
00头1940EC cmp esi, esp
}
int main()
{
…
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址
时，是在编译时已经从符号表确认了函数的地址，直接call 地址
mike.BuyTicket();
00195182 lea ecx, [mike]
00195185 call Person::BuyTicket(01914F6h)
…
}

4.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

五、单继承和多继承关系的虚函数表

5.1 单继承中的虚函数表

在这里插入图片描述

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

#include <iostream>
using namespace std;

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

typedef void (*VF_PTR)();

void PrintVTable(VF_PTR table[])
{
	for(int i = 0; table[i] != nullptr; ++i)
	{
		printf("第%d个虚函数: %p:", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Derive d;
	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函指
	//针的指针数组，这个数组最后面放了一个nullptr
	// 1.先取b的地址，强转成一个int*的指针
	// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
	// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
	// 4.虚表指针传递给PrintVTable进行打印虚表
	// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，
	//虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了
	PrintVTable((VF_PTR*)*(int*)&d);
	return 0;
}

在这里插入图片描述

5.2 多继承中的虚函数表

在这里插入图片描述

#include <iostream>
using namespace std;

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 (*VF_PTR)();

void PrintVTable(VF_PTR table[])
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("第%d个虚函数%: %p:", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Derive d;
	PrintVTable((VF_PTR*)*(void **)&d);
	cout << endl;
	PrintVTable((VF_PTR*)*(void **)((char*)&d+sizeof(Base1)));
	return 0;
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述

5.3 菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用

小唐学渣
关注
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
多态（C++）
缥缈烟雨
07-09 2112
1.多态的概念   同一种东西在不同场景下的多种形态    比如举个例子：见人说人话，见鬼说鬼话2.动态多态的分类       1&gt;静态多态  静态多态是编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型的转换)，可推断出要调用哪个函数，如果有对应的函数就调用该函数，否则出现编译错误  2&gt;动态多态    我们先来看一段代码：#define _CRT_SECURE_N...
《C++》13 C++ 多态
HerGhost
03-30 549
C++ 多态多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。下面的实例中，基类 Shape 被派生为两个类，如下所示：#include <iostream> using namespace std;class Shape { protected: int w
【C++从青铜到王者】第十八篇:C++之多态
森明帮大于黑虎帮的博客
07-23 715
系列文章目录 文章目录系列文章目录前言一、多态的概念1.多态的概念二、多态的定义及实现1.多态的构成条件2.虚函数的认识3.虚函数的重写1.虚函数重写的两个例外之协变2.虚函数重写的两个例外之析构函数的重写4.C++11 override 和 final1.final:修饰虚函数，表示该虚函数不能再被重写2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错5. 重载、覆盖(重写)、隐藏(重定义)的对比三、抽象类的认识1.抽象类的概念2.接口继承和实现继承四、多态的原理1.
C++中的多态
最新发布
2302_81171591的博客
09-17 2258
多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了Person。Person对象买票全价，Student对象优惠买票。2.1.1 实现多态还有两个必须重要条件：• 必须指针或者引⽤调⽤虚函数• 被调⽤的函数必须是虚函数。说明：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向派⽣类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多态的不同形态效果才能达到。2.1.2 虚函数。
C++ std::tuple与std::variant的结合应用：多态类型处理新策略
# 1. C++中的多态类型处理 多态是面向对象编程的核心概念之一，它允许在运行时通过基类指针或引用来操作派生类对象。在C++中，多态的实现主要依赖于虚函数机制，它为基类提供了一种接口，使得派生类能够覆盖这些...
Visual C++从入门到精通第三版.pdf
05-02
《Visual C++从入门到精通第三版》是一本专为初学者设计的C++编程教程，旨在引导读者从基础知识开始，逐步深入到VC++的高级应用。这本书详细讲解了C++语言的基础语法、面向对象编程理念以及Visual C++集成开发环境的...
C++从入门到精通（第4版） PPT电子课件（ 可供教学参考）.7z
07-14
《C++从入门到精通（第4版）》是一本深受程序员喜爱的C++学习教材，而提供的PPT电子课件则是对书籍内容的补充和强化，非常适合教学使用或者自学。C++是一种强大的、面向对象的编程语言，广泛应用于系统软件、应用...
C++从入门到精通1
08-03
《C++从入门到精通1》是一本针对C++初学者的教程，旨在全面系统地讲解C++语言的基础知识和核心概念。从C++概述开始，逐步深入到面向对象编程、程序结构、编码规范以及各种重要的语法元素。下面将详细阐述其中的关键...
现代C++14-编译期多态：泛型编程和模板入门
qq_53280238的博客
06-23 881
while (b!b = r;return a;这里只有一个小小的问题，C++ 的整数类型可不止 int 一种啊。为了让这个算法对像长整型这样的类型也生效，我们需要把它定义成一个模板：while (b!b = r;return a;这个代码里，基本上就是把 int 替换成了模板参数 E，并在函数的开头添加了模板的声明。我们对于“整数”这只鸭子的要求实际上是：可以通过常量 0 来构造可以拷贝（构造和赋值）可以作不等于的比较。
C++ 继承和多态
凡事都是靠练习
08-17 2830
讲解继承和多态，多态的实现原理
C++——继承和多态
weixin_57133901的博客
03-07 2432
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
C++继承和多态
weixin_39861267的博客
05-05 2945
继承和多态
C++继承与多态
m0_62656812的博客
12-16 572
C++是一款面向对象的语言，对象是可以物化的实体，拥有自己的特性与行为，像车子有外形，内核，可以加速减速。而车子又分为保时捷与宝马、奔驰等等。我们想要描述一个车子对象的特征，就需要创建一个类，若为每一种车创建一个类，会使效率下降，而不同车子之间既有共性又有特性，因此，便产生了派生类。 一、派生类的继承方式 派生类（子类）继承了基类（父类）的特性，同时它可以添加自己的诸多特点。继承的方式有以下三种 既：派生类对基类的继承小于等于基类的数据（包括成员变量与成员函数） 无论...
C++面向对象编程第二版：深入解析类、对象与多态
本书详细介绍了C++的核心概念和特性，从过程化编程基础讲起，逐渐深入到面向对象编程的关键元素，如类、对象、动态内存管理、构造函数、析构函数、继承、多态、运算符重载等。书中还涵盖了流处理、模板（包括标准...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小唐学渣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值