反汇编(三)C/C++ 结构体与类(1)--this指针、类成员与类成员函数

最新推荐文章于 2022-09-04 13:05:57 发布
最新推荐文章于 2022-09-04 13:05:57 发布
阅读量611 收藏 1
点赞数
分类专栏： 反汇编
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38576022/article/details/97170077
版权

类的内容有点多，分章节研究

结构体跟类

1.结构体跟类

结构体跟类本质上没有太大区别，只是结构体成员默认为public的，而类则是private。这里直接省去了结构体的反汇编。直接看类。

#include<iostream>
using namespace std;

class A
{
public:	
	/*
	 	以下数据成员探讨 一个类的大小由什么决定 
	 	以及数据排列 内存对齐等特性 
	*/ 
	const static int sos = 654;	
	int old;
	int old2;
	char ui;
	char po[14];
	
	/*
		以下来探讨函数在类中是如何表现的  
	*/ 
	
	int getNumber()
	{
		return old + old2;
	}
	//这个函数来看看this指针到底是什么 
	void seeThis()
	{
		this->old = 555;
	}
	
};

int main()
{
	A a;
	a.getNumber();
	a.seeThis();
	
	
	A b;
	b.getNumber();
	b.seeThis(); 
	
	
	return 0;
}

选择了静态反汇编工具IDAPro跟动态反汇编OD(便于调试)，配合进行 。附上了反汇编代码

main函数部分：

这里并没有发现实例对象的代码.(构造函数的问题?这里先放放)，看其他部分

.text:004013B0 ; int main()
.text:004013B0                 public _main
.text:004013B0 _main           proc near               ; CODE XREF: ___mingw_CRTStartup+F8p
.text:004013B0                 push    ebp
.text:004013B1                 mov     ebp, esp
.text:004013B3                 and     esp, 0FFFFFFF0h
.text:004013B6                 sub     esp, 30h
.text:004013B9                 call    ___main

                               //这里开始
                               //把a的首地址赋值给eax，然后赋值给ecx
                               
.text:004013BE                 lea     eax, [esp+18h]
.text:004013C2                 mov     ecx, eax

                               //调用a的成员函数getNumber()

.text:004013C4                 call    __ZN1A9getNumberEv ; A::getNumber(void)

                               //把a的首地址赋值给eax，然后赋值给ecx

.text:004013C9                 lea     eax, [esp+18h]
.text:004013CD                 mov     ecx, eax
                               //调用a的成员函数seeThis()
.text:004013CF                 call    __ZN1A7seeThisEv ; A::seeThis(void)

                               //把b的首地址赋值给eax，然后赋值给ecx

.text:004013D4                 mov     eax, esp
.text:004013D6                 mov     ecx, eax
                               //调用b的getNumber()
.text:004013D8                 call    __ZN1A9getNumberEv ; A::getNumber(void)
                               
                               //把b的首地址放到ecx中
.text:004013DD                 mov     eax, esp
.text:004013DF                 mov     ecx, eax
                               //调用b的seeThis()函数
.text:004013E1                 call    __ZN1A7seeThisEv ; A::seeThis(void)
.text:004013E6                 mov     eax, 0
.text:004013EB                 leave
.text:004013EC                 retn
.text:004013EC _main           endp

这里产生的问题：

1.类的在内存中的排列由什么决定?

看到  .text:004013BE 这行 与 .text:004013D4 这行。esp栈顶寄存器相隔18h，也就是24字节大小。反观类A,两个int类型，

一个char型，一个14字节的char数组，一个静态成员。除去静态成员4字节的大小(静态数据成员不算大小)，一个char 加上 char数组 (这里有内存对齐，对齐的部分留空)，一共算16字节，两个int 8字节，相加为24字节。

这里可以初步总结：不算内存对齐的留空内存，类在内存中的排列方式大致跟数组相同。静态数据成员其实跟全局变量相同。只不过编译器做了作用域限制。这里不再详细给出，但是可以肯定是，静态数据成员的位置不在栈空间中。那么类在内存中的排列其实还是看编译器怎么处理，内存对齐也复杂，这里以看到的为准，就轻描淡写的过了。

2.在调用成员函数时，为什么要把a，b的首地址放到ecx寄存器中?

在看一段反汇编代码：

.text:0041B6B0 ; void __cdecl A::seeThis(A *const this)
.text:0041B6B0 __ZN1A7seeThisEv proc near              ; CODE XREF: _main+1Fp
.text:0041B6B0                                         ; _main+31p
.text:0041B6B0
.text:0041B6B0 this            = dword ptr -4
.text:0041B6B0
.text:0041B6B0                 push    ebp
.text:0041B6B1                 mov     ebp, esp
.text:0041B6B3                 sub     esp, 4
                            
                               //ecx即为this   
                            
.text:0041B6B6                 mov     [ebp+this], ecx
                               //this放入eax
.text:0041B6B9                 mov     eax, [ebp+this]、
                               //this->old = 555;
.text:0041B6BC                 mov     dword ptr [eax], 22Bh
.text:0041B6C2                 leave
.text:0041B6C3                 retn
.text:0041B6C3 __ZN1A7seeThisEv endp
.text:0041B6C3
.text:0041B6C4
.text:0041B6C4 ; =============== S U B R O U T I N E =======================================
.text:0041B6C4
.text:0041B6C4 ; Attributes: static bp-based frame
.text:0041B6C4
.text:0041B6C4 ; int __cdecl A::getNumber(A *const this)
.text:0041B6C4                 public __ZN1A9getNumberEv
.text:0041B6C4 __ZN1A9getNumberEv proc near            ; CODE XREF: _main+14p
.text:0041B6C4                                         ; _main+28p
.text:0041B6C4
.text:0041B6C4 this            = dword ptr -4
.text:0041B6C4
.text:0041B6C4                 push    ebp
.text:0041B6C5                 mov     ebp, esp
.text:0041B6C7                 sub     esp, 4
                               //把首地址放入 ebp+this(此this非彼this，不要弄混淆)
.text:0041B6CA                 mov     [ebp+this], ecx

                               //return old + old2;
.text:0041B6CD                 mov     eax, [ebp+this]
.text:0041B6D0                 mov     edx, [eax]
.text:0041B6D2                 mov     eax, [ebp+this]
.text:0041B6D5                 mov     eax, [eax+4]
.text:0041B6D8                 add     eax, edx

.text:0041B6DA                 leave
.text:0041B6DB                 retn
.text:0041B6DB __ZN1A9getNumberEv endp

以下分别为getNumber()跟seeThis()的反汇编代码,部分解释在注释里

1.这里发现神奇的事情，a跟b这两个对象，共用一段函数代码。也就是说，在实例类对象时，不会重复定义函数，函数只会存在一份。那么此时又产生一个问题，如何识别当前调用的是a的函数还是b的函数？承接上面的问题，关键在ecx寄存器。ecx即为this。函数执行的时候会以这个this当做基地址+上成员变量的偏移地址。这有点像多线程中的可重入函数。当然，具体以什么寄存器作为this的保存者，具体看编译器怎么决定，大致做法都是一样的。可能这里ecx为esi，edi都有可能。

2.这里可以看到类成员函数区别于普通函数的是，编译器隐藏了一个参数传递.为以下：

.text:0041B6B0 ; void __cdecl A::seeThis(A *const this)
.text:0041B6C4 ; int __cdecl A::getNumber(A *const this)

A*const this。这是编译器通过ecx传递过去的参数。具体怎么传递，看编译器的传递方式，这里为c的调用方式。也可以用stdcall的调用方式。 

由此，初步结论。类变得不再那么神秘，它是编译器抽象化的产物，数据排列方式大致如数组，成员函数不在类中定义(但同类的对象公用一个函数代码块，这就跟调用普通函数没有任何区别)，静态成员跟全局变量相同，只不过编译器做了作用域限制。this指针即为对象的首地址。一般存入某个寄存器。

夜听细雨声
关注
专栏目录
C/C++程序员为什么要了解汇编？了解汇编有哪些好处？如何学习汇编？
dvlinker的技术专栏
10-09 7265
本文详细讲解了C++程序员为什么要了解汇编，了解汇编都有哪些具体的好处，如何学习汇编，以及如何看懂汇编代码上下文等，希望能给大家提供一定的借鉴或参考。
使用反汇编工具IDA查看动态库的汇编代码上下文，结合安卓系统生成的Tombstone文件，排查安卓app程序底层C++库的崩溃问题
最新发布
dvlinker的技术专栏
08-14 3万+
使用IDA反汇编工具查看汇编代码上下文，结合安卓系统自动生成的Tombstone文件，去分析安卓app程序底层C++模块的崩溃问题。
C++反汇编学习笔记4——结构体和类1
Traxer的学习之路
12-17 2070
在C++中类和结构体都具有构造函数、析构函数和成员函数，两者的唯一区别就在于结构体的默认访问控制为public，而类则是private。在C++中对于访问控制都是在编译期进行检查，所以在执行时程序不会对访问控制做任何检查和限制，因此在反汇编中两者没有区别，两者原理相同只是类型名称不同。 1.对象的内存布局 了解C++就必然要了解类，所以类和对象之间的关系这里就不再多说，就举几个简单的小例子:
反汇编 之构造函数的this指针
xiaozhi
02-17 984
从C++的标准可知，构造函数的返回值是一个新建立的对象的指针，即this指针。 /* * 从汇编层面看，C++类(class)的组织方式和结构体数据完全一致。 */ class c { private: int v1; int v2; public: c() { v1 = 667; v2 = 999; } c(int a, int b) { v1 = a; v2 = b;...
反汇编 this 指针分析
苦逼码农
06-18 1911
先看一个没有虚函数的类 class A  { public: A() { _a = 0; _b = 0; cout } ~A() { cout cout } void fun1() { cout cout cout cout } int fun2(int a,int b) { cout cout cout return 0; } p
从反汇编看this指针
jxz_dz的博客
08-20 1800
在这大概从三个角度来谈this指针 : A . this指针的由来  B . this指针的特点   C . this指针与this Call调用方式    有错误的地方,欢迎批评指正 A . this指针的由来      1.
C++对象模型7——类的成员函数、反汇编虚析构函数、RTTI、多态的开销
Master Cui的博客
03-18 358
一、类成员函数 class test { public: void myfunc(){} virtual void vfunc() {} static void sfunc() {} }; void myfunc(){} 查看上述代码的可执行文件的符号清单 可见，所有的成员函数最终在可执行文件中，都被转化成了具有唯一函数名的成员函数，所以，类的成员函数经过编译器处理后，实质上就是全局函数 非static成员函数的转换过程主要就是添加this指针参数并用this指针访问类数据成员，最后改
笔记：C++结构体内部声明函数名，外部实现
Q324411601的博客
09-04 1271
笔记：C++结构体内部声明函数名，外部实现
C++反汇编视频教程（代码+课件+视频全套价值300元的付费教程）
04-04
这是一套基础课程，着重讲解反汇编代码与 C/C++ 语法的对应关系，抓住最核心的知识点。 学员对象 课程面向的学员需要具备 C++ 基础知识，汇编语言则不必很熟练，了解一些常用指令即可。如果您想从事逆向工程和软件...
反汇编——结构体作为局部变量的传参和返回值的本质测试
zmmycsdn的博客
11-20 756
结构体传参： # include struct st { char a; short b; int c; int d; int e; }; void Function(st s) { } int main(int argc, char* argv[]) { st s; s.a = 1; s.b = 2; s.c = 3; s.d = 4; s.e = 5; Func
C++中的this指针相关内容总结
sakeww的博客
04-24 305
什么是this指针？ this指针是类“成员函数”第一个隐藏的参数，该指针时时刻刻指向调用成员函数的对象（当前对象） 先写一份关于“类”的代码，我们从中开始探究this class Student { public: char _name[20]; char _gender[3]; int _age; public: //下列函数代码有四个参数，另一个参数是：隐藏的this指针 //在写代码期间，用户不用显示给出this指针，编译器在编译代码时，会自动加上this指针的参数 void
C++结构体和类的成员函数
努力的八戒
08-02 5299
1、使用结构体成员变量"."还是“->"的区别? 一般的结构体成员变量访问用"."即可，只用结构体指针访问结构体成员才使用“->" #include <iostream> #include<cstring> using namespace std; struct Books { char title[50]; char author[50]; int...
结构体中定义指针
心随梦动
11-05 6318
转自：http://blog.csdn.net/unix21/article/details/9293877 结构体指针变量的定义，定义结构体变量的一般形式如下： 形式１：先定义结构体类型，再定义变量 struct结构体标识符 { 成员变量列表;… }; struct 结构体标识符 *指针变量名; 变量初始化一：struct结构体标识符 变量名={初始化值1，初
《C++反汇编与逆向分析技术揭秘》读书总结——this指针
北侠的博客
10-05 1557
this指针中保存了所属对象的首地址。 看一个书中示例： 上述代码中，利用寄存器ecx保存了对象的首地址，并以寄存器传参的方式传递到成员函数中，这便是this指针的由来。所有的成员函数（非静态成员函数）都有一个隐藏参数 ，即自身类型的指针——this指针，将这样的默认调用约定称为thiscall，类的成员函数默认是 thiscall调用方式。thiscall与__stdcall的堆栈平衡方...
将shellcode反编译成c语言代码的两种方式
weixin_43090100的博客
10-04 5657
下述所用的工具包含：IDA pro，Dev C++ 以下介绍两种方法 开始操作之前，需要知道的几个小前提 一个可执行文件包含多个字段(field), text段是程序代码段，包含着要运行程序的指令。shellcode像你说的，转成汇编语言很容易，因为shellcode本质就是一段恶意的机器码——cpu指令 逆向工程(reverse engineering)常用到的分析工具大体有两个：olly...
Debug指令练习
萍水间人的小天地
06-06 320
关于之前的一部分指令，可以参考这篇文章 rep stosd循环： 从lea edi , [EBP+arg_0] 开始，到rep stosd 结束。EDI中存入的是循环操作的起始地址，ECX存入的是循环次数，EAX是循环填入的值。这一段的操作就是从EBP+var_40处开始，循环十次，向下依次填入CCCCCCCC，写入的长度由EAX决定，32位。 1: #include &...
简单反汇编之还原(谁是窃贼算法)C++代码
收破烂的
01-20 3375
    能读懂汇编代码不难，但是要是从汇编代码还原成源码就有的难度了(高手飘过)，今天闲来无事，从网上找了个简单的算法，试着从汇编代码还原代码，从网上找了个谁是窃贼的算法代码，在没有看源码的情况下编译，然后反汇编Release版，分析的汇编代码如下：00401000 /$ 83EC 10 SUB ESP,10 //安排4个
c++下类成员函数的调用发生了啥（从汇编看）
danolphoenix的专栏
06-29 1570
昨天使用了下这样一段代码 class A { public: virtual void vitualFun() { cout<<"hello this is a A vitual Fun()"<<endl; }; }; class B : public A { public: void vitualFun() { cout<<"hello t
深入探讨this指针：从汇编的角度考虑
liaoyoujinb的专栏
08-19 3279
深入探讨this指针：从汇编的角度考虑 总结：至此我们对this指针和成员函数调用有了更进一步的认识, (1) this 指针只存在于成员函数内部， (2) 成员函数的调用时，this指针并没有那么神秘，那完全可以认为对象在调用成员函数时将自身地址作为函数的第一个参数在默认情况下传递给了函数的默认形参，只不过这个默认形参被命名为this罢了，仅此而已，小样，不就是穿了一个马甲吗！ (3) 尽管我们可以把this指针当做成员函数的第一个默认参数，但是我们心里应该明白，事实上它还是有点特殊待遇的，它与正常的函数
C/C++结构体与链表详解：入门与实践
在定义结构体时，例如`struct test`，我们可以看到其包含了三个成员：`char name[10]`用于存储字符串，`float score`用于存储浮点数，以及`test* next`是一个结构体指针，指向另一个同类型的结构体实例。这展示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值