本文主要主要研究C++中数组，结构以及类的反汇编。
1.数组
数组在内存中式一块连续的区域。比如当声明char ch[100]的时候， 我们知道栈是向下增长的， 所以我们开辟地址空间的时候起地址就为[esp(esp会赋值给ebp) – 100, esp].我们可以看下如下的列子：
1 char buf[ 100 ];
2 for ( int i = 0 ; i < 100 ; i ++ )
3 buf[i] = i;
我们看下他的反汇编代码：
1 char buf[ 100 ];
2 for ( int i = 0 ; i < 100 ; i ++ )
3 00BD13A8 mov dword ptr [i], 0
4 00BD13AF jmp wmain + 3Ah (0BD13BAh)
5 00BD13B1 mov eax,dword ptr [i]
6 00BD13B4 add eax, 1
7 00BD13B7 mov dword ptr [i],eax
8 00BD13BA cmp dword ptr [i],64h
9 00BD13BE jge wmain + 4Ch (0BD13CCh) // 到这里是一个典型的for循环标志了
10 buf[i] = i;
11 00BD13C0 mov eax,dword ptr [i] // 把当前i的值赋予eax，这个eax是用来计算内存位置的
12 00BD13C3 mov cl, byte ptr [i] // 因为是char型，所以复制给cl， 这个是给内存赋值的
13 00BD13C6 mov byte ptr [ebp + eax - 6Ch],cl // 计算当前buf[i]在栈中的位置，并赋值
14 00BD13CA jmp wmain + 31h (0BD13B1h)
从上面我们就可以知道buf[0] = [ebp-100]; buf[1] = [ebp -99]……
2.结构体
我们声明这样一个结构体
1 struct myStruct
2 {
3 int a;
4 char b;
5 float c;
6 };
然后调用之:
1 int _tmain( int argc, _TCHAR * argv[])
2 {
3 int n = sizeof (myStruct);
4 n = sizeof ( float );
5 myStruct test;
6 test.a = 0 ;
7 test.b = ' a ' ;
8 test.c = 1.0f ;
9 return 0 ;
10 }
我们看下其内存是如何分布的：
1 int n = sizeof (myStruct);
2 00FB13A8 mov dword ptr [ebp - 0Ch],0Ch
3 n = sizeof ( float );
4 00FB13AF mov dword ptr [ebp - 0Ch], 4
5 myStruct test;
6 test.a = 0 ;
7 00FB13B6 mov dword ptr [ebp - 20h], 0
8 test.b = ' a ' ;
9 00FB13BD mov byte ptr [ebp - 1Ch],61h
10 test.c = 1.0f ;
11 00FB13C1 fld1
12 00FB13C3 fstp dword ptr [ebp - 18h]
我们可以看出这个结构体的大小为OCH(12), float的大小为4, int为4， char为1， 考虑到内存对齐， 大小就得为4的整数倍， 所以为12。
test.a 在内存中的位置为[ebp-20h]；
test.b 在内存中的位置为[ebp-2Ch]；
test.C 在内存中的位置为[ebp-28h]；
3. 类
C++中的类与结构体没有本质上的区别。都是在某一内存地址上开辟地址空间，存放和操作成员变量。我们可以看下如下的测试代码：
1 class myClass
2 {
3 private :
4 int m_a;
5 char m_b;
6 float m_c;
7 public :
8 myClass(){}
9 ~ myClass(){}
10 void SetA( int a)
11 {
12 m_a = a;
13 }
14 virtual void SetB( char b)
15 {
16 m_b = b;
17 }
18 virtual void SetC( float c)
19 {
20 m_c = c;
21 }
22 };
看下其反汇编的实现：
1 int n = sizeof (myClass);
2 0030144D mov dword ptr [ebp - 14h],10h
3 myClass test;
4 00301454 lea ecx,[ebp - 2Ch]
5 00301457 call myClass::myClass (301028h)
6 0030145C mov dword ptr [ebp - 4 ], 0
7 test.SetA( 10 );
8 00301463 push 0Ah
9 00301465 lea ecx,[ebp - 2Ch]
10 00301468 call myClass::SetA (301014h)
11 test.SetB( ' a ' );
12 0030146D push 61h
13 0030146F lea ecx,[ebp - 2Ch]
14 00301472 call myClass::SetB (3011EFh)
15 test.SetC( 1.0f );
16 00301477 push ecx
17 00301478 fld1
18 0030147A fstp dword ptr [esp]
19 0030147D lea ecx,[ebp - 2Ch]
20 00301480 call myClass::SetC (301104h)
21 return 0 ;
22 00301485 mov dword ptr [ebp - 0F8h], 0
23 0030148F mov dword ptr [ebp - 4 ],0FFFFFFFFh
24 00301496 lea ecx,[ebp - 2Ch]
25 00301499 call myClass:: ~ myClass (3010BEh)
26 0030149E mov eax,dword ptr [ebp - 0F8h]
这里先稍微解释下其意思：
# 0030144D 表明这个类的大小为16， 那位什么不是如上结构体的为12呢， 一问类中用到虚函数，所以就有一个指向虚函数列表的指针，其大小为4。
# 00301457 变量调用了该类的构造函数
# 00301468 调用了SetA
# 00301472 调用了SetB
# 00301499 调用了析构函数
我们分别来看下着四个函数内部的实现。
(1) 构造函数
1 00301550 mov dword ptr [ebp - 8 ],ecx
2 00301553 mov eax,dword ptr [ this ] // 首先我们把this指针放入eax中
3 00301556 mov dword ptr [eax],offset myClass::`vftable ' (306744h)//然后把虚函数列表的地址放入[eax]中
4 0030155C mov eax,dword ptr [ this ]
如上，我们可以看出此类的构造函数只是简单得把虚函数列表的指针指向[this]的地址。
(2) SetA
这个函数是一个的成员函数，我们看下其是如何实现的
1 003015E3 mov eax,dword ptr [ this ]
2 003015E6 mov ecx,dword ptr [a]
3 003015E9 mov dword ptr [eax + 4 ],ecx
如上，可以看出很简单，把参数a的值服务[this + 4]这块地址，而这块地址保存的是成员变量m_a的值。
(3) SetB
SetB是一个虚函数， 我们看下其实如何实现的：
1 00301633 mov eax,dword ptr [ this ]
2 00301636 mov cl, byte ptr [b]
3 00301639 mov byte ptr [eax + 8 ],cl
如上可以发现，虚函数的内部实现和普通的函数没有区别， 唯一不同的是虚函数的位置是放在一个类的虚函数列表里面的。
(4) 析构函数
最后我们看下此类的析构函数是怎么实现的
1 003015A0 mov dword ptr [ebp - 8 ],ecx
2 003015A3 mov eax,dword ptr [ this ]
3 003015A6 mov dword ptr [eax],offset myClass::`vftable ' (306744h)
因为我们在析构函数中什么事情也没有干，所以此析构函数只是简单的吧虚函数列表的地址放到[this]中。
这里我总结下声明一个类其内存是如何分配的：
# 当写下myStruct test;的时候会在栈上开辟一个内存空间，其地址为[this]
# 如果此类有虚函数，就有有一个指向此类虚函数列表的指针，其地址为[this ]
# m_a 的地址为[this +4]
# m_b 的地址为[this + 8]
# m_c 的地址为[this + 0Ch]