C++中的多态与虚函数的内部实现

最新推荐文章于 2022-05-17 22:12:19 发布
最新推荐文章于 2022-05-17 22:12:19 发布
阅读量574 收藏
点赞数 1
分类专栏： C/C++ 文章标签： C++ 派生 多态 虚函数 虚函数表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coderCong/article/details/50510788
版权
1、什么是多态
        多态性可以简单概括为“一个接口，多种方法”。
        也就是说，向不同的对象发送同一个消息， 不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。这是一种泛型技术，即用相同的代码实现不同的动作。这体现了面向对象编程的优越性。
        多态分为两种：
        （1）编译时多态：主要通过函数的重载和运算符的重载来实现。
        （2）运行时多态：主要通过虚函数来实现。
2、几个相关概念
        （1）覆盖、重写（override）
        override指派生类拥有和基类同名的函数。这其中又分为普通函数的override和虚函数的override。只有对虚函数的override才能体现出运行时多态
        （2）重载（overload）
        指同一个作用域出生多个函数名相同，但是形参不同的函数。编译器在编译的时候，通过实参的个数和类型，选择最终调用的函数。
        （3）隐藏（hide）
        分为两种：
            1）局部变量或者函数隐藏了全局变量或者函数
            2）派生类拥有和基类同名的成员函数或成员变量。
        产生的结果：使全局或基类的变量、函数不可见。
3、几个简单的例子
 

/******************************************************************************************************
* File:PolymorphismTest
* Introduction:测试构造函数、析构函数、虚构造函数与纯虚构造函数的一些特性。
* Author:AndyQ
* Date:20141114
* LastModifiedDate:20160113
*******************************************************************************************************/
#include "stdafx.h"
#include <iostream>
using namespace std;
class A
{
public:
	void foo()
	{
		printf("1\n");
	}
	virtual void fun()
	{
		printf("2\n");
	}
};
class B : public A
{
public:
	void foo()  //隐藏。重写
	{
		printf("3\n");
	}
	void fun()  //隐藏。重写
	{
		printf("4\n");
	}
};
int main(void)
{
	A a;
	B b;
	A *p = &a;
	p->foo();  //输出1。
	p->fun();  //输出2。
	p = &b;
	p->foo();  //输出1。因为p是基类指针，p->foo指向一个具有固定偏移量的函数。也就是基类函数
	p->fun();  //输出4。多态。虽然p是基类指针，但实际上指向的是一个子类对象。p->fun指向的是一个虚函数。按照动态类型，调用子类函数    
	B* pB = (B*)&a;
	pB->foo();   //输出3
	pB->fun();   //输出2。pB->fun是虚函数，按照动态类型指向基类。
	return 0;
}

4、运行时多态以及虚函数的内部实现
看了上边几个简单的例子，我恍然大悟，原来这就是多态，这么简单，明白啦！
好，那我们再看一个例子： 
class A
{
public:
	virtual void FunA()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "FunA1" << endl;
<span style="white-space:pre">	</span>};
<span style="white-space:pre">	</span>virtual void FunAA()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "FunA2" << endl;
<span style="white-space:pre">	</span>}
};
class B
{
public:
	virtual void FunB()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "FunB" << endl;
<span style="white-space:pre">	</span>}
};
class C :public A, public B
{
public:
<span style="white-space:pre">	</span>virtual void FunA()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "FunA1C" << endl;
<span style="white-space:pre">	</span>};
};


int _tmain(int argc, _TCHAR* argv[])
{
<span style="white-space:pre">	</span>C objC;
<span style="white-space:pre">	</span>A *pA = &objC;
<span style="white-space:pre">	</span>B *pB = &objC;
<span style="white-space:pre">	</span>C *pC = &objC;

<span style="white-space:pre">	</span>printf("%d  %d\n", &objC, objC);
<span style="white-space:pre">	</span>printf("%d  %d\n", pA, *pA);
<span style="white-space:pre">	</span>printf("%d  %d\n", pB, *pB);
<span style="white-space:pre">	</span>printf("%d  %d\n", pC, *pC);

<span style="white-space:pre">	</span>return 0;
}

运行结果：
5241376  1563032
5241376  1563032
5241380  1563256
5241376  1563032
细心的同志一定发现了pB出了问题，为什么明明都是指向objC的指针，pB跟别人的值都不一样呢？
是不是编译器出了问题呢？

当然不是！我们先讲结论：
（1）每一个含有虚函数的类对象，都会在构造函数执行的时候，生成虚表(virtual table)。这个表，记录了对象的动态类型，决定了执行此对象的虚成员函数的时候，真正执行的那一个成员函数。
（2）对于有多个基类的类对象，会有多个虚表，每一个基类对应一个虚表，同时，虚表的顺序和继承时的顺序相同。
        （3）在每一个类对象所占用的内存中，虚表位于最前边。
先从简单的单个基类说起： 
class A
{
public:
<span style="white-space:pre">	</span>virtual void FunA()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "FunA1" << endl;
<span style="white-space:pre">	</span>};
<span style="white-space:pre">	</span>virtual void FunA2()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">	</span>cout << "FunA2" << endl;
<span style="white-space:pre">	</span>}
};

class C :public A
{
<span style="white-space:pre">	</span>virtual void FunA()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">	</span>cout << "FunA1C" << endl;
<span style="white-space:pre">	</span>};
};
int _tmain(int argc, _TCHAR* argv[])
{
<span style="white-space:pre">	</span>A *pA = new A;
<span style="white-space:pre">	</span>C *pC = new C;
<span style="white-space:pre">	</span>typedef void (*Fun)(void);

<span style="white-space:pre">	</span>Fun fun= (Fun)*((int*)(*(int*)pA));
<span style="white-space:pre">	</span>fun();//pA指向的第一个函数
<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*(int*)pA) +1);
<span style="white-space:pre">	</span>fun();//pA指向的第二个函数

<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*(int*)pC));
<span style="white-space:pre">	</span>fun();//pC指向的第一个函数
<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*(int*)pC) + 1);
<span style="white-space:pre">	</span>fun();//pC指向的第二个函数
<span style="white-space:pre">	</span>return 0;
}
运行结果：
FunA1
FunA2
FunA1C
FunA2

是不是有点晕？没关系。我一点一点解释：pA对应一个A的对象，我们可以画出这样的一个表：

这就是对象*pA的虚表，两个虚函数以声明顺序排列。pA指向对象*pA，则*(int*)pA指向此虚拟表，则(Fun)*((int*)(*(int*)pA))指向FunA，同理，(Fun)*((int*)(*(int*)pA) + 1)指向FunA2。所以，出现了前两个结果。
根据后两个结果， 我们可以推测*pC的虚表如下图所示：

也就是说，由于C中的FunA重写(override)了A中的FunA，虚拟表中虚拟函数的地址也被重写了。
就是这样，这就是多态实现的内部机制。

我们再回到最初的问题：为什么*pB出了问题。
根据上边的结论，我们大胆地进行猜测：由于C是由A、B派生而来，所以objC有两个虚拟表，而由于表的顺序，pA、pC都指向了对应于A的虚拟表，而pB则指向了对应于B的虚拟表。做个实验来验证我们的猜想是否正确：
我们不改变A、B、C类，将问题中的main改一下： 
int _tmain(int argc, _TCHAR* argv[])
{
<span style="white-space:pre">	</span>C objC;
<span style="white-space:pre">	</span>A *pA = &objA;
<span style="white-space:pre">	</span>B *pB = &objC;
<span style="white-space:pre">	</span>C *pC = &objC;

<span style="white-space:pre">	</span>typedef void (*Fun)(void);

<span style="white-space:pre">	</span>Fun fun = (Fun)*((int*)(*(int*)pC));
<span style="white-space:pre">	</span>fun();//第一个表第一个函数
<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*(int*)pC)+1);
<span style="white-space:pre">	</span>fun();//第一个表第二个函数
<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*((int*)pC+1)));
<span style="white-space:pre">	</span>fun();<span style="white-space:pre">	</span>//第二个表第一个函数
<span style="white-space:pre">	</span>fun = (Fun)*((int*)(*(int*)pB));
<span style="white-space:pre">	</span>fun();//pB指向的表的第一个函数
<span style="white-space:pre">	</span>return 0;
}
哈哈，和我们的猜测完全一致：
FunA1C
FunA2
FunB
FunB
我们可以画出这样的虚函数图：
就是这样！
说了这么多，我们把虚函数内部实现机制都讲完了。多态作为虚函数的一个应用，也就是这么实现的 。

理解好多态，对理解面向对象编程的思想有很大的帮助！

coderCong
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++杂记：运行时类型识别（RTTI）与动态类型转换原理
weixin_30237281的博客
06-10 134
运行时类型识别（RTTI）的引入有三个作用： 配合typeid操作符的实现； 实现异常处理中catch的匹配过程； 实现动态类型转换dynamic_cast。 1. typeid操作符的实现 1.1. 静态类型的情形 C++中支持使用typeid关键字获取对象类型信息，它的返回值类型是const std::type_info&，例： #include &lt...
c++的多态和虚函数（一）
coder_xia的专栏
07-10 728
前言：          提到c++的多态，很容易就会想到通过继承和虚函数，让同一函数的调用表现出不同的结果。其实C++支持多种形式的多态，从绑定时间来看可以分成静态多态和动态多态，也称为编译期多态和运行期多态。       其中，动态多态，通过继承和虚函数机制实现；静态多态，在
C++ 虚函数&纯虚函数&抽象类&接口&虚基类&析构函数&虚析构函数
◇在摩天轮上看星星つ
12-14 889
转至：http://www.cnblogs.com/fly1988happy/archive/2012/09/25/2701237.html 1. 多态 在面向对象语言中，接口的多种不同实现方式即为多态。多态是指，用父类的指针指向子类的实例(对象)，然后通过父类的指针调用实际子类的成员函数。 多态性就是允许将子类类型的指针赋值给父类类型的指针，多态是通过虚函数实现的。 多态可以让父
面试题目——多态性的考查
小凡的专栏
06-28 444
笔试题目： #include using namespace std; class A { public: void foo() { printf("1\n"); } virtual void fun() { printf("2\n"); } }; class B : public A { public: void foo() { printf("3\n"); }
c++多态及虚函数表内部原理实战详解
bitcarmanlee的博客
05-17 3650
1.多态实现方式 c++的多态机制主要是靠虚函数来实现。具体来说，就是用父类的指针指向子类的实例，然后通过父类指针调用子类对象中的成员函数。这样，就实现了父类指针的“多态"。 想了解虚函数实现机制，就必须先了解对象的存储方式。 2.类的存储方式 我们以为的存储方式是这样： 上面的图，表示对象的数据和函数代码都要分配内存空间，这样内存的利用效率显然较低，因此实际上存储方式是这样： 每个对象占用存储空间的只是该对象的数据部分（虚函数指针和虚基类指针也属于数据部分），函数代码属于公用部分。我们常说的“A对象的成
C++中的多态与虚函数的内部实现方法
08-31
在C++中，多态（Polymorphism）和虚函数（Virtual Function）是面向对象编程的重要特性，它们允许程序员编写更加灵活和可扩展的代码。本文将深入探讨这两种概念及其内部实现。 首先，多态性是指一个接口可以有不同...
详解C++值多态中的传统多态与类型擦除
08-19
类型擦除通过在内部使用某种形式的动态类型（如虚函数表或类型信息）来实现，但不需要指针或引用，从而减少了内存管理和性能开销。 虚函数的实现通常依赖于虚函数表（vtable）。每个含有虚函数的类都有一个vtable，...
xuhanshu.rar_C++虚函数_虚函数
09-14
在C++编程语言中，虚函数（Virtual Function）是一个核心特性，它允许子类重写父类的方法，实现多态性。多态性是面向对象编程的三大特性之一，另外两个是封装和继承。理解并熟练运用虚函数是C++程序员必备的技能。 ...
C++ 虚函数的内部实现
PupYuan的博客
10-26 650
单继承的情况下 若类有虚函数，则在构造函数的时候编译器会自动为类的实例（对象）在其内存的首部（0地址偏移处）增添一个虚函数表指针vfptr，指向该类的虚函数表。虚函数表中会存放该类所有的虚函数地址，普通函数则不会被放入其中。如果是子类重写了父类的虚函数，那么在建立虚函数表的时候被重写的虚函数的地址被替换成了子类的虚函数。 而使用父类指针BaseClass* base指向一个子类对象DerivedC...
C++使用类名强制指定调用的函数
qq_31424423的博客
11-30 1517
#include<iostream> using namespace std; class A { public: void foo() { printf("1\n"); } virtual void fun() { printf("2\n"); } }; class B : public A { pub...
C 虚函数表及多态内部原理详解
轻松学C语言
01-28 627
C 中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，...
C++多态的实现原理
热门推荐
Demons的博客
05-05 3万+
一、多态的概念            多态就是多种形态，C++的多态分为静态多态与动态多态。静态多态就是重载，因为在编译期决议确定，所以称为静态多态。在编译时就可以确定函数地址。动态多态就是通过继承重写基类的虚函数实现的多态，因为实在运行时决议确定，所以称为动态多态。运行时在虚函数表中寻找调用函数的地址。     在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实...
pi_heif-0.17.0-cp39-cp39-manylinux_2_31_armv7l.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
ubuntu20.04-ssh9.8p1-ssl3.0.14-focal-deb-amd64升级加固脚本.zip
07-27
若有新版本请查看文章最后附件地址：https://blog.csdn.net/liuxin638507/article/details/132450367 特点： 1、同时升级openssh与openssl，采用deb包形式，一键快速升级版本，无需每台单独再次进行编译， 2、隐藏openssh-版本号(openssh9.8p1及之后隐藏版本号还未找到方法) 3、已默认安全加固（已有配置跳过） 安装： 执行 bash upgrade_ssl_ssh_ubuntu.sh 进行安装 注意，升级安装后，确保sshd服务正常，请新开终端进行验证测试 验证 openssl版本： openssl version OpenSSL 3.0.14 4 Jun 2024 (Library: OpenSSL 3.0.14 4 Jun 2024) openssh版本： ssh -V OpenSSH_9.8p1, OpenSSL 3.0.14 4 Jun 2024
avif-0.5.0-cp36-cp36m-manylinux1_i686.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
教务管理系统-毕业设计.zip
07-27
教务管理系统-毕业设计.zip
pillow_jxl_plugin-1.2.5-cp39-none-win_amd64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
pi_heif-0.17.0-cp38-cp38-win_amd64.whl
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
C++虚函数详解：继承、多态与友元
总结来说，纯虚函数是C++中实现多态的关键手段，用于定义接口和规范子类行为；友元则是提供了一种特殊的访问机制，但应谨慎使用以保持封装性和代码的清晰度。理解并掌握这些概念有助于提高编程效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值