C++虚函数表杂谈

最新推荐文章于 2021-12-23 22:46:31 发布
最新推荐文章于 2021-12-23 22:46:31 发布
阅读量204 收藏
点赞数
分类专栏： 计算机杂谈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengyibing/article/details/82987436
版权

通过分析windows平台简单c++程序来验证C++虚函数网上的相关说法，相关汇编是win32 x86汇编，不过都比较简单。同时回顾内存对齐相关知识，以及函数调用的具体过程的相关知识。

要分析的代码如下：

#include <iostream>
#pragma pack(16)

using namespace std;

struct MyStruct1
{
	char a;
	int s_data1;
	float s_data2;
	double s_data3;
	char s_data4;
	void sfunc1() {};
};

class Class1 {
public:
	int m_data1;
	int m_data2;
	int m_data3;
	virtual void vfunc1() { 
		cout << "class1_test" << endl; 
	};
	virtual void vfunc2() {};
	virtual void vfunc3() {
		cout << "class1_test3" << endl;
	};
	virtual void vfunc4() {};
	virtual void vfunc5() {};
};

class Class2 : public Class1 {
public:
	int n_data1;
	int n_data2;
	int n_data3;
	void vfunc1() { 
		cout << "class2_test" << endl; 
	};
	virtual void vfunc7() {};
	void vfunc3() {
		cout << "class2_test3" << endl;
	};
	void vfunc4() {};
	void vfunc5() {};
	int test;
};

void Test() {
	int a = 0;
	a = a + 10;
	MyStruct1 ms1;
	return;
}

int main() {
	cout << sizeof(MyStruct1) << endl;
	cout << sizeof(Class1) << endl;
	Class1 *c1 = new Class1();
	c1->vfunc1();
	c1->vfunc2();
	c1->vfunc3();
	Class2 *c2 = new Class2();
	c2->vfunc3();
	Test();
	return 0;
}
内存对齐
  1. 数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。
  2. 结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。
  3. 结合1、2可推断：当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。

Win32平台下的微软C编译器(cl.exefor 80×86)的对齐策略：

  1. 结构体变量的首地址是其最长基本类型成员的整数倍；
    备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。
  2. 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
    备注:为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。

以上说明摘自 百度百科

根据以上说明，我们对 MyStruct1 结构体进行分析：
代码中我们写的是按16字节对齐，偏移结构体成员变量的生成文件。

  • 成员变量a是char类型，1个字节，从0字节开始；
  • 成员变量s_data1是int类型，4个字节，每个成员相对于结构体首地址的offset都是成员大小的整数倍，则对齐后的偏移应该是4字节，中间空3个字节；
  • s_data2同理
  • s_data3是double类型，8个字节，每个成员相对于结构体首地址的offset都是成员大小的整数倍，对齐后偏移应该是16字节，中间空4个字节；
  • s_data4是char类型，16+8=24就是它的位置

最后结构体又进行对齐，最大的成员长度是8，所以对齐是32个字节。

1>class MyStruct1	size(32):
1>	+---
1> 0	| a
1>  	| <alignment member> (size=3)
1> 4	| s_data1
1> 8	| s_data2
1>  	| <alignment member> (size=4)
1>16	| s_data3
1>24	| s_data4
1>  	| <alignment member> (size=7)
1>	+---
1>

但是从visual studio的生成中，我们看到结构体 MyStruct1 是用class表示的。这又从侧面说明了struct与class的相似性，struct所有的成员默认都是public的。

如果我们在给 MyStruct1 加一个虚函数的话，我们发现生成中显示的，跟class一样会有虚函数表存在。

struct MyStruct1
{
	char a;
	int s_data1;
	float s_data2;
	double s_data3;
	char s_data4;
	virtual void sfunc1() {};
};

生成

1>class MyStruct1	size(40):
1>	+---
1> 0	| {vfptr}
1> 8	| a
1>  	| <alignment member> (size=3)
1>12	| s_data1
1>16	| s_data2
1>  	| <alignment member> (size=4)
1>24	| s_data3
1>32	| s_data4
1>  	| <alignment member> (size=7)
1>	+---
1>
1>MyStruct1::$vftable@:
1>	| &MyStruct1_meta
1>	|  0
1> 0	| &MyStruct1::sfunc1
1>
1>MyStruct1::sfunc1 this adjustor: 0
虚函数表

c++的面向对象的多态特性，可以通过虚函数来实现。
具体的可以看 https://www.cnblogs.com/malecrab/p/5572730.html

当子类覆盖了父类的虚函数之后，子类对象赋值给父类指针，但是父类指针在调用响应函数的时候，还是调用的子类的实现。

我们来看一下生成文件
父类 Class1

1>class Class1	size(16):
1>	+---
1> 0	| {vfptr}
1> 4	| m_data1
1> 8	| m_data2
1>12	| m_data3
1>	+---
1>
1>Class1::$vftable@:
1>	| &Class1_meta
1>	|  0
1> 0	| &Class1::vfunc1
1> 1	| &Class1::vfunc2
1> 2	| &Class1::vfunc3
1> 3	| &Class1::vfunc4
1> 4	| &Class1::vfunc5
1>
1>Class1::vfunc1 this adjustor: 0
1>Class1::vfunc2 this adjustor: 0
1>Class1::vfunc3 this adjustor: 0
1>Class1::vfunc4 this adjustor: 0
1>Class1::vfunc5 this adjustor: 0

继承并覆盖了虚函数的子类 Class2

1>class Class2	size(32):
1>	+---
1> 0	| +--- (base class Class1)
1> 0	| | {vfptr}
1> 4	| | m_data1
1> 8	| | m_data2
1>12	| | m_data3
1>	| +---
1>16	| n_data1
1>20	| n_data2
1>24	| n_data3
1>28	| test
1>	+---
1>
1>Class2::$vftable@:
1>	| &Class2_meta
1>	|  0
1> 0	| &Class2::vfunc1
1> 1	| &Class1::vfunc2
1> 2	| &Class2::vfunc3
1> 3	| &Class2::vfunc4
1> 4	| &Class2::vfunc5
1> 5	| &Class2::vfunc7
1>
1>Class2::vfunc1 this adjustor: 0
1>Class2::vfunc7 this adjustor: 0
1>Class2::vfunc3 this adjustor: 0
1>Class2::vfunc4 this adjustor: 0
1>Class2::vfunc5 this adjustor: 0

首先，虚函数表是在类的内存的最前面，单继承只有一个虚函数表，因为多继承很不常用，所以就没做分析。
子类覆盖了父类的虚方法后，在子类的虚函数表中响应方法都被替换成了子类实现的方法。
这里的c++代码反汇编后如下：

    59: 	Class1 *c1 = new Class1();
000F2BD8 6A 10                push        10h  
000F2BDA E8 6E E7 FF FF       call        operator new (0F134Dh)  
000F2BDF 83 C4 04             add         esp,4  
000F2BE2 89 85 20 FF FF FF    mov         dword ptr [ebp-0E0h],eax  
000F2BE8 83 BD 20 FF FF FF 00 cmp         dword ptr [ebp-0E0h],0  
000F2BEF 74 26                je          main+0B7h (0F2C17h)  
000F2BF1 33 C0                xor         eax,eax  
000F2BF3 8B 8D 20 FF FF FF    mov         ecx,dword ptr [ebp-0E0h]  
000F2BF9 89 01                mov         dword ptr [ecx],eax  
000F2BFB 89 41 04             mov         dword ptr [ecx+4],eax  
000F2BFE 89 41 08             mov         dword ptr [ecx+8],eax  
000F2C01 89 41 0C             mov         dword ptr [ecx+0Ch],eax  
000F2C04 8B 8D 20 FF FF FF    mov         ecx,dword ptr [ebp-0E0h]  
000F2C0A E8 94 E6 FF FF       call        Class1::Class1 (0F12A3h)  
000F2C0F 89 85 0C FF FF FF    mov         dword ptr [ebp-0F4h],eax  
000F2C15 EB 0A                jmp         main+0C1h (0F2C21h)  
000F2C17 C7 85 0C FF FF FF 00 00 00 00 mov         dword ptr [ebp-0F4h],0  
000F2C21 8B 95 0C FF FF FF    mov         edx,dword ptr [ebp-0F4h]  
000F2C27 89 55 F8             mov         dword ptr [c1],edx  
    60: 	c1->vfunc1();
000F2C2A 8B 45 F8             mov         eax,dword ptr [c1]  
000F2C2D 8B 10                mov         edx,dword ptr [eax]  
000F2C2F 8B F4                mov         esi,esp  
000F2C31 8B 4D F8             mov         ecx,dword ptr [c1]  
000F2C34 8B 02                mov         eax,dword ptr [edx]  
000F2C36 FF D0                call        eax  
000F2C38 3B F4                cmp         esi,esp  
000F2C3A E8 83 E5 FF FF       call        __RTC_CheckEsp (0F11C2h)  
    61: 	c1->vfunc2();
000F2C3F 8B 45 F8             mov         eax,dword ptr [c1]  
000F2C42 8B 10                mov         edx,dword ptr [eax]  
000F2C44 8B F4                mov         esi,esp  
000F2C46 8B 4D F8             mov         ecx,dword ptr [c1]  
000F2C49 8B 42 04             mov         eax,dword ptr [edx+4]  
000F2C4C FF D0                call        eax  
000F2C4E 3B F4                cmp         esi,esp  
000F2C50 E8 6D E5 FF FF       call        __RTC_CheckEsp (0F11C2h)  
    62: 	c1->vfunc3();
000F2C55 8B 45 F8             mov         eax,dword ptr [c1]  
000F2C58 8B 10                mov         edx,dword ptr [eax]  
000F2C5A 8B F4                mov         esi,esp  
000F2C5C 8B 4D F8             mov         ecx,dword ptr [c1]  
000F2C5F 8B 42 08             mov         eax,dword ptr [edx+8]  
000F2C62 FF D0                call        eax  
000F2C64 3B F4                cmp         esi,esp  
000F2C66 E8 57 E5 FF FF       call        __RTC_CheckEsp (0F11C2h)

简单说明一下上述汇编代码的关键地方。
Class1被实例化，并赋值给了指针c1，这里c1的值是指针的offset。
mov eax,dword ptr [c1]
是把 c1 指向的地址的32位内容移动到eax寄存器，这是实例化的对象Class1的offset，即Class1对象的地址。
因为我们之前分析过，虚函数表是在类的开头，所以此时eax寄存器中实际上时存储的虚函数表的地址。
mov edx,dword ptr [eax] 取到虚函数表中指向的函数的offset，
mov eax,dword ptr [edx] 这是取第一个函数的地址，
mov eax,dword ptr [edx+4] 取第二个函数的地址，
mov eax,dword ptr [edx+8] 取第三个函数的地址，

所以正如上面链接提到的博客所说，在编译阶段就把虚函数表中的函数地址做了替换，所以通过偏移来取得真正的函数就不会出错。

构造函数的执行顺序是从父类到基类，从上往下，析构函数是从基类到父类，所以一般把析构函数声明为虚函数，这样无论基类的指针是赋值给了谁，都可以按照从下往上的顺序释放资源。

函数调用过程

这里我们说vc的stdcall。
函数调用过程堆栈

推荐看《汇编语言 基于x86处理器》

滑稽树
关注
专栏目录
C++之虚函数和虚函数表
编程与实战的博客
04-18 2169
哈喽大家好。最近开始学习计算机基础相关的面试内容，比如C++、算法与数据结构、计算机网络、操作系统、设计模式、数据库等。因此把学习时记的笔记分享给大家，希望对大家有所帮助。今天分享的是C++中虚函数和虚函数表相关知识，下面是正文。虚函数概念虚函数是在编译时，并不能确定的类函数，而是在运行时确定的。核心点：通过基类对象访问派生类实现的函数。例子虚函数的例子，通常有三步。第一...
C++中的虚函数表
littlecorner1205的博客
09-05 1948
面试中遇到最多的问题就是多态的概念，以及多态的实现依据，首先多态发生的条件： （1）必须要有子类继承父类 （2）父类中存在虚函数，并且子类重写该虚函数 （3）父类的指针或者引用指向子类对象 这三个条件缺一不可。那么多态究竟是怎么实现的呢？那就不得不提到虚函数表，在每一个实例化的子类对象的头部，首先是一个指向虚函数表的指针，那么虚函数表中依次存放着父类的方法和子类特有的方法，如果子类重写父类的方法，那么就会替换父类的方法，否则的话就照抄。下面给出一个示意图。 这里面需要注意的是，虚函数表并不是共.
C++虚函数及虚函数表解析
weixin_34353714的博客
07-11 148
原文链接：http://www.keepsimply.org/2012/07/11/cpp-vtable/ 作者：独酌逸醉 时间：2012.07.11 声明： 　　本文内容由自互联网资源（见参考资料）、个人的一些 C++ 学习感悟、个人实践整理而成。文章仅以技术学习和交流为目的。如果您发现了文中的错误，或者您有的不同的见解，可以给我留言或者给我发邮件,我们共同探 讨。如果您觉得我...
C++ 虚函数表
菜狗的博客
10-12 152
虚函数 为了实现运行时多态，通过指向派生类的基类指针或引用调用派生类中同名覆盖函数。虚函数用法格式为：virtual 函数返回类型 函数名（参数表） {函数体} 虚函数表 虚函数调用是通过虚函数表简介访问的，就是说基类指针或引用指向派生类时，基类的虚函数表被重写。所以调用函数被覆盖。 含虚函数类的实例的第一个指针变量指向虚函数表， class Base { virtual void Show(vo...
c++ - 虚函数表
weixin_49303682的博客
12-23 2518
1.什么是虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表 也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器 中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 代码示例： class Base{ public: virtual void A(){cout << "Base::A()" << endl;} virtual void B(){cout &
C++之虚函数表
maoliran的博客
06-16 557
虚函数是C++实现多态的一种重要方式，那么虚函数是如果进行工作的，这就依赖于虚函数表，虚函数表是对象生成时自动生成的，当对象释放时，虚函数表也会自动消失，这一切对程序员都是透明的。class Base { public: virtual void f(){cout << "Base::f()" << endl;} virtual void g(){cout << "Base::g()
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++虚函数表实例分析
09-04
C++虚函数表是实现多态性的重要机制，它允许我们通过基类指针或引用调用派生类中的重写方法。在这个实例分析中，我们将深入探讨虚函数表的工作原理，以及如何通过代码来查看和理解它们。 首先，多态性是面向对象...
C++虚函数表分析
12-22
C++虚函数表分析 C++中的虚函数是实现多态性的重要机制，它允许子类重写基类的方法，并在运行时动态决定调用哪个版本的函数。虚函数表（Virtual Function Table，简称vtable）是C++编译器为了实现这种动态绑定而...
c++ 虚函数表
06-12 678
先看以下单继承类层次： class A1{public:       A1(){}       virtual fun(){}       virtual funA1(){}       long m_data1;};  class A2:public A1{public:
c++虚函数表
关小白的博客
07-11 202
详情移步这里 C++虚函数表 这里要注意如果在32位环境下，地址可转为 __int32* 类型 如果在64位环境下，地址可转为 __int64* 类型 补充1（转自知乎陈硕的回答） vtable 是每个 class 类型一个，不是每个对象一个。 vtable 的大小（长度）跟这个 class 的虚函数总数（继承和自己新增）正相关。 vptr 是每个对象一个，vptr 大小是固定的，跟虚函数多少无关。对象的 vptr 在构造和析构的时候可能会变，指向不同的 vtable。对象构造完就不会变了。 补充2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值