cpp反汇编分析之构造函数

最新推荐文章于 2023-06-19 22:17:28 发布
最新推荐文章于 2023-06-19 22:17:28 发布
阅读量688 收藏
点赞数
分类专栏： cpp c 反汇编 文章标签： 反汇编 c cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011185633/article/details/44778631
版权
cpp 同时被 3 个专栏收录
27 篇文章 0 订阅
订阅专栏
反汇编
13 篇文章 0 订阅
订阅专栏
c
7 篇文章 0 订阅
订阅专栏

子类构造函数先调用父类。子类保留父类一块空间。

以一个例子分析:

class A  
{  
public:  
    A()  {     }  
    ~A() {    cout<<"~A"<<endl;   }  
};  
   
class B:public A  
{  
    public:  
        B(A &a):_a(a)  
        {  
             
        }  
        ~B()  
        {  
            cout<<"~B"<<endl;  
        }  
    private:  
        A _a;  
    };  
       
int main(void)  
 {  
        A a;       //很简单，定义a的时候调用了一次构造函数  
        B b(a); 
}

输出:
A construct
A construct
const A&
~B
~A
~A
~A 

下面是反汇编代码

1:    #include <iostream>
2:    using namespace std;
3:    class A
4:    {
5:    public:
6:        A()
00401240   push        ebp
00401241   mov         ebp,esp
00401243   sub         esp,44h
00401246   push        ebx
00401247   push        esi
00401248   push        edi
00401249   push        ecx
0040124A   lea         edi,[ebp-44h]
0040124D   mov         ecx,11h
00401252   mov         eax,0CCCCCCCCh
00401257   rep stos    dword ptr [edi]
00401259   pop         ecx
0040125A   mov         dword ptr [ebp-4],ecx
7:        {
8:            cout << "A construct" << endl;
0040125D   push        offset @ILT+35(std::endl) (00401028)
00401262   push        offset string "A construct" (0043201c)
00401267   push        offset std::cout (00439528)
0040126C   call        @ILT+180(std::operator<<) (004010b9)
00401271   add         esp,8
00401274   mov         ecx,eax
00401276   call        @ILT+120(std::basic_ostream<char,std::char_traits<char> >::operator<<) (0040107d)
9:        }
0040127B   mov         eax,dword ptr [ebp-4]
0040127E   pop         edi
0040127F   pop         esi
00401280   pop         ebx
00401281   add         esp,44h
00401284   cmp         ebp,esp
00401286   call        __chkesp (004096e0)
0040128B   mov         esp,ebp
0040128D   pop         ebp
0040128E   ret
10:       A operator=(const A &a)
11:       {
12:           cout << "operator = " << endl;
13:           return a;
14:       }
15:       A(const A& a)		复制构造函数
004013B0   push        ebp
004013B1   mov         ebp,esp
004013B3   sub         esp,44h
004013B6   push        ebx
004013B7   push        esi
004013B8   push        edi
004013B9   push        ecx
004013BA   lea         edi,[ebp-44h]
004013BD   mov         ecx,11h
004013C2   mov         eax,0CCCCCCCCh
004013C7   rep stos    dword ptr [edi]
004013C9   pop         ecx
004013CA   mov         dword ptr [ebp-4],ecx
16:       {
17:           cout << "const A&" << endl;
004013CD   push        offset @ILT+35(std::endl) (00401028)
004013D2   push        offset string "const A&" (00432030)
004013D7   push        offset std::cout (00439528)
004013DC   call        @ILT+180(std::operator<<) (004010b9)
004013E1   add         esp,8
004013E4   mov         ecx,eax
004013E6   call        @ILT+120(std::basic_ostream<char,std::char_traits<char> >::operator<<) (0040107d)
18:       }
004013EB   mov         eax,dword ptr [ebp-4]
004013EE   pop         edi
004013EF   pop         esi
004013F0   pop         ebx
004013F1   add         esp,44h
004013F4   cmp         ebp,esp
004013F6   call        __chkesp (004096e0)
004013FB   mov         esp,ebp
004013FD   pop         ebp
004013FE   ret         4

19:       ~A()
20:       {
004012B0   push        ebp
004012B1   mov         ebp,esp
004012B3   sub         esp,44h
004012B6   push        ebx
004012B7   push        esi
004012B8   push        edi
004012B9   push        ecx
004012BA   lea         edi,[ebp-44h]
004012BD   mov         ecx,11h
004012C2   mov         eax,0CCCCCCCCh
004012C7   rep stos    dword ptr [edi]
004012C9   pop         ecx
004012CA   mov         dword ptr [ebp-4],ecx
21:           cout<<"~A"<<endl;
004012CD   push        offset @ILT+35(std::endl) (00401028)
004012D2   push        offset string "~A" (0043202c)
004012D7   push        offset std::cout (00439528)
004012DC   call        @ILT+180(std::operator<<) (004010b9)
004012E1   add         esp,8
004012E4   mov         ecx,eax
004012E6   call        @ILT+120(std::basic_ostream<char,std::char_traits<char> >::operator<<) (0040107d)
22:       }
004012EB   pop         edi
004012EC   pop         esi
004012ED   pop         ebx
004012EE   add         esp,44h
004012F1   cmp         ebp,esp
004012F3   call        __chkesp (004096e0)
004012F8   mov         esp,ebp
004012FA   pop         ebp
004012FB   ret

23:   };
24:
25:   class B:public A
26:   {
27:       public:
28:           B(A &a):_a(a)
29:           {
00401310   push        ebp
00401311   mov         ebp,esp
00401313   push        0FFh
00401315   push        offset __ehhandler$??0B@@QAE@AAVA@@@Z (0041fd79)
0040131A   mov         eax,fs:[00000000]
00401320   push        eax
00401321   mov         dword ptr fs:[0],esp
00401328   sub         esp,44h
0040132B   push        ebx
0040132C   push        esi
0040132D   push        edi
0040132E   push        ecx
0040132F   lea         edi,[ebp-50h]
00401332   mov         ecx,11h
00401337   mov         eax,0CCCCCCCCh
0040133C   rep stos    dword ptr [edi]
0040133E   pop         ecx
0040133F   mov         dword ptr [ebp-10h],ecx
00401342   mov         ecx,dword ptr [ebp-10h]
00401345   call        @ILT+80(A::A) (00401055)		普通构造函数	B类有A类对象。
0040134A   mov         dword ptr [ebp-4],0
00401351   mov         eax,dword ptr [ebp+8]
00401354   push        eax
00401355   mov         ecx,dword ptr [ebp-10h]
00401358   call        @ILT+165(A::A) (004010aa)	复制构造函数
30:           //     _a = a;
31:           }
0040135D   mov         dword ptr [ebp-4],0FFFFFFFFh
00401364   mov         eax,dword ptr [ebp-10h]
00401367   mov         ecx,dword ptr [ebp-0Ch]
0040136A   mov         dword ptr fs:[0],ecx
00401371   pop         edi
00401372   pop         esi
00401373   pop         ebx
00401374   add         esp,50h
00401377   cmp         ebp,esp
00401379   call        __chkesp (004096e0)
0040137E   mov         esp,ebp
00401380   pop         ebp
00401381   ret         4

32:           ~B()
33:           {
00401420   push        ebp
00401421   mov         ebp,esp
00401423   push        0FFh
00401425   push        offset __ehhandler$??1B@@QAE@XZ (0041fda2)
0040142A   mov         eax,fs:[00000000]
00401430   push        eax
00401431   mov         dword ptr fs:[0],esp
00401438   sub         esp,44h
0040143B   push        ebx
0040143C   push        esi
0040143D   push        edi
0040143E   push        ecx
0040143F   lea         edi,[ebp-50h]
00401442   mov         ecx,11h
00401447   mov         eax,0CCCCCCCCh
0040144C   rep stos    dword ptr [edi]
0040144E   pop         ecx
0040144F   mov         dword ptr [ebp-10h],ecx
00401452   mov         dword ptr [ebp-4],1
34:               cout<<"~B"<<endl;
00401459   push        offset @ILT+35(std::endl) (00401028)
0040145E   push        offset string "~B" (0043203c)
00401463   push        offset std::cout (00439528)
00401468   call        @ILT+180(std::operator<<) (004010b9)
0040146D   add         esp,8
00401470   mov         ecx,eax
00401472   call        @ILT+120(std::basic_ostream<char,std::char_traits<char> >::operator<<) (0040107d)
35:           }
00401477   mov         byte ptr [ebp-4],0
0040147B   mov         ecx,dword ptr [ebp-10h]
0040147E   call        @ILT+110(A::~A) (00401073)
00401483   mov         dword ptr [ebp-4],0FFFFFFFFh
0040148A   mov         ecx,dword ptr [ebp-10h]
0040148D   call        @ILT+110(A::~A) (00401073)
00401492   mov         ecx,dword ptr [ebp-0Ch]
00401495   mov         dword ptr fs:[0],ecx
0040149C   pop         edi
0040149D   pop         esi
0040149E   pop         ebx
0040149F   add         esp,50h
004014A2   cmp         ebp,esp
004014A4   call        __chkesp (004096e0)
004014A9   mov         esp,ebp
004014AB   pop         ebp
004014AC   ret
36:       private:
37:           A _a;
38:       };
39:
40:   int main(void)
41:    {
00401190   push        ebp
00401191   mov         ebp,esp
00401193   push        0FFh
00401195   push        offset __ehhandler$_main (0041fd59)
0040119A   mov         eax,fs:[00000000]
004011A0   push        eax
004011A1   mov         dword ptr fs:[0],esp
004011A8   sub         esp,4Ch
004011AB   push        ebx
004011AC   push        esi
004011AD   push        edi
004011AE   lea         edi,[ebp-58h]
004011B1   mov         ecx,13h
004011B6   mov         eax,0CCCCCCCCh
004011BB   rep stos    dword ptr [edi]
42:           A a;       //很简单，定义a的时候调用了一次构造函数
004011BD   lea         ecx,[ebp-10h]
004011C0   call        @ILT+80(A::A) (00401055)
004011C5   mov         dword ptr [ebp-4],0
43:           B b(a);
004011CC   lea         eax,[ebp-10h]
004011CF   push        eax
004011D0   lea         ecx,[ebp-14h]
004011D3   call        @ILT+155(B::B) (004010a0)
44:           return 0;
004011D8   mov         dword ptr [ebp-18h],0
004011DF   lea         ecx,[ebp-14h]
004011E2   call        @ILT+130(B::~B) (00401087)
004011E7   mov         dword ptr [ebp-4],0FFFFFFFFh
004011EE   lea         ecx,[ebp-10h]
004011F1   call        @ILT+110(A::~A) (00401073)
004011F6   mov         eax,dword ptr [ebp-18h]
45:   }
004011F9   mov         ecx,dword ptr [ebp-0Ch]
004011FC   mov         dword ptr fs:[0],ecx
00401203   pop         edi
00401204   pop         esi
00401205   pop         ebx
00401206   add         esp,58h
00401209   cmp         ebp,esp
0040120B   call        __chkesp (004096e0)
00401210   mov         esp,ebp
00401212   pop         ebp
00401213   ret


@ILT+145(_main):
00401096   jmp         main (00401190)

@ILT+155(??0B@@QAE@AAVA@@@Z):
004010A0   jmp         B::B (00401310)

@ILT+165(??0A@@QAE@ABV0@@Z):
004010AA   jmp         A::A (004013b0)	复制构造函数

@ILT+110(??1A@@QAE@XZ):
00401073   jmp         A::~A (004012b0)
@ILT+130(??1B@@QAE@XZ):
00401087   jmp         B::~B (00401420)

@ILT+80(??0A@@QAE@XZ):
00401055   jmp         A::A (00401240)	普通构造函数


_子木_
关注
专栏目录
从反汇编的角度看C++语法(构造函数)
Hani的 编程生活
10-25 1079
从反汇编的角度看C++语法(hani199012@gmail.com.cn/QQ :1121797386)  写在前面的话 写这些文章，主要是对自己在学习C++过程中遇到的一些问题进行总结，同时，利用反汇编工具来看C++语法在实际内存中的体现，因为，C++是一门高级语言，其实是写给人看的，但是机器只认识0  1 ，查看在学习过程中编写的一些练习的程序的反汇编代码，这样，看得更加实际，不那么抽象
cpp反汇编之构造函数2
jinya
04-01 612
先献上源代码 #include class CNumber { public: CNumber() { m_nNumber = 1; } int m_nNumber; }; void main() { CNumber *pNumber = NULL; pNumber = new CNumber; pNumber->m_nNumber = 3; printf("%d \r\n
C++反汇编第一讲,认识构造函数,析构函数,以及成员函数
weixin_30344795的博客
12-03 129
　　　　　　　　　　C++反汇编第一讲,认识构造函数,析构函数,以及成员函数 以前说过在C系列下的汇编,怎么认识函数.那么现在是C++了,隐含有构造和析构函数 一丶认识构造函数 高级代码: 　　 class MyTest { public: MyTest(); ~MyTest(); public: DWORD m_dwTest; };...
反汇编学习之路之构造函数与析构函数（一）
知其所以然
04-20 1095
构造函数与析构函数是类的重要组成部分，他们在类中担任着至关重要的工作。够战术常用来完成对象的生成时的初始化工作，而析构函数则常用于在对象销毁时释放对象中的所申请的资源。 当对象生成时，编译器会自动产生调用其类的构造函数的代码，在编码构成中可以分为类中的数据尘烟赋予的初始值，当对象销毁时，编译器同样也会产生调用其析构函数的代码。 构造函数与析构函数都是类中特殊的函数，构造函数可以重载，而析构函数
反汇编 之构造函数反汇编看到的初始化顺序
xiaozhi
02-17 853
/* * 构造函数反汇编看到的顺序 */ 1.继承类构造函数 2.构造函数:后面的初始化变量 3.class里面申明的类变量构造函数 4.构造函数体内代码 5.class里面的类变量析构函数 /* .h */ class CameraCtrl : public CameraSyncBase,public NetworkBaseInterface, public SerialProxyInterface,public HDLS_FileTra...
深入C++虚表(虚函数 虚表 反汇编)
05-28
本文将通过分析C++程序的反汇编代码来揭示虚表的工作机制，以便更好地理解C++多态性的底层实现。我们将重点关注以下几个方面： - **虚表是如何实现的？** - **虚表存放在何处？** - **虚表中的数据何时确定？** - *...
c++ 默认移动构造函数
星河的博客
12-28 3705
class Test { public: Test(int v, const string& str) { p = new int(v); s = str; cout << "test()" << endl; } ~Test() { cout << "~Test()" << endl; delete p; p = nullptr;
C++ 类的反汇编
ez scope
07-04 2484
C++的类与C++的结构体本质上没有什么不同，唯一不同的可能即是在编译期默认的成员访问全乡不同。当我们new 一个类时，在heap中申请了一块内存区域， 用于保存类的实体，并且调用了类的构造函数。当我们调用delete时，调用了析构函数，并调用了heap内存块释放函数。 今天随便写了一个简单的类，并对其进行了反汇编分析，由此记录下来，环境如下： 操作系统：win7 sp1 x86_64 调
构造函数、反编译、构造代码块
一点一滴
09-27 645
java是面向对象的语言： “万物皆对象”: 任何事物都可以使用类进行描述。需求： 使用java类描述 一个婴儿. 在现实生活中有两种婴儿， 一种婴儿一出生就具备了名字(有身份)，还有一种婴儿就是出生之后才有名字的(黑户)。 那么如何才能成为有身份的baby呢？引入构造函数。一、构造函数： 1、作用： 给对应的对象进行初始化。2、构造函数的定义的格式：修饰符 函数名(形式参数)
cpp反汇编之类和结构体分析
jinya
04-07 929
废话不多说。。 #include class CNumber { public: CNumber() { m_nOne = 1; m_nTwo = 2; } int __stdcall GetNumberOne() { return m_nOne; } int GetNumberTwo() { return m_nTwo; }1: #include 2:
cpp反汇编之控制结构
jinya
04-01 708
控制结构主要是关于  if/else   switch/case 废话不多说。。献上代码及反汇编分析。。 #include int main(int argc , char *argv[]) { int nInt = 9; // if(0 == nInt) __asm { cmp DWORD PTR [EBP - 4h] , 0 ; jle __exit; } // __
C++ 反汇编简要
最新发布
梦的灰色边沿...
06-19 2747
C/C++都需要经过编译器变成对应的机器码，通常编译器对程序员是个黑盒子。有些时候我们可能会纠结编译器会不会进行RVO，EBO等优化，以及一些在我们看起来应该正常的代码因为一些UB的行为被C++编译器优化成了不可预期的代码。这时候如果我们了解具体代码是如何编译成对应的二进制机器码对我们查具体的问题非常有益。另一种场景，在开发软件时，线上环境能够复现的问题，我们本地可能是无法复现的。这就需要我们根据线上的堆栈分析具体的原因。
cpp反汇编之const分析
jinya
04-04 797
先来分析一个简单的例子。(注意容易出错) 代码非常简单 #include #include using namespace std; int main(){ const int a = 1; int* b = (int*)&a; *b = 2; cout << a << endl << *b << endl; return 0; } 反汇编分析  重点之处有注释 1: #i
cpp反汇编之继承之基类
jinya
04-02 574
先分析一个例子。 #include class CBase { public: CBase() { printf("CBase\n"); } ~CBase() { printf("~CBase\n"); } void SetNumber(int nInt) { this->m_nNumber = nInt; } int GetNumber() { retu
C++ 反汇编：分析类的实现原理
CSDN
04-29 1万+
反汇编(Disassembly) 即把目标二进制机器码转为汇编代码的过程，该技术常用于逆向工程、软件汉化等领域，学习和理解反汇编对软件调试、系统漏洞挖掘、内核原理及理解高级语言代码都有相当大的帮助，软件一切神秘的运行机制全在反汇编代码里面。下面将分析VS 2013 编译器产生C代码的格式与实现方法，研究一下编译器的编译特性。
c和c++的反汇编方法
weixin_40673765的博客
08-06 1117
反汇编
C/C++ 反编译工具开源软件
热门推荐
MessCodes
04-20 12万+
转自：点击打开链接 Java反编译器 Java Decompiler 这款反编译器叫 "Java Decompiler", 由 Pavel Kouznetsov开发，目前最新版本为0.2.5. 它由 C++开发，并且官方可以下载 windows、linux和苹果Mac Os三个平台的可执行程序。 其有下面几个功能：   1. 支持对整个Jar文件进行
python中构造函数和cpp构造函数
05-26
Python和C++中都有构造函数的概念，不同的是它们的语法和用法略有不同。 在Python中，构造函数是`__init__()`方法，它的作用是在创建对象时初始化对象的属性。例如： ```python class MyClass: def __init__(self...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值