从汇编的角度了解C++原理——虚函数

已于 2023-01-16 20:07:12 修改
阅读量902 收藏 7
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言 数据结构
于 2023-01-16 17:24:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45001971/article/details/128703713
版权

文章目录

本文用到的反汇编工具是objconv，使用方法可以看我另一篇文章https://blog.csdn.net/weixin_45001971/article/details/128660642。

其它文章：
从汇编的角度了解C++原理——类的储存结构和函数调用
从汇编的角度了解C++原理——new和malloc的区别
从汇编的角度了解C++原理——虚函数

1、虚函数

1.1、虚函数储存结构

在这里插入图片描述
反汇编。

main:
        sub     rsp, 56                             
        lea     rcx, [rsp+20H]                    
        call    ??0A@@QEAA@XZ      				//调用构造函数                  
        mov     eax, 4294967295                  
        add     rsp, 56                                
        ret                                             
        
??0A@@QEAA@XZ:									//调用A类的构造函数
        mov     qword [rsp+8H], rcx                  
        mov     rax, qword [rsp+8H]                    
        lea     rcx, [rel ??_7A@@6B@]           //获取虚表??_7A@@6B@的地址
        mov     qword [rax], rcx                //把虚表地址放在对象的头部      
        mov     rax, qword [rsp+8H]                    
        mov     dword [rax+8H], 10              //在对象首地址偏移8个字节的位置定义d1变量       
        mov     rax, qword [rsp+8H]                     
        ret                                                           

??_7A@@6B@:                     				//A类虚表                       
        dq ?func2@A@@UEAAXXZ                    //虚函数func2

以上例的汇编代码可以得出带虚函数的类的储存结构如下图所示。
在这里插入图片描述
带有虚函数的对象的头部会放置8个字节大小的虚表地址，有了虚表之后的对象会以8个字节为单位去对齐，如上例中的A类，如果没有虚函数，它的大小为4个字节，而加了虚函数之后，大小变为了16个字节。

1.2、子类重写虚函数

在代码中添加A的子类B，重写func2方法。
在这里插入图片描述

反汇编

main:
        sub     rsp, 56                             
        lea     rcx, [rsp+20H]                       
        call    ??0B@@QEAA@XZ          		//调用B类构造                
        mov     eax, 4294967295                        
        add     rsp, 56                                
        ret                                             
        
??0A@@QEAA@XZ:								//A类构造函数
        mov     qword [rsp+8H], rcx                  
        mov     rax, qword [rsp+8H]                     
        lea     rcx, [rel ??_7A@@6B@]     	//把A类虚表的地址放在头部              
        mov     qword [rax], rcx                      
        mov     rax, qword [rsp+8H]                   
        mov     dword [rax+8H], 10                  
        mov     rax, qword [rsp+8H]           
        ret                                             

??0B@@QEAA@XZ:								//B类构造函数
        mov     qword [rsp+8H], rcx                
        sub     rsp, 40                             
        mov     rcx, qword [rsp+30H]               
        call    ??0A@@QEAA@XZ    			//调用A类构造                   
        mov     rax, qword [rsp+30H]             
        lea     rcx, [rel ??_7B@@6B@]       //把B类虚表的地址放在头部           
        mov     qword [rax], rcx                    
        mov     rax, qword [rsp+30H]                   
        add     rsp, 40                                 
        ret                                           
       
??_7A@@6B@:                         		//A类虚表                        
        dq ?func2@A@@UEAAXXZ                //A::func2                             
        dq ?func3@A@@UEAAXXZ                //A::func3      
             
??_7B@@6B@:                                 //B类虚表                       
        dq ?func2@B@@UEAAXXZ                //B::func2，被替换为了B实现的func2          
        dq ?func3@A@@UEAAXXZ                //A::func3

从该例中我们可以看到，父类有虚函数时，不光它自己有一张虚表，它的子子孙孙都会各带有一个自己的虚表，子类重写虚函数时，会把子类实现的函数指针替换上虚表，把原先父类的函数指针覆盖掉。

1.3、在栈上调用虚函数

在main里添加方法的调用。
在这里插入图片描述
反汇编。

main:
        sub     rsp, 56                               
        lea     rcx, [rsp+20H]                         
        call    ??0B@@QEAA@XZ                        
        lea     rcx, [rsp+20H]                        
        call    ?func1@A@@QEAAXXZ   		//调用A::func1                 
        lea     rcx, [rsp+20H]                        
        call    ?func2@B@@UEAAXXZ   		//调用B::func2                       
        lea     rcx, [rsp+20H]                         
        call    ?func3@A@@UEAAXXZ   		//调用A::func3                         
        mov     eax, 4294967295                         
        add     rsp, 56                                
        ret

在栈上调用方法时，因为类型是确定的，所以编译器在编译阶段就会找到对应的函数去调用，调用过程与普通方法一样。

1.4、在堆上调用虚函数(通过指针调用，多态)

修改例程如下。
在这里插入图片描述
反汇编

main:
        sub     rsp, 72                                
        mov     ecx, 16                                
        call    ??2@YAPEAX_K@Z                         
        mov     qword [rsp+28H], rax                   
        cmp     qword [rsp+28H], 0                    
        jz      ?_001                                 
        mov     rcx, qword [rsp+28H]		//定义指针b                   
        call    ??0B@@QEAA@XZ                       
        mov     qword [rsp+30H], rax        //rsp+30H指向对象          
        jmp     ?_002                       //跳到?_002            

?_001:  mov     qword [rsp+30H], 0   
                  
?_002:  mov     rax, qword [rsp+30H]                   
        mov     qword [rsp+38H], rax        //rsp+38H指向对象         
        mov     rax, qword [rsp+38H]        //rax指向对象           
        mov     qword [rsp+20H], rax        //rsp+20H指向对象       
        mov     rcx, qword [rsp+20H]        //rcx指向对象          
        call    ?func1@A@@QEAAXXZ           //调用A::func1       
        mov     rax, qword [rsp+20H]                 
        mov     rax, qword [rax]            //取虚表        
        mov     rcx, qword [rsp+20H]                   
        call    near [rax]                  //执行虚表第一个函数，即B::func2           
        mov     rax, qword [rsp+20H]                   
        mov     rax, qword [rax]                       
        mov     rcx, qword [rsp+20H]                
        call    near [rax+8H]             	//执行虚表第二个函数，即A::func3             
        mov     eax, 4294967295                         
        add     rsp, 72                               
        ret                                          
        
??_7B@@6B@:                                           
        dq ?func2@B@@UEAAXXZ                        
        dq ?func3@A@@UEAAXXZ

从该例可以看到，通过指针来调用函数时。
如果是普通函数，编译器会直接根据指针类型，找到对应的的方法，而不是根据对象本身的类型，如本例中B类也实现了func1方法，但通过A类指针调用时，写到汇编里的时A::func1。
如果是虚函数，编译器不会根据名字来查找函数，而是让汇编代码通过虚表中的偏移量来调用，如本例中，b指针执行了func2和func3，这两个函数都没有被直接调用，而是以“call near [rax + 偏移量]”的形式调用了，这也是C++中父类指针指向子类对象的多态的实现原理。

weixin_45001971
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
汇编语言入门先导
m0_51067047的博客
06-27 214
1、语言 人和人沟通？通过语言来交流的！ 中国人 语言 外国人，学习外语！ 人 语言 计算机，学习计算机语言！ 什么是机器语言？ # 我们目前主流的电子计算机 # 状态0和1 # 最早的程序员：穿孔卡带！ 加 0100 0000 减 0100 1000 乘 0100 1000 0100 1000 除 0100 1000 1100 1000 这些复杂的机器语言，能简化吗？助记符！汇编语言！人能够理解的语言转换成为机器能够理解的语言！ 加 INC -编译器-> 0100 0000 减
汇编视角分析C++虚函数实现原理
GetnextWindow的专栏
08-07 634
虚函数是c++语言非常重要的机制，日常的c++编程工作中经常使用虚函数，通过汇编视角来探究虚函数的实现原理，有助于深刻理解虚函数的内部机制。c++语法规范并没有规定虚函数的具体实现方案，不同的编译器实现方式可以不同，本文基于arm32平台，g++编译器来分析虚函数表的实现机制，基本主流编译器的原理基本是相似的，所以理解g++实现方案再去分析其他编译器的实现也是类似的。......
关于gcc汇编过程的一些事（一）
SVRach的博客
04-25 1899
一、前言   众所周知，C语言中“编译”这个词其实已经被泛化了。很多时候，该词直接取代了整个从c文件到到可执行文件的流程，但为了笔者叙述方便，本人有必要在此先做一些说明。   C语言的整套流程，准确的说是预处理、编译、汇编以及链接四个过程。预处理完成头文件展开与宏替换，得到i文件；编译将i文件转换为汇编指令——s文件；汇编将s文件转换为o文件；链接将多个o文件联合得到最终的可执行文件。详细内容网上其余文章已有详细说明，此处不再赘述。   此外，由于处理器的发展，现在32、64位机C语言的int和long都是
右值引用调用-汇编码分析
春夜喜雨的专栏
05-21 425
右值引用是在C++11时引入的一个重要的功能，并在stl库中提供了右值引用的函数，便于做值的转移。下面通过汇编码分析，来进一步理解右值引用从汇编角度来看，它的特点是有什么。
二进制分析实战：x86汇编快速入门
人邮异步社区
12-10 3267
因为汇编语言是二进制文件中机器指令的标准表示形式，许多二进制分析都基于反汇编，所以读者必须熟悉x86汇编语言的基础知识，才能从本书中获得最大收获。本附录将为你介绍汇编语言的基础知识。 本附录的目的不是教你如何编写汇编程序（有专门介绍汇编程序的图书），而是向读者展示理解汇编程序所需的基础知识。通过本附录你将了解汇编程序和x86指令的结构以及它们运行时的行为，此外还将看到C/C++程序的通用代码在汇编层面是如何表示的。这里只介绍基本的64位用户模式的x86指令，不包括浮点指令集或者扩展指令集，如SSE或MMX
编译原理_课程设计.zip
07-06
在C++中，这通常涉及模板、虚函数、继承等面向对象特性。 5. **面向对象编程**：由于项目特别提到C++的面向对象特性，这意味着源代码可能包含类定义、对象实例化、继承、多态等概念。这些是C++作为强类型、面向对象...
牛客校招面试题（附答案与解析）c++
最新发布
07-31
面试时可能会要求设计简单的类和类层次结构，或者解释虚函数、纯虚函数和抽象类的作用。 5. **模板**：C++的模板允许创建泛型代码，可以用于编写通用的函数和类。模板的理解和使用是高级C++开发者必备的技能。 6. ...
C++面向对象程序设计第01章.ppt
02-12
C++的发展历程可以分为几个阶段：从早期的机器语言和汇编语言，到面向过程的编程语言如BASIC、Pascal和C，再到支持面向对象的C++和Java等。机器语言是由二进制指令组成的，直接对应于硬件的操作，而汇编语言则是为了...
C++编程惯用法——高级程序员常用方法和技巧
07-10
例如，虚函数（Virtual Functions）和纯虚函数（Pure Virtual Functions）是实现多态的基础，而智能指针（Smart Pointers）如shared_ptr、unique_ptr和weak_ptr则是管理对象生命周期的有效工具，可以避免内存泄漏和...
与谭浩强C++教材配套PPT课件
05-06
因此，C++不断进化，加入了运算符重载、引用、虚函数等特性，以提升其功能和适应性。如今，我们有多种C++编译器，如VC++、BC++和AT&T C++等。 C++的编译过程一般涉及源文件（*.cpp）、目标文件（*.obj）和可执行...
从汇编角度看虚函数和普通成员函数的调用过程
12-20
本篇文章直入正题。 我们的类成员函数分为inline、virtual、static、normal。 **normal成员函数：**其地址和一般函数的地址没有区别，就是函数代码在内存中的真实地址，但其调用要绑定到一个实实在在的对象上。取其地址需要使用“&”运算符。 **virtual成员函数：**其地址指的是其在vtable中的位置；取其地址需要使用“&”运算符。 inline成员函数：在运行时会展开，虽然语言允许取其地址，但是没有太大意义。 static成员函数：其地址和普通全局函数的地址没有任何区别；其不依赖与类的对象而存在，也不依赖与类的对象而调用，只是作用域变成了类作用域，可以像取全局函
汇编下的C++虚函数
zzzzzz
05-18 627
#include class B { private: int x; public: B(int i) :x(i) {} virtual void printinfo() const { printnum(); printf("Base\n"); } virtual void printnum() const
从汇编层面深度剖析C++虚函数
热门推荐
海枫的专栏
04-20 2万+
本文尝试从汇编的角度来分析g++编译器下C++虚函数的实现
从汇编代码分析c++虚函数表真正原理
u011569253的博客
07-07 1652
记得当年刚入行的时候经常看一些别人讲C++虚函数表，当时也不理解，别人怎么说就怎么信了。后来知道多了，发现以前的帖子很有问题，不知道你是否看过这样的图片。现在我用汇编分析真正虚函数是如何实现动态，如何生存虚函数表。如果你觉得有什么不对的地方欢迎交流。这个图片问题很大，我只是指出些这样帖子的人一些错误。下面来看我写的一对父子类class MyPreant { public: MyPreant();...
虚函数调用汇编
heartrude的专栏
03-20 895
tP->TV(); 00F2167A mov eax,dword ptr [tP] // 把对象指针放入eax 00F21680 mov edx,dword ptr [eax] // 对象指针地址的最前面放置着该对象的虚地址指针，取虚地址指针 00F21682 mov esi,esp 00F21684 mov
几秒读懂C++虚函数调用的汇编代码实现
dvlinker的技术专栏
10-30 6476
本文详细讲述C++虚函数调用的汇编代码实现。
从汇编的角度看C++里的引用和指针
爱就是是恒久忍耐的专栏
12-28 960
C++里有引用和指针，它们具有相似性，但也是不同的。本文主要从汇编的角度去理解这2者之间的异同点。 一 神器推荐 一般来说，查看C++程序的汇编指令，都是使用gcc去生成对应的汇编文件，这里推荐一个在线显示程序汇编的神器，Compiler Explorer，网址为https://godbolt.org/ 使用也非常简单，在左侧编写C++代码，在右侧就会直接显示对应的汇编语言，也可以根据需要的平...
汇编分析多态 虚函数表
woshinadie的博客
06-21 181
多态 默认情况下，父类指针指向子类对象，只能调用父类中的函数。  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++ 中，虚函数是通过虚函数表来实现的。每个对象都有一个指向虚函数表的指针，虚函数表是一个数组，存储了该对象的虚函数的地址。 当调用一个虚函数时，编译器会先查找该对象的虚函数表，然后根据虚函数的索引找到对应的函数地址，最终调用该函数。 以下是一个简单的示例，展示了虚函数的汇编代码实现： ```c++ class Base { public: virtual void foo() { printf("Base::foo()\n"); } }; class Derived : public Base { public: virtual void foo() { printf("Derived::foo()\n"); } }; int main() { Base* ptr = new Derived(); ptr->foo(); delete ptr; return 0; } ``` 对应的汇编代码如下（采用 AT&T 语法）： ```asm .file "main.cpp" .section .text .globl main .p2align 4,,15 .type main, @function main: .LFB0: .cfi_startproc subq $8, %rsp movl $8, %edi call operator new(unsigned long) movq %rax, %rdi leaq .LC0(%rip), %rsi movl $1, %edx movl $0, %eax call __printf_chk movq %rax, %rdi movq %rax, -8(%rbp) movq $vtable for Derived(%rip), %rax movq (%rax), %rax movq (%rax), %rax movq -8(%rbp), %rdx movq %rdx, %rsi movq %rax, (%rsp) call *%rax leaq -8(%rbp), %rax movq (%rax), %rax movq %rax, (%rsp) call operator delete(void*) xorl %eax, %eax addq $8, %rsp .cfi_endproc .LFE0: .size main, .-main .section .rodata .align 8 .LC0: .string "Base::foo()\n" .section .rodata.cst4 .align 4 vtable for Derived: .quad 0 .quad typeinfo for Derived .quad Derived::foo() .section .note.GNU-stack,"",@progbits ``` 可以看到，在调用虚函数时，程序首先通过虚函数表找到对应的函数地址，然后通过 `call` 指令调用该函数。虚函数表的地址是通过 `vtable for Derived(%rip)` 获取的。调用完毕后，还需要调用 `operator delete` 释放内存。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值