从逆向分析角度看C++的析构函数

最新推荐文章于 2023-04-17 22:23:29 发布
最新推荐文章于 2023-04-17 22:23:29 发布
阅读量3.9k 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： [编程语言]C++逆向分析 C++逆向分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yeweiouyang/article/details/8651443
本文通过一个C++代码示例，详细解析了在VC 6.0环境下，调用函数时对象拷贝构造及析构的过程。在调用fun函数时，会创建一个临时对象，利用拷贝构造，然后将对象地址传入函数。当函数执行完毕，析构函数销毁临时对象，释放栈空间。

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

有这么一段C++代码：

#include <cstdio>

class CExample {
  int x, y;
  
public:
  CExample(int va, int vb) {
    x = va;
	y = vb;
  }
  CExample(const CExample& C) {
    x = C.x;
	y = C.y;
  }
  ~CExample() {
	printf("~CExample()\n");
  }
  
  void Show () {
    printf("%d, %d\n", x, y);
	return ;
  }
};

void fun(CExample E) {
  printf("In F(CExample)\n");
  return ;
}

int main() {
  CExample A(100, 200);
  CExample B = A;
  B.Show();
  fun(A);
  return 0;
}


运行结果：


编译调试的环境是 VC 6.0，注释如下：

main 函数：

30:   int main() {
00401130   push        ebp
00401131   mov         ebp,esp
00401133   push        0FFh
00401135   push        offset __ehhandler$_main (00413422)
0040113A   mov         eax,fs:[00000000]
00401140   push        eax
00401141   mov         dword ptr fs:[0],esp
00401148   sub         esp,5Ch
0040114B   push        ebx
0040114C   push        esi
0040114D   push        edi
0040114E   lea         edi,[ebp-68h]
00401151   mov         ecx,17h
00401156   mov         eax,0CCCCCCCCh
0040115B   rep stos    dword ptr [edi]				; 以上代码为建立堆栈，EBP = 1245000
31:     CExample A(100, 200);
0040115D   push        0C8h					; 将 200 压入堆栈中
00401162   push        64h					; 将 100 压入堆栈中
00401164   lea         ecx,[ebp-14h]				; EBP-14h 是 A 的内存地址，占 8 个字节，将该地址保存到 ECX 寄存器中
00401167   call        @ILT+0(CExample::CExample) (00401005)	; 调用构造函数 CExample(int, int)
0040116C   mov         dword ptr [ebp-4],0
32:     CExample B = A;
00401173   lea         eax,[ebp-14h]				; 将 A 的内存地址保存到 EAX 寄存器中
00401176   push        eax					; 将 EAX 压入堆栈中
00401177   lea         ecx,[ebp-1Ch]				; EBP-1Ch 是 B 的内存地址，占 8 个字节，将该地址保存到 ECX 寄存器中
0040117A   call        @ILT+20(CExample::CExample) (00401019)	; 调用拷贝构造函数，将A中的值复制到 B 的内存空间中，			

								; 细心观察一下栈地址就能明白
0040117F   mov         byte ptr [ebp-4],1
33:     B.Show();
00401183   lea         ecx,[ebp-1Ch]
00401186   call        @ILT+25(CExample::Show) (0040101e)
34:     fun(A);
0040118B   sub         esp,8					; ESP = 1244884, ESP - 8 = 1244876；ESP-8 是开辟的一块内存，
								; 在调用fun之前，先调用拷贝构造函数对 A 进行拷贝，拷贝的内容就
								; 存放在这块内存空间中（一个CExample对象，记为Temp）
0040118E   mov         ecx,esp					; ECX 寄存器保存 Temp 对象的内存地址
00401190   mov         dword ptr [ebp-20h],esp			; EBP-20h 这块空间保存 Temp 对象的内存地址
00401193   lea         edx,[ebp-14h]				; EDX 寄存器保存 A 对象的内存地址
00401196   push        edx					; ESP = 1244872，将 A 的内存地址压入栈
00401197   call        @ILT+20(CExample::CExample) (00401019)	; ESP = 1244868，函数返回地址压入栈，调用拷贝构造函数
0040119C   mov         dword ptr [ebp-28h],eax			; ESP = 1244876, EBP - 28h = 1244876，保存 Temp 的内存地址
0040119F   call        @ILT+15(fun) (00401014)			; ESP = 1244872，函数返回地址压入栈，调用fun函数
004011A4   add         esp,8					; __cdecl 规则，恢复堆栈段，EBP = 1245000
35:     return 0;
004011A7   mov         dword ptr [ebp-24h],0
004011AE   mov         byte ptr [ebp-4],0
004011B2   lea         ecx,[ebp-1Ch]				; EBP - 1Ch 是 B 的内存地址，保存到 ECX 中
004011B5   call        @ILT+5(CExample::~CExample) (0040100a)	; 调用析构函数，销毁对象 B
004011BA   mov         dword ptr [ebp-4],0FFFFFFFFh
004011C1   lea         ecx,[ebp-14h]				; EBP - 14h 是 A 的内存地址，保存到 ECX 中
004011C4   call        @ILT+5(CExample::~CExample) (0040100a)	; 调用析构函数，销毁对象 A
004011C9   mov         eax,dword ptr [ebp-24h]
36:   }


拷贝构造函数 CExample(const CExample& C)：

11:     CExample(const CExample& C) {
00401270   push        ebp
00401271   mov         ebp,esp
00401273   sub         esp,44h
00401276   push        ebx
00401277   push        esi
00401278   push        edi
00401279   push        ecx
0040127A   lea         edi,[ebp-44h]
0040127D   mov         ecx,11h
00401282   mov         eax,0CCCCCCCCh
00401287   rep stos    dword ptr [edi]			; 以上为建立堆栈代码，EBP = 1244864
00401289   pop         ecx				; 恢复 ECX 寄存器的内容，即为 Temp 的内存地址
0040128A   mov         dword ptr [ebp-4],ecx		; EBP - 4 = 1244860，这块栈内存保存 Temp 的内存地址
12:       x = C.x;
0040128D   mov         eax,dword ptr [ebp-4]		; EBP - 4 = 1244860，EAX 获得 Temp 的内存地址（EAX 指向 Temp）
00401290   mov         ecx,dword ptr [ebp+8]		; EBP + 8 = 1244872，ECX 获得 A 的内存地址（ECX 指向 A）
00401293   mov         edx,dword ptr [ecx]		; EDX = 100（A 的首地址是 100，100 后于 200 进栈）
00401295   mov         dword ptr [eax],edx		; Temp.x = 100
13:       y = C.y;
00401297   mov         eax,dword ptr [ebp-4]
0040129A   mov         ecx,dword ptr [ebp+8]
0040129D   mov         edx,dword ptr [ecx+4]		; EDX = 200
004012A0   mov         dword ptr [eax+4],edx		; 同理，Temp.y = 200
14:     }
004012A3   mov         eax,dword ptr [ebp-4]		; EAX 寄存器保存 Temp 的内存空间
004012A6   pop         edi
004012A7   pop         esi
004012A8   pop         ebx
004012A9   mov         esp,ebp
004012AB   pop         ebp				; 恢复EBP，EBP = 1245000
004012AC   ret         4				; 恢复这一函数的堆栈段

fun 函数：

25:   void fun(CExample E) {
00401050   push        ebp
00401051   mov         ebp,esp							
00401053   push        0FFh
00401055   push        offset __ehhandler$?fun@@YAXVCExample@@@Z (004133f9)
0040105A   mov         eax,fs:[00000000]
00401060   push        eax
00401061   mov         dword ptr fs:[0],esp
00401068   sub         esp,40h
0040106B   push        ebx
0040106C   push        esi
0040106D   push        edi
0040106E   lea         edi,[ebp-4Ch]
00401071   mov         ecx,10h
00401076   mov         eax,0CCCCCCCCh
0040107B   rep stos    dword ptr [edi]
0040107D   mov         dword ptr [ebp-4],0				; EBP = 1244868，以上为建立堆栈代码
26:     printf("In F(CExample)\n");
00401084   push        offset string "In F(CExample)\n" (0042501c)
00401089   call        printf (00401320)
0040108E   add         esp,4
27:     return ;
00401091   mov         dword ptr [ebp-4],0FFFFFFFFh
00401098   lea         ecx,[ebp+8]					; EBP+8 = 1244876，是 Temp 的内存地址
									; ECX 寄存器保存
0040109B   call        @ILT+5(CExample::~CExample) (0040100a)		; 调用析构函数，销毁 Temp 对象（生命期结束）
28:   }
004010A0   mov         ecx,dword ptr [ebp-0Ch]
004010A3   mov         dword ptr fs:[0],ecx
004010AA   pop         edi
004010AB   pop         esi
004010AC   pop         ebx
004010AD   add         esp,4Ch
004010B0   cmp         ebp,esp
004010B2   call        __chkesp (00401780)
004010B7   mov         esp,ebp
004010B9   pop         ebp						; 恢复EBP，EBP = 1245000
004010BA   ret


下面重点分析一下调用 fun 函数时程序的工作机制：



执行“fun(A);”时，首先先调用拷贝构造函数，创建一个实体对象Temp，占8个字节长度的栈空间，内容是拷贝 A 的内容；然后再把对象 Temp 的内存地址压入 fun 函数的堆栈中，调用 fun 函数，当 fun 函数结束时，调用析构函数销毁 Temp 对象，从此 Temp 对象所占的栈空间被回收


打印异常详细信息_C++幕后故事（十三） 异常实现原理
weixin_39746552的博客
11-25 625
这个章节我们主要学习一下几个知识点：1.异常是如何实现的？2.异常是如何销毁局部变量的？它怎么知道哪些临时变量需要销毁？3.异常效率真的很低？1.前言 责任链设计模式如果你能够理解设计模式中的责任链模式，那么你对异常原理模型也就吃透一大半了。什么，有这么神奇？或许你会问，这是个啥套路咋没有见过。那我形象、具体、简单的给你举个例子。在高中的化学课程中，你是不是经常做到这样的题目从一种液体中...
Android SO逆向-对象的构造函数与析构函数
jltxgcy的专栏
04-19 4225
0x00    这一节我们主要讨论对象的构造函数和析构函数的汇编实现。    0x01    我们先直接看C++代码：#include "com_example_ndkreverse4_Lesson4.h" #include "Test.h" #include #define LOG_TAG "lesson4" #define ALOGD(...) ((void)__android_log_pr
C++ 类与对象中的构造函数与析构函数认识（一）
NavyGH的博客
04-17 296
构造与析构函数
【翻译】异常和异常处理（windows平台）
weixin_30569153的博客
12-27 417
翻译的不好，莫怪。 原文地址：http://crashrpt.sourceforge.net/docs/html/exception_handling.html#getting_exception_context About Exceptions and Exception Handling About Exception 当程序遇到一个异常或一个严重的错误时，通常意味着它不能继...
C++异常处理源码与安全性分析
ashimida
12-10 5589
C++异常处理需要DWARF的支持,其业界实际标准是 IA-64 C++ABI[1],本文主要描述整个异常处理的流程以及在libgcc中的实现.关于基于DWARF的栈回溯可参考 [2], 关于C++异常处理其他分析可参考[3-8]。 一、异常处理代码举例 先以一个简单的C++程序为例: 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 class x { 5 public: 6 x(voi...
异常处理
Mr.Out的专栏
10-02 2786
<br />C++标准中只规定了异常处理的语法，各编译器厂商也都予以实现。但由于C++标准中并没有规定异常处理的实现过程，造成了不同厂商的编译器，编译后产生的异常处理代码也不相同。本教程中一直使用微软C++编译器系列中的Microsoft Visual C++ 6.0，因此本章也不例外，依然使用VC6.0用于调试讲解。<br />       C++中异常处理机制由try、throw、catch语句组成。<br />q        try语句块中负责监视异常。<br />q        throw用于异
全面解析C++中的析构函数
09-02
析构函数调用的顺序是逆向的，首先调用析构函数自身，然后按照类声明中非静态成员对象的顺序逆序调用它们的析构函数。对于基类，非虚拟基类的析构函数按声明的逆序调用，而虚拟基类的析构函数也按声明的逆序调用。 ...
逆向工程C++：IDA分析构造与析构函数
"这篇文章主要介绍了如何使用IDA工具进行逆向分析C++程序，特别是如何识别析构函数和其他关键的C++特性。文章分为手工方法和自动化两个部分，详细阐述了识别类、构造函数、析构函数、多态类、类间关系及成员的方法。...
C++继承与析构函数解析
C++编译器会自动按照从派生类到基类的顺序，调用各个析构函数。这是因为析构函数的调用是逆向于构造函数的调用顺序进行的。首先调用最派生类的析构函数，然后逐级向上，直到基类的析构函数被调用。 4. **析构函数...
C++ 中类成员析构函数调用顺序
最新发布
02-22
### C++ 中类成员析构函数的调用顺序 在 C++ 中，当对象销毁时，会按照特定顺序调用析构函数。对于组合类而言，在其生命周期结束时，先执行派生类自身的析构函数逻辑，之后依次对其基类以及内部含有的其他类型成员...
C++中堆对象的构造函数和析构函数逆向分析
weixin_34174132的博客
04-14 179
实验环境： 操作系统：Windows XP Professional Service Pack 3 集成开发环境：Microsoft Visual C++ 6.0 构建版本：Debug版本 实验代码： 1 #include <stdio.h> 2 3 class People 4 { 5 public: 6 People()...
C++反汇编揭秘1 – 一个简单C++程序反汇编解析 (Rev. 3)
热门推荐
张羿的优快云专栏
11-14 1万+
如果想要了解C++内部的实现原理，没有什么比观察C++代码对应的汇编代码来的更直接了。本系列主要从汇编角度研究C++代码和汇编的对应关系，揭示C++内部的机制和原理。在第一篇文章中我将从一个简单的C++程序着手快速解释一下C++反汇编代码的基本的结构和内容，相当于一个简单的Preview。而在后续的文章中，我将根据不同的Topic，详细解释C++代码对应的反汇编代码。一个简单的C++程序示
cpp反汇编分析之构造函数
jinya
03-31 722
子类构造函数先调用父类。子类保留父类一块空间。 以一个例子分析: class A { public: A() { } ~A() { cout<<"~A"<<endl; } }; class B:public A { public: B(A &a):_a(a) {
c++ new,delete,析构函数原理，汇编展示
sam的学习家园
07-19 3185
479:  String2* str2 = new String2;00401821 6A 10            push        10h  00401823 E8 C8 03 00 00   call        operator new (401BF0h) 00
C++类构造函数、析构函数运行机理
diaoju3333的博客
09-05 188
http://blog.sina.com.cn/s/blog_6fd68d5f0100n60h.html 前言--构造函数、析构函数的简单理解：1）构造函数---对象被创建时候调用的函数；2）析构函数---对象被释放时候调用的函数；一案例程序源代码//下面的代码为一个简单的VC++6.0下生成的控制台工程，自定义了一个CObj类：#include"stdafx.h"const i...
《C++反汇编与逆向分析技术揭秘》之十——析构函数
weixin_30588675的博客
12-17 168
局部对象 当对象所在作用域结束之后，销毁栈空间，此时析构函数被调用。 举例： 函数返回时自动调用析构函数： 堆对象 调用析构代理函数来处理析构函数： 为什么使用析构代理函数来调用析构函数？考虑到如果delete的对象是一个对象数组，可以使用析构代理函数依次析构所有的对象。举例： 调用了构造代理函数： vector ...
从逆向分析角度看C++虚函数
个人技术博客
07-28 6151
从逆向分析角度，粗略地分析了虚拟表的结构，本人才疏学浅，有误之处，望各位指正
__stdcall 和 __cdecl 的区别
个人技术博客
03-05 4809
1. __cdecl __cdecl 是C Declaration的缩写（declaration，声明），表示C语言默认的函数调用方法：所有参数从右到左依次入栈，由调用者负责把参数压入栈，最后也是由调用者负责清除栈的内容，一般来说，这是 C/C++ 的默认调用函数的规则，MS VC 编译器采用的规则则是这种规则 2. __stdcall _stdcall 是StandardCall的缩写，是
前置和后置运算符
个人技术博客
03-22 4568
这是迅雷一问一答的题目： #include int main(void) { int a, b; a = 5; a = a + a++; printf("a = %d\n", a); a = 5; b = a + a++; printf("b = %d\n", b); return 0; } 输出的结果是： 反汇编过程： PUBL
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值