【C++】虚函数表实现机制

最新推荐文章于 2024-08-23 13:26:34 发布
最新推荐文章于 2024-08-23 13:26:34 发布
阅读量223 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43465579/article/details/99709484
版权
本文详细探讨了C++对象内存布局，特别是涉及虚函数时的情况。通过实例展示了只有数据成员、没有虚函数、拥有单个和多个虚函数的类对象的内存布局，并揭示了虚函数表（vtable）的工作原理。内容包括虚函数表指针的位置、虚函数表的更新以及单继承类中虚函数的覆盖和新增虚函数的情况。
摘要由CSDN通过智能技术生成

要想知道C++对象的内存布局, 可以有多种方式, 比如:

  1. 输出成员变量的偏移, 通过offsetof宏来得到
  2. 通过调试器查看, 比如常用的VS
1 只有数据成员的对象
class Base1
{
public:
    int base1_1;
    int base1_2;
};

对象大小及偏移:

sizeof(Base1)8
offsetof(Base1, base1_1)0
offsetof(Base1, base1_2)4

可知对象布局:
在这里插入图片描述
可以看到, 成员变量是按照定义的顺序来保存的, 最先声明的在最上边, 然后依次保存!
类对象的大小就是所有成员变量大小之和.

2 没有虚函数的对象
class Base1
{
public:
    int base1_1;
    int base1_2;
 
    void foo(){}
};

结果如下:

sizeof(Base1)8
offsetof(Base1, base1_1)0
offsetof(Base1, base1_2)4

和前面的结果是一样的，非虚函数不占对象内存。

3 拥有仅一个虚函数的类对象
class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
};
sizeof(Base1)12
offsetof(Base1, base1_1)4
offsetof(Base1, base1_2)8

咦? 多了4个字节? 且 base1_1 和 base1_2 的偏移都各自向后多了4个字节!
说明类对象的最前面被多加了4个字节的"东东", what’s it?
现在, 我们通过VS2013来瞧瞧类Base1的变量b1的内存布局情况:
(由于我没有写构造函数, 所以变量的数据没有根据, 但虚函数是编译器为我们构造的, 数据正确!)
(Debug模式下, 未初始化的变量值为0xCCCCCCCC, 即:-858983460)
在这里插入图片描述
看到没? base1_1前面多了一个变量 __vfptr(常说的虚函数表vtable指针), 其类型为void**, 这说明它是一个void*指针(注意:不是数组).

再看看[0]元素, 其类型为void*, 其值为 ConsoleApplication2.exe!Base1::base1_fun1(void), 这是什么意思呢? 如果对WinDbg比较熟悉, 那么应该知道这是一种惯用表示手法, 她就是指 Base1::base1_fun1() 函数的地址.

该类的对象大小为12个字节, 大小及偏移信息如下：

sizeof(Base1)12
offsetof(__vfptr)0
offsetof(Base1, base1_1)4
offsetof(Base1, base1_2)8

现在的对象布局如下:
在这里插入图片描述
虚函数指针__vfptr位于所有的成员变量之前定义.

4 拥有多个虚函数的类对象
class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
    virtual void base1_fun2() {}
};

大小以及偏移信息如下:
在这里插入图片描述
有情况!? 多了一个虚函数, 类对象大小却依然是12个字节!

再来看看VS形象的表现:
在这里插入图片描述
呀, __vfptr所指向的函数指针数组中出现了第2个元素, 其值为Base1类的第2个虚函数base1_fun2()的函数地址.

通过上面两张图表, 我们可以得到如下结论:

  1. 更加肯定前面我们所描述的: __vfptr只是一个指针, 她指向一个函数指针数组(即: 虚函数表)
  2. 增加一个虚函数, 只是简单地向该类对应的虚函数表中增加一项而已, 并不会影响到类对象的大小以及布局情况

前面已经提到过: __vfptr只是一个指针, 她指向一个数组, 并且: 这个数组没有包含到类定义内部, 那么她们之间是怎样一个关系呢?
不妨, 我们再定义一个类的变量b2, 现在再来看看__vfptr的指向:
在这里插入图片描述
通过Watch 1窗口我们看到:

  1. b1和b2是类的两个变量, 理所当然, 她们的地址是不同的(见 &b1 和 &b2)
  2. 虽然b1和b2是类的两个变量, 但是: 她们的__vfptr的指向却是同一个虚函数表

由此我们可以总结出:
同一个类的不同实例共用同一份虚函数表, 她们都通过一个所谓的虚函数表指针__vfptr(定义为void**类型)指向该虚函数表.

是时候该展示一下类对象的内存布局情况了:
在这里插入图片描述

5 拥有多个虚函数的类对象

前面研究了那么多啦, 终于该到研究继承类了! 先研究单继承!

依然, 简单地定义一个继承类, 如下:

class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
    virtual void base1_fun2() {}
};
 
class Derive1 : public Base1
{
public:
    int derive1_1;
    int derive1_2;
};

我们再来看看现在的内存布局(定义为Derive1 d1):
在这里插入图片描述
没错! 基类在上边, 继承类的成员在下边依次定义! 展开来看看:
在这里插入图片描述
经展开后来看, 前面部分完全就是Base1的东西: 虚函数表指针+成员变量定义.
并且, Base1的虚函数表的[0][1]两项还是其本身就拥有的函数: base1_fun1() 和 base1_fun2().

现在类的布局情况应该是下面这样:
在这里插入图片描述

6 本身不存在其他虚函数但存在基类虚函数覆盖的单继承类的内存布局
class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
    virtual void base1_fun2() {}
};
 
class Derive1 : public Base1
{
public:
    int derive1_1;
    int derive1_2;
 
    // 覆盖基类函数
    virtual void base1_fun1() {}
};

可以看到, Derive1类 重写了Base1类的base1_fun1()函数, 也就是常说的虚函数覆盖. 现在是怎样布局的呢?
在这里插入图片描述
特别注意我高亮的那一行: 原本是Base1::base1_fun1(), 但由于继承类重写了基类Base1的此方法, 所以现在变成了Derive1::base1_fun1()!

那么, 无论是通过Derive1的指针还是Base1的指针来调用此方法, 调用的都将是被继承类重写后的那个方法(函数), 多态发生鸟!!!

那么新的布局图:
在这里插入图片描述

7 定义了基类没有的虚函数的单继承的类对象布局

说明一下: 由于前面一种情况只会造成覆盖基类虚函数表的指针, 所以接下来我不再同时讨论虚函数覆盖的情况.

继续贴代码:

class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
    virtual void base1_fun2() {}
};
 
class Derive1 : public Base1
{
public:
    int derive1_1;
    int derive1_2;
 
    virtual void derive1_fun1() {}
};

和第5类不同的是多了一个自身定义的虚函数. 和第6类不同的是没有基类虚函数的覆盖.
在这里插入图片描述
咦, 有没有发现问题? 表面上看来几乎和第5种情况完全一样? 为嘛呢?
现在继承类明明定义了自身的虚函数, 但不见了??
那么, 来看看类对象的大小, 以及成员偏移情况吧:
在这里插入图片描述
居然没有变化!!! 前面12个字节是Base1的, 有没有觉得很奇怪?

好吧, 既然表面上没办法了, 我们就只能从汇编入手了, 来看看调用derive1_fun1()时的代码:

Derive1 d1;
Derive1* pd1 = &d1;
pd1->derive1_fun1();

要注意: 我为什么使用指针的方式调用? 说明一下: 因为如果不使用指针调用, 虚函数调用是不会发生动态绑定的哦! 你若直接d1.derive1_fun1(); , 是不可能会发生动态绑定的, 但如果使用指针: pd1->derive1_fun1(); , 那么 pd1就无从知道她所指向的对象到底是Derive1 还是继承于Derive1的对象, 虽然这里我们并没有对象继承于Derive1, 但是她不得不这样做, 毕竟继承类不管你如何继承, 都不会影响到基类, 对吧?

pd1->derive1_fun1();
00825466  mov         eax,dword ptr [pd1]  
00825469  mov         edx,dword ptr [eax]  
0082546B  mov         esi,esp  
0082546D  mov         ecx,dword ptr [pd1]  
00825470  mov         eax,dword ptr [edx+8]  
00825473  call        eax

汇编代码解释:

第2行: 由于pd1是指向d1的指针, 所以执行此句后 eax 就是d1的地址
第3行: 又因为Base1::__vfptr是Base1的第1个成员, 同时也是Derive1的第1个成员, 那么: &__vfptr == &d1, clear? 所以当执行完 mov edx, dword ptr[eax] 后, edx就得到了__vfptr的值, 也就是虚函数表的地址.
第5行: 由于是__thiscall调用, 所以把this保存到ecx中.
第6行: 一定要注意到那个 edx+8, 由于edx是虚函数表的地址, 那么 edx+8将是虚函数表的第3个元素, 也就是__vftable[2]!!!
第7行: 调用虚函数.

结果:

  1. 现在我们应该知道内幕了! 继承类Derive1的虚函数表被加在基类的后面! 事实的确就是这样!
  2. 由于Base1只知道自己的两个虚函数索引[0][1], 所以就算在后面加上了[2], Base1根本不知情, 不会对她造成任何影响.
  3. 如果基类没有虚函数呢? 这个问题我们留到第9小节再来讨论!

最新的类对象布局表示:
在这里插入图片描述

8 定义了基类没有的虚函数的单继承的类对象布局
class Base1
{
public:
    int base1_1;
    int base1_2;
 
    virtual void base1_fun1() {}
    virtual void base1_fun2() {}
};
 
class Base2
{
public:
    int base2_1;
    int base2_2;
 
    virtual void base2_fun1() {}
    virtual void base2_fun2() {}
};
 
// 多继承
class Derive1 : public Base1, public Base2
{
public:
    int derive1_1;
    int derive1_2;
 
    // 基类虚函数覆盖
    virtual void base1_fun1() {}
    virtual void base2_fun2() {}
 
    // 自身定义的虚函数
    virtual void derive1_fun1() {}
    virtual void derive1_fun2() {}
};

初步了解一下对象大小及偏移信息:
在这里插入图片描述
貌似, 若有所思? 不管, 来看看VS再想:
在这里插入图片描述
哇, 不摆了! 一丝不挂啊! 😃

结论:

  1. 按照基类的声明顺序, 基类的成员依次分布在继承中.
  2. 注意被我高亮的那两行, 已经发生了虚函数覆盖!
  3. 我们自己定义的虚函数呢? 怎么还是看不见?!

好吧, 继续反汇编, 这次的调用代码如下:

Derive1 d1;
Derive1* pd1 = &d1;
pd1->derive1_fun2();

反汇编代码如下:

pd1->derive1_fun2();
00995306  mov         eax,dword ptr [pd1]  
00995309  mov         edx,dword ptr [eax]  
0099530B  mov         esi,esp  
0099530D  mov         ecx,dword ptr [pd1]  
00995310  mov         eax,dword ptr [edx+0Ch]  
00995313  call        eax

解释下, 其实差不多:

第2行: 取d1的地址
第3行: 取Base1::__vfptr的值!!
第6行: 0x0C, 也就是第4个元素(下标为[3])

结论:

Derive1的虚函数表依然是保存到第1个拥有虚函数表的那个基类的后面的.

看看现在的类对象布局图:
在这里插入图片描述
如果第1个基类没有虚函数表呢? 进入第9节!

9 如果第1个直接基类没有虚函数(表)
class Base1
{
public:
    int base1_1;
    int base1_2;
};
 
class Base2
{
public:
    int base2_1;
    int base2_2;
 
    virtual void base2_fun1() {}
    virtual void base2_fun2() {}
};
 
// 多继承
class Derive1 : public Base1, public Base2
{
public:
    int derive1_1;
    int derive1_2;
 
    // 自身定义的虚函数
    virtual void derive1_fun1() {}
    virtual void derive1_fun2() {}
};

来看看VS的布局:

在这里插入图片描述
这次相对前面一次的图来说还要简单啦! Base1已经没有虚函数表了! (真实情况并非完全这样, 请继续往下看!)

现在的大小及偏移情况: 注意: sizeof(Base1) == 8;
在这里插入图片描述
重点是看虚函数的位置, 进入函数调用(和前一次是一样的):

Derive1 d1;
Derive1* pd1 = &d1;
pd1->derive1_fun2();

反汇编调用代码:

pd1->derive1_fun2();
012E4BA6  mov         eax,dword ptr [pd1]  
012E4BA9  mov         edx,dword ptr [eax]  
012E4BAB  mov         esi,esp  
012E4BAD  mov         ecx,dword ptr [pd1]  
012E4BB0  mov         eax,dword ptr [edx+0Ch]  
012E4BB3  call        eax

这段汇编代码和前面一个完全一样!, 那么问题就来了! Base1 已经没有虚函数表了, 为什么还是把b1的第1个元素当作__vfptr呢?
不难猜测: 当前的布局已经发生了变化, 有虚函数表的基类放在对象内存前面!? , 不过事实是否属实? 需要仔细斟酌.

我们可以通过对基类成员变量求偏移来观察:
在这里插入图片描述
可以看到:
&d1==0x~d4
&d1.Base1::__vfptr==0x~d4
&d1.base2_1==0x~d8
&d1.base2_2==0x~dc
&d1.base1_1==0x~e0
&d1.base1_2==0x~e4
所以不难验证: 我们前面的推断是正确的, 谁有虚函数表, 谁就放在前面!

现在类的布局情况:
在这里插入图片描述
那么, 如果两个基类都没有虚函数表呢?

10 What if 两个基类都没有虚函数表
class Base1
{
public:
    int base1_1;
    int base1_2;
};
 
class Base2
{
public:
    int base2_1;
    int base2_2;
};
 
// 多继承
class Derive1 : public Base1, public Base2
{
public:
    int derive1_1;
    int derive1_2;
 
    // 自身定义的虚函数
    virtual void derive1_fun1() {}
    virtual void derive1_fun2() {}
};

前面吃了个亏, 现在先来看看VS的基本布局:
在这里插入图片描述
可以看到, 现在__vfptr已经独立出来了, 不再属于Base1和Base2!

看看求偏移情况:
在这里插入图片描述
Ok, 问题解决! 注意高亮的那两行, &d1==&d1.__vfptr, 说明虚函数始终在最前面!

不用再废话, 相信大家对这种情况已经有底了.

对象布局:
在这里插入图片描述

Mr.tai
关注
专栏目录
虚函数的实现机制
如果可以我想再爱一次的博客
02-28 639
虚函数的实现机制 每个含有虚函数的类都有一张虚函数表。 在继承关系中,子类的虚函数表具有包含心,即父类的虚函数表肯定在子类中有一份完整的拷贝,一模一样。 从虚函数的实现机制来讲讲为何虚函数会影响效率 无论在何种情况,采用多态机制调用虚函数的时候都会比普通函数调用要慢,不管cpu缓存或其他机制做得多好。 现在cpu几经很强了,如果不是设计不合理和性能要求极高,一般虚函数的开销可以忽略。 当用基类指针调用虚函数的时候,能够根据指针所指的实际对象来选择到底是调用那个派生类对象的虚函数,对于这个问题的解就可以找
C++中的虚函数(表)实现机制及模拟实现
zhipingxi的博客
09-16 411
前言 大家都应该知道C++的精髓是虚函数吧? 虚函数带来的好处就是: 可以定义一个基类的指针, 其指向一个继承类, 当通过基类的指针去调用函数时, 可以在运行时决定该调用基类的函数还是继承类的函数. 虚函数是实现多态(动态绑定)/接口函数的基础. 可以说: 没有虚函数, C++将变得一无是处! 既然是C++的精髓, 那么我们有必要了解一下她的实现方式吗? 有必要! 既然C++是从C语言的基础上发展而来的, 那么我们可以尝试用C语言来模拟实现吗? 有可能! 接下来, 就是我一步一步地来解析C++的虚函数的
C++：虚函数和虚表详细总结
最新发布
m0_73727069的博客
08-23 614
虚函数是基类中使用virtual关键字声明的成员函数，支持动态多态性。通过基类指针或引用调用虚函数时，会根据实际对象类型选择调用相应的函数实现。虚函数的声明class Basepublic:// 声明虚函数在派生类中重写虚函数public:// 使用 override 关键字可选虚表是由编译器为每个包含虚函数的类生成的结构，包含该类所有虚函数的指针。
C++虚表的实现原理（windows & linux上）
JesonYang的IT之路
11-21 766
当大家被问到C++多态是怎么实现的时候，一般也就想到了虚函数吧，进一步也就是想到了与其关联的虚表指针，那我们就该想想这个虚表到底是怎么做到的呢。 /*author: Jeson Yang date: 2015.11.21 file: ****.cpp*/ #include using namespace std; #define __stdcallclass CBase { publ
C++虚函数表的实现细节
zxh2075的专栏
12-15 251
虚函数表实现机制
clam_clam的专栏
10-31 2003
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了 这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一
C++虚函数表实现机制解析
虚函数表是C++实现多态性的一个关键机制，主要用于解决动态绑定问题，确保通过基类指针调用子类重写的成员函数时能正确执行子类的实现。在C++中，当一个类声明了虚函数，编译器就会为这个类生成一张虚函数表，表中...
C++虚函数的实现机制分析
01-01
1、简单地说，虚函数是通过虚函数表实现的。那么，什么是虚函数表呢？ 事实上，如果一个类中含有虚函数，则系统会为这个类分配一个指针成员指向一张虚函数表（vtbl），表中每一项指向一个虚函数的地址，实现上就是一...
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了...在这篇文章中，我只想从虚函数的实现机制上面为大家一个清晰的剖析。当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，
C++虚函数及虚函数表解析
07-24
C++的虚函数和虚函数表是面向对象编程中实现多态性的重要机制。多态性允许通过基类指针或引用调用不同子类的重写方法，从而实现更灵活的设计和代码复用。 虚函数（Virtual Function）是基类中声明的一种特殊函数，...
C++虚函数的实现机制——虚函数表
Stoneplay
04-04 461
  C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是...
C++虚函数 虚函数表 多态 实现机制
realizationmecha的专栏
09-15 1225
C++中以虚函数表多态机制实现
c++虚函数实现机制及内存模型
mightySheldor的专栏
11-19 6187
前言 大家都应该知道C++的精髓是虚函数吧? 虚函数带来的好处就是: 可以定义一个基类的指针, 其指向一个继承类, 当通过基类的指针去调用函数时, 可以在运行时决定该调用基类的函数还是继承类的函数. 虚函数是实现多态(动态绑定)/接口函数的基础. 可以说: 没有虚函数, C++将变得一无是处! 既然是C++的精髓, 那么我们有必要了解一下她的实现方式吗? 有必要! 既然C++是从C语言
C++中的虚函数表
littlecorner1205的博客
09-05 1947
面试中遇到最多的问题就是多态的概念，以及多态的实现依据，首先多态发生的条件： （1）必须要有子类继承父类 （2）父类中存在虚函数，并且子类重写该虚函数 （3）父类的指针或者引用指向子类对象 这三个条件缺一不可。那么多态究竟是怎么实现的呢？那就不得不提到虚函数表，在每一个实例化的子类对象的头部，首先是一个指向虚函数表的指针，那么虚函数表中依次存放着父类的方法和子类特有的方法，如果子类重写父类的方法，那么就会替换父类的方法，否则的话就照抄。下面给出一个示意图。 这里面需要注意的是，虚函数表并不是共.
C++之虚函数表
maoliran的博客
06-16 557
虚函数是C++实现多态的一种重要方式，那么虚函数是如果进行工作的，这就依赖于虚函数表，虚函数表是对象生成时自动生成的，当对象释放时，虚函数表也会自动消失，这一切对程序员都是透明的。class Base { public: virtual void f(){cout << "Base::f()" << endl;} virtual void g(){cout << "Base::g()
c++ - 虚函数表
weixin_49303682的博客
12-23 2516
1.什么是虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表 也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器 中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 代码示例： class Base{ public: virtual void A(){cout << "Base::A()" << endl;} virtual void B(){cout &
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值