汇编下的C++虚函数

最新推荐文章于 2023-01-16 17:24:51 发布
最新推荐文章于 2023-01-16 17:24:51 发布
阅读量631 收藏
点赞数
分类专栏： C++ 文章标签： 虚函数原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nblsadnfh/article/details/51445116
版权 

#include <cstdio>

class B
{
private:
    int x;
public:
    B(int i) :x(i) {}
    virtual void printinfo() const
    {
        printnum();
        printf("Base\n");
    }
    virtual void printnum() const
    {
        printf("%d\n", x);
    }
};

class D : public B
{
private:
    int y;
public:
    D(int i, int j) :B(i), y(j){}
    virtual void printinfo() const
    {
        printnum();
        printf("Derived\n");
    }
};

void PutInfo(const B &b)
{
    b.printinfo();
}

int main()
{
    B b(1);
    D d(2, 3);
    printf("\tB\tD\nsize:\t%d\t%d\n", sizeof b, sizeof d);
    printf("addr:\t%x\t%x\n", &b, &d);
    putchar('\n');
    PutInfo(b);
    PutInfo(d);

    return 0;
}

使用VS2013生成，Release模式，无优化，运行结果如下：


18f918和18f90c这两个是变量b，d的地址，每次运行都可能不同。

由于B类有虚函数，因为会有一个虚表指针（4字节），加上一个int成员变量x（4字节），因此大小为8字节。

D类是B类派生类，在B类基础上，增加了一个int成员变量y，所以大小为12字节。

 

一些基本的约定：

Windows栈从高地址向低地址增长，栈底地址高于栈顶地址，局部变量按声明顺序从高地址向低地址存放。

__cdecl函数调用方式：一般来说，函数参数从右向左依次入栈，然后是返回地址入栈，然后是ebp入栈，再将ebp设为栈顶指针esp，用于访问数据，esp减小，开辟栈空间以保存局部变量。

具体汇编代码如下：

; int __cdecl main(int argc, const char **argv, const char **envp)
_main proc near

d= D ptr -14h
b= B ptr -8
argc= dword ptr  8
argv= dword ptr  0Ch
envp= dword ptr  10h

push    ebp
mov     ebp, esp
sub     esp, 14h
push    1               ; i
lea     ecx, [ebp+b]    ; this
call    ??0B@@QAE@H@Z   ; B::B(int)
push    3               ; j
push    2               ; i
lea     ecx, [ebp+d]    ; this
call    ??0D@@QAE@HH@Z  ; D::D(int,int)
push    0Ch
push    8
push    offset aBDSizeDD ; "\tB\tD\nsize:\t%d\t%d\n"
call    ds:__imp__printf
add     esp, 0Ch
lea     eax, [ebp+d]
push    eax
lea     ecx, [ebp+b]
push    ecx
push    offset aAddrXX  ; "addr:\t%x\t%x\n"
call    ds:__imp__printf
add     esp, 0Ch
push    0Ah             ; Ch
call    ds:__imp__putchar
add     esp, 4
lea     edx, [ebp+b]
push    edx             ; b
call    ?PutInfo@@YAXABVB@@@Z ; PutInfo(B const &)
add     esp, 4
lea     eax, [ebp+d]
push    eax             ; b
call    ?PutInfo@@YAXABVB@@@Z ; PutInfo(B const &)
add     esp, 4
xor     eax, eax
mov     esp, ebp
pop     ebp
retn
_main endp

sub    esp, 14h

为局部变量分配空间，b和d一共20字节，因此esp减去14h。

 

push   1               ; i

lea    ecx, [ebp+b]    ; this

call   ??0B@@QAE@H@Z   ; B::B(int)

1入栈，同时ecx = &b。

lea reg, mem的作用是将mem的地址传递给reg寄存器，类似于reg = &mem，[reg]是取地址为reg的数据，类似于*reg，所以

lea ecx, [ebp+b]

将ebp-8赋给ecx，ebp-8就是b的地址，接下来调用B的构造函数B::B(int)。

; void __thiscall B::B(B *this, int i)
??0B@@QAE@H@Z proc near

this= dword ptr -4
i= dword ptr  8

push    ebp
mov     ebp, esp
push    ecx
mov     [ebp+this], ecx
mov     eax, [ebp+this]
mov     dword ptr [eax], offset ??_7B@@6B@ ; const B::`vftable'
mov     ecx, [ebp+this]
mov     edx, [ebp+i]
mov     [ecx+4], edx
mov     eax, [ebp+this]
mov     esp, ebp
pop     ebp
retn    4
??0B@@QAE@H@Z endp

从代码可以看到，成员函数中其实是有一个隐藏的参数this，用于保存对象地址。

mov [ebp+this], ecx

表明this指针通过ecx寄存器传递，在B：：B(int)函数中，形成的stack是这样的：


mov    eax, [ebp+this]

mov    dword ptr [eax], offset ??_7B@@6B@ ; const B::`vftable'

这两句将b的地址&b复制到eax，并将B类的虚表地址复制到&b处。

mov    ecx, [ebp+this]

mov    edx, [ebp+i]

mov    [ecx+4], edx

这里再将ecx设为&b，edx设为ebp+8中的数据，即参数i的值1，再将edx复制到&b+4处，即成员变量b.x被初始化为1。

 

push   3               ; j

push   2               ; i

lea    ecx, [ebp+d]    ; this

call   ??0D@@QAE@HH@Z  ; D::D(int,int)

将D类构造函数的参数压入栈中，ecx = &d，调用D::D(int, int)。

; void __thiscall D::D(D *this, int i, int j)
??0D@@QAE@HH@Z proc near

this= dword ptr -4
i= dword ptr  8
j= dword ptr  0Ch

push    ebp
mov     ebp, esp
push    ecx
mov     [ebp+this], ecx
mov     eax, [ebp+i]
push    eax             ; i
mov     ecx, [ebp+this] ; this
call    ??0B@@QAE@H@Z   ; B::B(int)
mov     ecx, [ebp+this]
mov     dword ptr [ecx], offset ??_7D@@6B@ ; const D::`vftable'
mov     edx, [ebp+this]
mov     eax, [ebp+j]
mov     [edx+8], eax
mov     eax, [ebp+this]
mov     esp, ebp
pop     ebp
retn    8
??0D@@QAE@HH@Z endp

this = &d，调用基类构造函数B::B(int)，初始化d.x，然后D类虚表地址复制到&d，再初始化d.y。

 

看一下虚表中的数据：

.rdata:00402164                   ; const B::`vftable'
.rdata:00402164 30 10 40 00       ??_7B@@6B@ dd offset ?printinfo@B@@UBEXXZ
.rdata:00402164                                                 ; DATA XREF: B::B(int)+Ao
.rdata:00402164                                                 ; B::printinfo(void)
.rdata:00402168 60 10 40 00       dd offset ?printnum@B@@UBEXXZ ; B::printnum(void)

按照成员函数声明的顺序，B类虚表的第一项是B::printinfo(void)地址，第二项是B::printnum(void)地址。

D类虚表类似：

.rdata:00402158                   ; const D::`vftable'
.rdata:00402158 B0 10 40 00       ??_7D@@6B@ dd offset ?printinfo@D@@UBEXXZ
.rdata:00402158                                                 ; DATA XREF: D::D(int,int)+16o
.rdata:00402158                                                 ; D::printinfo(void)
.rdata:0040215C 60 10 40 00       dd offset ?printnum@B@@UBEXXZ ; B::printnum(void)

注意到由于派生类D的printinfo覆盖了基类的printinfo，但并未对B::printnum(void)进行覆盖，所以虚表第一项是D::printinfo(void)地址，第二项仍然是B::printnum(void)的地址。

 

再看

PutInfo(b);

PutInfo(d);

对应的汇编：

lea     edx, [ebp+b]
push    edx             ; b
call    ?PutInfo@@YAXABVB@@@Z ; PutInfo(B const &)
add     esp, 4
lea     eax, [ebp+d]
push    eax             ; b
call    ?PutInfo@@YAXABVB@@@Z ; PutInfo(B const &)
add     esp, 4

lea     edx, [ebp+b]
push    edx             ; b
edx = &b，然后edx入栈，调用PutInfo(B const &)。

PutInfo(const B &)代码：
; void __cdecl PutInfo(B *b)
?PutInfo@@YAXABVB@@@Z proc near

b= dword ptr  8

push    ebp
mov     ebp, esp
mov     eax, [ebp+b]
mov     edx, [eax]
mov     ecx, [ebp+b]
mov     eax, [edx]
call    eax
pop     ebp
retn
?PutInfo@@YAXABVB@@@Z endp


左图为main形成的stack，右图为PutInfo(b)形成的stack，

在PutInfo(b)中，

eax = &b

edx = offset B::vftable

ecx = &b

eax = B::vftable = offset B::printinfo(void)。

然后call eax调用B::printinfo(void)。

类似地，在PutInfo(d)中，由于虚表第一项是offset D::printinfo(void)，因此call eax会调用D::printinfo(void)。

于是，对象在运行时根据虚表中保存的函数地址，自动调用所属类的虚函数。


如果仅仅将参数传递方式改为pass by value，即

void PutInfo(const B b)

结果如下：



; int __cdecl main(int argc, const char **argv, const char **envp)
_main proc near

d= D ptr -14h
b= B ptr -8
argc= dword ptr  8
argv= dword ptr  0Ch
envp= dword ptr  10h

push    ebp
mov     ebp, esp
sub     esp, 14h
push    1               ; i
lea     ecx, [ebp+b]    ; this
call    ??0B@@QAE@H@Z   ; B::B(int)
push    3               ; j
push    2               ; i
lea     ecx, [ebp+d]    ; this
call    ??0D@@QAE@HH@Z  ; D::D(int,int)
push    0Ch
push    8
push    offset aBDSizeDD ; "\tB\tD\nsize:\t%d\t%d\n"
call    ds:__imp__printf
add     esp, 0Ch
lea     eax, [ebp+d]
push    eax
lea     ecx, [ebp+b]
push    ecx             ; b
push    offset aAddrXX  ; "addr:\t%x\t%x\n"
call    ds:__imp__printf
add     esp, 0Ch
push    0Ah             ; Ch
call    ds:__imp__putchar
add     esp, 4
sub     esp, 8
mov     ecx, esp        ; this
lea     edx, [ebp+b]
push    edx             ; __that
call    ??0B@@QAE@ABV0@@Z ; B::B(B const &)
call    ?PutInfo@@YAXVB@@@Z ; PutInfo(B)
add     esp, 8
sub     esp, 8
mov     ecx, esp        ; this
lea     eax, [ebp+d]
push    eax             ; __that
call    ??0B@@QAE@ABV0@@Z ; B::B(B const &)
call    ?PutInfo@@YAXVB@@@Z ; PutInfo(B)
add     esp, 8
xor     eax, eax
mov     esp, ebp
pop     ebp
retn
_main endp

sub     esp, 8

mov    ecx, esp        ; this

lea    edx, [ebp+b]

push   edx             ; __that

call   ??0B@@QAE@ABV0@@Z ; B::B(B const &)

call   ?PutInfo@@YAXVB@@@Z ; PutInfo(B)

add    esp, 8

可以看到，程序又开辟了8字节的空间，这用于PutInfo函数中的临时变量（形参b）的存放，之后又回收了这8字节的空间。

源代码并没有声明copy构造函数，但是在PutInfo中，参数传递必须利用实参构造形参，因此编译器自动生成了一个copy构造函数B::B(const &)。

考察B::B(const &)，__that是已经构造的对象，this是将要构造的对象，在调用copy函数之前，ecx = esp这是栈顶，也是形参b的地址，或者说this指针，edx是实参b的地址。

; void __thiscall B::B(B *this, B *__that)
??0B@@QAE@ABV0@@Z proc near

this= dword ptr -4
__that= dword ptr  8

push    ebp
mov     ebp, esp
push    ecx
mov     [ebp+this], ecx
mov     eax, [ebp+this]
mov     dword ptr [eax], offset ??_7B@@6B@ ; const B::`vftable'
mov     ecx, [ebp+this]
mov     edx, [ebp+__that]
mov     eax, [edx+4]
mov     [ecx+4], eax
mov     eax, [ebp+this]
mov     esp, ebp
pop     ebp
retn    4
??0B@@QAE@ABV0@@Z endp

构造函数中，初始化B类虚表地址。

mov    edx, [ebp+__that]

mov    eax, [edx+4]

mov    [ecx+4], eax

然后复制that->x到this->x，完成对象的copy。

 

pass by value版本的PutInfo：

; void __cdecl PutInfo(B b)
?PutInfo@@YAXVB@@@Z proc near

b= B ptr  8

push    ebp
mov     ebp, esp
lea     ecx, [ebp+b]    ; this
call    ?printinfo@B@@UBEXXZ ; B::printinfo(void)
pop     ebp
retn
?PutInfo@@YAXVB@@@Z endp

直接调用了B::printinfo(void)，与实参的实际类型无关。




f011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用汇编解释虚函数调用
pennyliang的专栏
06-09 9025
做程序设计助教，刚刚有个同学来实验室找我。问了个问题，“为什么指向基类指针能指向派生类，而且能调用派生类的函数”。        我按我的理解，简单解释下         指向基类的指针，“能看见”的部分是这个基类定义的，包括函数和变量。         如果该指针指向了它的派生类，它依然“能看见”的部分还是基类定义的，包括函数和变量。 但是如果函数是虚函数，那么C++编译器会把这个调用，借
通过汇编角度理解虚函数!
likexin的专栏
07-10 3555
今天通过汇编角度在次理解一下虚函数.工作环境VC6方法DEBUG 跟踪MEMORY测试程序代码 虽然是测试程序但希望大家还是养成良好习惯 不要污染命名空间测试代码:#include "iostream"using std::cout;using std::endl;class a{  int m_a;public:  a(int x):m_a(x) {}  virtua
用汇编的眼光看C++（之虚函数）
javasee
09-15 101
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 虚函数是面向对象设计中的一个重要内容。它的出现使得我们只需要相同的接口函数，并可以得到不同的生成结果。但是有些朋友却知其然，不知其所以然，为什么会出现这样的结果，我们可以用一段代码说明问题。首先，我们先定义两个基本类型，一个是employee，一个是manager，看过前面一片博客的朋...
C++虚函数调用的反汇编解析
热门推荐
阮建辉的专栏
08-23 1万+
C++虚函数调用的反汇编解析     作者：阮建辉 虚函数的调用如何能实现其“虚”？作为C++多态的表现手段，估计很多人对其实现机制感兴趣。大约一般的教科书就说到这个C++强大机制的时候，就是教大家怎么用，何时用，而不会去探究一下这个虚函数的真正实现细节。（当然，因为不同的编译器厂家，可能对虚函数有自己的实现，呵呵，这就算是虚函数对于编译器的“多态”了：）。 作为编译型语言，C
汇编视角分析C++虚函数实现原理
GetnextWindow的专栏
08-07 643
虚函数是c++语言非常重要的机制，日常的c++编程工作中经常使用虚函数，通过汇编视角来探究虚函数的实现原理，有助于深刻理解虚函数的内部机制。c++语法规范并没有规定虚函数的具体实现方案，不同的编译器实现方式可以不同，本文基于arm32平台，g++编译器来分析虚函数表的实现机制，基本主流编译器的原理基本是相似的，所以理解g++实现方案再去分析其他编译器的实现也是类似的。......
从汇编层面深度剖析C++虚函数
12-22
虚函数是C++语言实现运行时多态的手段，因此掌握C++虚函数也成为C++程序员是否合格的试金石。csdn网友所发的一篇博文《VC虚函数布局引发的问题》 从汇编角度分析了对象虚函数表的构，以及C++指针或者引用是如何利用...
浅谈C++ 虚函数分析
08-25
在本篇文章中，我们将深入探讨C++虚函数的工作原理、使用方式以及其实现机制。 首先，虚函数的声明是在函数前加上`virtual`关键字。例如，`virtual int fuck(int a)`声明了一个虚函数，它接收一个整型参数并返回...
如何获取C++类成员虚函数地址的示例代码
08-29
总结，获取C++虚函数地址的方法包括直接通过成员函数指针、使用内联汇编以及访问虚函数表。理解这些机制对于深入理解C++的虚函数机制和运行时类型信息的使用非常重要。不过，需要注意的是，这些操作通常属于底层编程...
从汇编看c++中默认构造函数的使用分析
09-05
在没有虚函数的情况下，虽然没有显式的构造函数调用，但编译器仍然会在内存分配时完成必要的步骤，尽管这些步骤并不包括显式的初始化。这是因为默认构造函数在C++中并不保证执行任何初始化，除非类中包含静态或非...
从汇编的角度理解C++虚函数（一）
qq_41071646的博客
07-01 522
写在前面这篇文章适合和我一样的汇编小白还有c++小白 大牛可绕过（打扰了）如果哪里有错误 还请指出  不胜感激 orz希望大家一起探讨 共同进步 我写这个博客主要是因为我们的C++考试 有一道关于虚析构函数的一道题 我当时没有做出来。我当时自认为我理解了多态 加上当时要复习高数 物理等一些科目 还有一些比赛 所以我就没有把精力放在c++上 结果很打脸的是 我当时 没有做出来那个我认为我理解的一道题...
深入C++虚表(虚函数 虚表 反汇编)
05-28
多态是C++语言中最重要的特性之一，而虚表以及虚函数是实现多态的重要手段。许多C++语言的教材对于虚函数的使用以及调用机制有着详细的阐述，但是对于虚表的一些细节内容阐述却并不是很深，对于虚表我们可能会有很多疑问。本文就试图通过使用汇编语言对于虚表实现的细节进行分析，从而加深对多态机制的理解。
从汇编的角度了解C++原理——虚函数
weixin_45001971的博客
01-16 915
从汇编的角度了解C++原理——虚函数
C++虚函数调用的汇编过程
kenby的专栏
02-19 1156
下面的程序改编自《Thinking in C++》的Instrument4.cpp#include using namespace std;enum note { middleC, Csharp, Cflat }; // Etc.class Instrument { public: virtual void play(note)
c++ 从汇编代码看虚函数实现
letterwhite的专栏
01-20 575
网上已经有很多关于c++虚函数多态的文章,今天我们从汇编的角度来看下这种实现. 废话不说,直接上代码: class BaseObject { public: void virtual print(int i,int j) {m_x = i;m_y = j;}; void virtual print2() { printf("base\n");}; private: int m_x;...
虚函数调用汇编
heartrude的专栏
03-20 897
tP->TV(); 00F2167A mov eax,dword ptr [tP] // 把对象指针放入eax 00F21680 mov edx,dword ptr [eax] // 对象指针地址的最前面放置着该对象的虚地址指针，取虚地址指针 00F21682 mov esi,esp 00F21684 mov
从汇编的角度理解c++虚函数（二）
qq_41071646的博客
07-02 254
上一个博客写的是析构函数 从析构函数我们就可以知道了我们写c++程序的时候析构函数最好是写成虚函数，因为这样的话，释放空间的时候，会把父类 以及子类的空间都是释放了 ，然后今天我们 看的是析构函数，假如是普通的成员函数 会是怎么样 我们先来看看我们写的c++代码#include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;algor...
虚函数调用 汇编代码
farmwang的专栏
08-02 522
汇编分析多态 虚函数表
woshinadie的博客
06-21 182
多态 默认情况下，父类指针指向子类对象，只能调用父类中的函数。  Animal *p = new Dog指针p只能调用Animal类中的函数 #include <iostream> using namespace std; class Animal { public: void speak() { cout << "animal speak()" << endl; } void run() { cout << "animal ru
C++虚函数调用的汇编代码实现
最新发布
04-05
在 C++ 中，虚函数是通过虚函数表来实现的。每个对象都有一个指向虚函数表的指针，虚函数表是一个数组，存储了该对象的虚函数的地址。 当调用一个虚函数时，编译器会先查找该对象的虚函数表，然后根据虚函数的索引...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值