虚函数在内存中的结构

最新推荐文章于 2024-06-29 17:14:10 发布
原创 最新推荐文章于 2024-06-29 17:14:10 发布 · 7.4k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#汇编 #class #c++ #c #struct #面试

作者面试C++工作时多次遇到虚拟函数问题，经学习后分享理解。先介绍C语言函数调用方式，通过汇编代码展示；接着说明C++中非虚函数调用，最后重点分析虚拟函数，指出其通过对象自身指针指向虚拟函数列表实现多态，还提及一些概念仍待清晰。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

                                                    

 

 

 

         这段日子面试了两次有关C++的工作，面试过程中都遇到了有关虚拟函数的问题。第一次遇到该问题的时候，我只能说出虚拟函数的用法，但具体在内存中的排布就不知道了。面试完之后，马上到书店找了一本《inside the c++ object model》，由于没有找到侯捷译的中文版，拿了本英文版的回去。英文较菜，也没有定下心来看，结果第一章的内容就理解错了。第二次面视的时候，还是同样的问题，结果回答错了。昨天晚上又重新看了一晚上，感觉对这部分内容有了正确的理解。决定把自己理解的内容，拿出来，争取能和大家分享一下，有错误的地方，也欢迎高手的斧正。

 

 

 

一，C语言中函数的调用方式

 

 

 

没有理解虚拟函数在内存中的处理形式，我觉得是自己在看书的时候缺乏思考造成的，只是跟着书本走，但没有仔细去想相关的内容。所以造成了思维闭路，导致很多东西理解错误。我觉得理解虚函数，还得从对函数在代码中的组织形式开始。好了，先谈谈我对函数的理解吧。

我们知道一个可执行有数据段，代码段等来存储文件的执行信息。而汇编就是用这种格式来写代码的，高级语言如C等都需要把文件转化为汇编之后，进行编译，最终生成可执行文件。所以把C文件转化为汇编，可能能更好的理解代码的组织形式。

我们先来看一段简单的C文件：

Void first()

{

}

Void main()

{

     frist();

}

 

 

 

在main中是通过何种形式来调用first的呢？学过汇编的话，我们知道汇编   中的函数的调用是通过call指令来实现的。试着编译以上的C程序，并通过dumpbin反编译它的exe文件，我们可以得到以下一段代码。

 

 

 

  00401000: CC                 int         3

  00401001: CC                 int         3

  00401002: CC                 int         3

  00401003: CC                 int         3

  00401004: CC                 int         3

@ILT+0(_first):

  00401005: E9 16 00 00 00     jmp         _first

@ILT+5(_main):

  0040100A: E9 41 00 00 00     jmp         _main

  0040100F: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC  ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

  0040101F: CC                                               Ì

_first:

  00401020: 55                 push        ebp

  00401021: 8B EC              mov         ebp,esp

  00401023: 83 EC 40           sub         esp,40h

  00401026: 53                 push        ebx

  00401027: 56                 push        esi

  00401028: 57                 push        edi

  00401029: 8D 7D C0           lea         edi,[ebp-40h]

  0040102C: B9 10 00 00 00     mov         ecx,10h

  00401031: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

  00401036: F3 AB              rep stos    dword ptr [edi]

  00401038: 5F                 pop         edi

  00401039: 5E                 pop         esi

  0040103A: 5B                 pop         ebx

  0040103B: 8B E5              mov         esp,ebp

  0040103D: 5D                 pop         ebp

  0040103E: C3                 ret

  0040103F: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC  ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

  0040104F: CC                                               Ì

_main:

  00401050: 55                 push        ebp

  00401051: 8B EC              mov         ebp,esp

  00401053: 83 EC 40           sub         esp,40h

  00401056: 53                 push        ebx

  00401057: 56                 push        esi

  00401058: 57                 push        edi

  00401059: 8D 7D C0           lea         edi,[ebp-40h]

  0040105C: B9 10 00 00 00     mov         ecx,10h

  00401061: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

  00401066: F3 AB              rep stos    dword ptr [edi]

  00401068: E8 98 FF FF FF     call        @ILT+0(_first)

 

  0040106D: 5F                 pop         edi

  0040106E: 5E                 pop         esi

  0040106F: 5B                 pop         ebx

  00401070: 83 C4 40           add         esp,40h

  00401073: 3B EC              cmp         ebp,esp

  00401075: E8 16 00 00 00     call        __chkesp

  0040107A: 8B E5              mov         esp,ebp

  0040107C: 5D                 pop         ebp

  0040107D: C3                 ret

  0040107E: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC  ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

  0040108E: CC CC                                            ÌÌ

 

 

 

该段代码中有一些是调试信息，不需要管它。我们知道程序一定从_main来执行，调用开始会有一些参数信息去配置，而后就通过00401068: E8 98 FF FF FF     call        @ILT+0(_first) 跳转到first函数。这样应该对C生成的执行文件的代码段有一个基本的了解，所有的函数被放到了代码段中，各个函数的调用是通过call来转到函数的开始地址来执行（当然每个函数都需要有自己独特的名字，其实到了具体的执行文件中，是通过数字来定位这些信息的）。

 

 

 

二，C++中非虚函数的调用方式

 

 

 

先看如下一段代码：

 

 

 

class point

{

public:

            void first();

};

 

 

 

void point::first()

{

            return;

}

 

 

 

void main()

{

            point pt;

            pt.first();

}

 

 

 

反编译后程序如下：

00401000: CC                 int         3

  00401001: CC                 int         3

  00401002: CC                 int         3

  00401003: CC                 int         3

  00401004: CC                 int         3

@ILT+0(_main):

  00401005: E9 16 00 00 00     jmp         _main

@ILT+5(?first@point@@QAEXXZ):

  0040100A: E9 51 00 00 00     jmp         ?first@point@@QAEXXZ

  0040100F: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC  ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

  0040101F: CC                                               Ì

_main:

  00401020: 55                 push        ebp

  00401021: 8B EC              mov         ebp,esp

  00401023: 83 EC 44           sub         esp,44h

  00401026: 53                 push        ebx

  00401027: 56                 push        esi

  00401028: 57                 push        edi

  00401029: 8D 7D BC           lea         edi,[ebp-44h]

  0040102C: B9 11 00 00 00     mov         ecx,11h

  00401031: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

  00401036: F3 AB              rep stos    dword ptr [edi]

  00401038: 8D 4D FC           lea         ecx,[ebp-4]

  0040103B: E8 CA FF FF FF     call        @ILT+5(?first@point@@QAEXXZ)

 

  00401040: 5F                 pop         edi

  00401041: 5E                 pop         esi

  00401042: 5B                 pop         ebx

  00401043: 83 C4 44           add         esp,44h

  00401046: 3B EC              cmp         ebp,esp

  00401048: E8 43 00 00 00     call        __chkesp

  0040104D: 8B E5              mov         esp,ebp

  0040104F: 5D                 pop         ebp

  00401050: C3                 ret

  00401051: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC     ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

?first@point@@QAEXXZ:

  00401060: 55                 push        ebp

  00401061: 8B EC              mov         ebp,esp

  00401063: 83 EC 44           sub         esp,44h

  00401066: 53                 push        ebx

  00401067: 56                 push        esi

  00401068: 57                 push        edi

  00401069: 51                 push        ecx

  0040106A: 8D 7D BC           lea         edi,[ebp-44h]

  0040106D: B9 11 00 00 00     mov         ecx,11h

  00401072: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

  00401077: F3 AB              rep stos    dword ptr [edi]

  00401079: 59                 pop         ecx

  0040107A: 89 4D FC           mov         dword ptr [ebp-4],ecx

  0040107D: 5F                 pop         edi

  0040107E: 5E                 pop         esi

  0040107F: 5B                 pop         ebx

  00401080: 8B E5              mov         esp,ebp

  00401082: 5D                 pop         ebp

  00401083: C3                 ret

  00401084: CC CC CC CC CC CC CC CC CC CC CC CC              ÌÌÌÌÌÌÌÌÌÌÌÌ

 

 

 

 可以看到在main函数中还是通过0040103B: E8 CA FF FF FF     call        @ILT+5(?first@point@@QAEXXZ)来调用对象中的函数的，而C中的_frist变成了first@point@@QAEXXZ是因为不同的类中可能有函数名相同的函数，这样为了区别这些函数，就需要为这些函数添加一些特别的信息，如类的名称等信息。（还有就是为了区别函数重载）

         这样其实就可以知道在C++的类中，非虚函数其实和C中的函数一样被组织在代码段中，只是命名的方式并不一样。

 

 

 

三，Class的布局

 

 

 

想要理解虚拟函数的内存布局，需要对class的结构入手，先从struct看起：

struct{

             int x,y;

}；

            如上的结构体在内存中如何存放呢？可以借用《inside the c++ program     model》的图形来看该内容：

     int  x;

 

 

 

     int y; 

 

 

 

                

从上图来看在内存中，x,y其实是被分配到一块连续的内存空间中，这块内 存空间的大小是x,y的大小之和（不同的变量类型的话，可能会产生内存对齐的问题，这里不考虑）。

 

 

 

当我们有如下一个class的话：

class point

{

private:

int x,y;

publice:

            void first(){};

}

如下声明： point pt;

那么pt 在内存中的存储方式如何呢？事实上它和struct的格式一样。并没有因为它是类而需要更多的信息（如函数名等信息）。而我刚开始的理解不是这样，因为当时没有考虑明白如下的方式中：

point pt;

pt.first();

 

 

 

是如何调用函数的。事实上和在C语言中调用函数没有太多区别。

 

 

 

四，关于虚函数

 

 

 

 先来看一段简单的程序：

class point

 

{

 

public:

 

      void virtual first();

 

};

 

 

 

 

void point::first()

 

{

 

      return;

 

}

 

 

 

 

 

 

 

 

 

 

void main()

 

{

 

      point pt;

 

      pt.first();

 

}

 

 

 

反汇编，摘出它的_main函数：

_main:

 

  00401060: 55                 push        ebp

 

  00401061: 8B EC              mov         ebp,esp

 

  00401063: 83 EC 44           sub         esp,44h

 

  00401066: 53                 push        ebx

 

  00401067: 56                 push        esi

 

  00401068: 57                 push        edi

 

  00401069: 8D 7D BC           lea         edi,[ebp-44h]

 

  0040106C: B9 11 00 00 00     mov         ecx,11h

 

  00401071: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

 

  00401076: F3 AB              rep stos    dword ptr [edi]

 

  00401078: 8D 4D FC           lea         ecx,[ebp-4]

 

  0040107B: E8 85 FF FF FF     call        @ILT+0(??0point@@QAE@XZ)

 

  00401080: 8D 4D FC           lea         ecx,[ebp-4]

 

  00401083: E8 87 FF FF FF     call        @ILT+10(?first@point@@UAEXXZ)

 

  00401088: 5F                 pop         edi

 

  00401089: 5E                 pop         esi

 

  0040108A: 5B                 pop         ebx

 

  0040108B: 83 C4 44           add         esp,44h

 

  0040108E: 3B EC              cmp         ebp,esp

 

  00401090: E8 5B 00 00 00     call        __chkesp

 

  00401095: 8B E5              mov         esp,ebp

 

  00401097: 5D                 pop         ebp

 

  00401098: C3                 ret

 

  00401099: CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC  ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ

 

  004010A9: CC CC CC CC CC CC CC    

 

 

 

我们可以看到对于first的调用，和调用普通成员函数并没有太多区别，也就是说虚拟函数也和普通函数一样的方式被组织在代码段中，通过函数名直接调用。

 

 

 

但我们知道，虚拟函数的最大特点，是通过父函数的指针可以调用子函数的方法来实现多态。是如何实现的呢？通过父指针要确定子类的的类型，由于可能有多个子类，而且是运行时刻识别，这样就需要子类的对象本身包含自身的信息。方法其实就在class对象的存储内容上。

再看一个类：

class  point

{

      Private:

                  Int x,y;

     Public:

        Virtual void first(){};

        Virtual void test(){};

}

当我们声明 point pt；的时候，内存中的存放形式如下：

 

 

 

     int  x;

 

 

     int y;

 

 

    vptr

 

 

 

 

 

 

 

 

void first();

 

 

 

void two();

 

 

 

type info

 

 

 

从图上可以看到，在pt的结构体内多了一个指针，该指针指向了该类所有的虚拟函数列表。该列表是各个虚拟函数所对应的函数地址。这样在动态调用的时候，就可以通过对象自身，而不是类来确定调用的函数。

       再看一个例子：

class point

 

{

 

public:

 

      void virtual first();

 

};

 

 

 

 

void point::first()

 

{

 

      return;

 

}

 

 

 

 

 

 

 

 

 

 

void main()

 

{

 

      point *pt = new point();

 

     

 

      pt->first();

 

}

 

 

 

现在改用指针来调用该方法，反汇编该代码，摘取_main函数如下：

 

 

 

_main:

 

  00401060: 55                 push        ebp

 

  00401061: 8B EC              mov         ebp,esp

 

  00401063: 6A FF              push        0FFh

 

  00401065: 68 5B 08 41 00     push        41085Bh

 

  0040106A: 64 A1 00 00 00 00  mov         eax,fs:[00000000]

 

  00401070: 50                 push        eax

 

  00401071: 64 89 25 00 00 00  mov         dword ptr fs:[0],esp

 

            00

 

  00401078: 83 EC 50           sub         esp,50h

 

  0040107B: 53                 push        ebx

 

  0040107C: 56                 push        esi

 

  0040107D: 57                 push        edi

 

  0040107E: 8D 7D A4           lea         edi,[ebp-5Ch]

 

  00401081: B9 14 00 00 00     mov         ecx,14h

 

  00401086: B8 CC CC CC CC     mov         eax,0CCCCCCCCh

 

  0040108B: F3 AB              rep stos    dword ptr [edi]

 

  0040108D: 6A 04              push        4

 

  0040108F: E8 6C 01 00 00     call        ??2@YAPAXI@Z

 

  00401094: 83 C4 04           add         esp,4

 

  00401097: 89 45 E8           mov         dword ptr [ebp-18h],eax

 

  0040109A: C7 45 FC 00 00 00  mov         dword ptr [ebp-4],0

 

            00

 

  004010A1: 83 7D E8 00        cmp         dword ptr [ebp-18h],0

 

  004010A5: 74 0D              je          004010B4

 

  004010A7: 8B 4D E8           mov         ecx,dword ptr [ebp-18h]

 

  004010AA: E8 56 FF FF FF     call        @ILT+0(??0point@@QAE@XZ)

 

  004010AF: 89 45 E4           mov         dword ptr [ebp-1Ch],eax

 

  004010B2: EB 07              jmp         004010BB

 

  004010B4: C7 45 E4 00 00 00  mov         dword ptr [ebp-1Ch],0

 

            00

 

  004010BB: 8B 45 E4           mov         eax,dword ptr [ebp-1Ch]

 

  004010BE: 89 45 EC           mov         dword ptr [ebp-14h],eax

 

  004010C1: C7 45 FC FF FF FF  mov         dword ptr [ebp-4],0FFFFFFFFh

 

            FF

 

  004010C8: 8B 4D EC           mov         ecx,dword ptr [ebp-14h]

 

  004010CB: 89 4D F0           mov         dword ptr [ebp-10h],ecx

 

  004010CE: 8B 55 F0           mov         edx,dword ptr [ebp-10h]

 

  004010D1: 8B 02              mov         eax,dword ptr [edx]

 

  004010D3: 8B F4              mov         esi,esp

 

  004010D5: 8B 4D F0           mov         ecx,dword ptr [ebp-10h]

 

  004010D8: FF 10              call        dword ptr [eax]

 

  004010DA: 3B F4              cmp         esi,esp

 

  004010DC: E8 0F 06 00 00     call        __chkesp

 

  004010E1: 8B 4D F4           mov         ecx,dword ptr [ebp-0Ch]

 

  004010E4: 64 89 0D 00 00 00  mov         dword ptr fs:[0],ecx

 

            00

 

  004010EB: 5F                 pop         edi

 

  004010EC: 5E                 pop         esi

 

  004010ED: 5B                 pop         ebx

 

  004010EE: 83 C4 5C           add         esp,5Ch

 

  004010F1: 3B EC              cmp         ebp,esp

 

  004010F3: E8 F8 05 00 00     call        __chkesp

 

  004010F8: 8B E5              mov         esp,ebp

 

  004010FA: 5D                 pop         ebp

 

  004010FB: C3                 ret

 

 

 

这段代码中已经找不到含有first形式的函数调用，新的调用方式是: 004010D8: FF 10              call        dword ptr [eax],通过ptr来调用函数。关于ptr的内容有些繁琐，一些细节我还是不太清楚。这边我所知道的就是通过它可以得到虚函数所存在的地址。

        这样当用父指针指向子类对象的时候，由于子类本身带有了虚函数的信息，通过父类就可以直接调用到子类的虚函数，而不是父类自己的虚函数。当不是虚函数的时候，父类是就只能调用自己的函数了。

 

 

 

        写到这儿，发现自己对很多概念还是不清晰，如this指针的用法，多重继承下的虚函数等。这篇文章写不清晰，同时发现自己的语文水平也有限！路漫漫其修远，不知道什么时候求索是个头啊！

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

接口与虚函数的数据结构知识
weixin_50746193的博客
05-03 843
接口与虚函数
C++多态性：虚函数的调用原理
08-19
vtable的结构简单来说，就是一个数组，数组的每个元素是一个函数指针，指向类中相应的虚函数。基类的vtable包含了所有基类的虚函数，而派生类的vtable除了包含基类的虚函数外，还可以添加新的虚函数或者覆盖...
虚函数的内存结构
那些年
12-25 1130
虚函数的内存结构 虚函数的内存结构 一、 基本概念     C++中的虚函数的作用主要是实现了多态的机制。     关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。     所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RT
含有虚函数类的对象在内存中的结构
KangRoger的专栏
07-31 2380
含有虚函数或基类含有虚函数的类,其对象在内存中的布局。
虚函数的内存结构，菱形继承的虚函数内存结构
weixin_41066529的博客
05-14 682
https://blog.youkuaiyun.com/u010235142/article/details/78307022
【VC++】虚函数 内存结构 - 第二篇（单继承，无虚函数覆盖）
maoyeahcom的博客
09-24 203
【VC++】虚函数 内存结构 - 第二篇（单继承，无虚函数覆盖） #include <IOSTREAM> using namespace std; class Base { public: int nBase1; int nBase2; Base(int n1,int n2):nBase1(n1),nBase2(n2) { cout<<"Base::Base("<<n1<<","<<n2<<")"<<end
C++ 类中有虚函数(虚函数表)时 内存分布详解
08-31
在C++中，虚函数（Virtual Function）是一个关键特性，用于支持动态多态性，使得在继承层次结构中可以通过基类指针调用派生类的重写成员函数。虚函数的实现依赖于虚函数表（Virtual Table，简称V-Table）。每个含有...
虚函数和虚继承及其在内存中布局
08-03
### 虚函数和虚继承及其在内存中布局 #### 一、虚函数的理解与内存布局 虚函数是C++中实现多态的一种机制。它允许派生类重定义基类中的虚函数，并且能够在运行时根据对象的实际类型来调用相应的函数版本。 **1.1 ...
虚函数内存模型
06-15
本文将深入探讨虚函数内存模型，解释当虚函数被引入到类中时，对象的内存布局会发生哪些变化。 #### 二、基本概念与背景 1. **虚函数表（vtable）**：每个包含虚函数的类都会有一个虚函数表，它是一张表格，其中...
C++ 虚函数内存结构详解
huangdenan的博客
05-27 236
参考 https://blog.twofei.com/496/
虚函数内存布局解析
ranxirui8580的博客
10-23 247
主要在于功能解耦合以及规范化的需要。我们很多时候需要做到：**一个模块对达成某个功能（机制）有一组可替换的实现（策略）。也就是说，需要策略和机制分离。那么我们的模块就应该只依赖这个机制的接口，而非这个机制的具体实现。，这是怎么实现的呢？中更加完善，它会告诉妳这是一个接口。，这里如果我们想在业务中使用。都生成了非虚的析构函数，直接。的功能，那么我们就必须把。可能导致释放不完全。
虚函数表结构
Nemo
07-15 5103
虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 我们可以通过下示的代码简单看下虚函数表结构： class Base{ public: virtual void A(){co...
C++ 虚函数表原理和类的内存分布
恋恋风辰的技术博客
08-02 1849
C++ 虚函数表原理和类的内存分布
虚函数对数据结构内存的影响
davidsu33的专栏
04-07 1266
写代码已经四、五年了，现在慢慢的开始非常注意代码的高质量和高效率了，其实有时候我们在写代码的时候很少考虑到虚函数对内存造成的影响，甚至有些非常简单的数据结构增加接口的时候也增加虚接口。一旦类之间的继承关系存在虚接口，那么就意味着多态的发生，也就意味着虚函数表的产生，虚函数表用来记录派生关系的子类应有的调用关系，以及说明其应该调用哪个函数。既然有了虚函数表就需要额外的内存开销了。那么我们看下如下的d
C++的虚函数和代码结构
枫叶人的博客
04-17 396
我曾听有人写了一句话，说明了虚函数的作用，是一个被子类初始化的父类指针想调用其子类实现的函数的一种实现方式，就是虚函数。意思就是Father* pFa = new Son(); pFa->Run()时，是儿子在跑，并不是父亲的跑。事实上，我们声明一个指针，如果用指针调用它自己拥有的函数，但有时候，我们并是这样，当此指针并不是自己所属的类去初始化时，而被子类的构造函数初始化时，就出现两种情况，如果函
c++ 虚函数内存布局示意图
chenwh_cn的博客
05-06 1327
文章目录一、virtual 虚函数工作原理二、虚函数内存布局1.基类和派生类同名函数，不能被继承2.单继承，无虚函数覆盖，无新增虚函数i.基类的内存布局：ii.派生类的内存布局：3.单继承，有虚函数覆盖，无新增虚函数4.单继承，有虚函数覆盖，有新增虚函数5.多继承，没有虚函数覆盖，没有新增虚函数6.多继承，有虚函数覆盖，没有新增虚函数7.多继承，有虚函数覆盖，有新增虚函数三、虚函数表指针访问1.代码示例2.安全性i. 通过基类指针访问派生类新增的虚函数ii. 访问 non-public 的虚函数 一、v
C++中的虚函数表结构框架
最新发布
qianniulaoren的博客
06-29 432
C++中的虚函数表结构框架介绍
虚函数，虚指针，虚表，虚析构函数和多态
weixin_40026739的博客
01-31 2204
而且，只要它是最后的构造函数调用，那么在这个对象的生命期内，VPTR将保持被初始化为指向这个VTABLE, 但如果接着还有一个更晚派生的构造函数被调用，这个构造函数又将设置VPTR指向它的 VTABLE，等.直到最后的构造函数结束。多态，就是存在虚函数的基类和存在一个或者多个基于该基类（并且实现了该基类的虚函数）的派生类，当一个基类指针指向不同的派生类时，通过基类指针调用虚函数，会有不同的实现，从而实现虚函数的多态性质。当使用基类指针或引用调用虚函数时，实际调用的是指向派生类的虚函数表的相应虚函数。
虚函数内存占用测试分析
在本例程中，通过对虚函数占用的内存进行测试，我们可以更好地理解虚函数在内存中的表现形式及其所占用的空间。根据描述，资源包中包含有两个C++源文件：“sizeof_virtual.cpp”和“string_size.cpp”。这两个文件...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值