浅析C++继承的内存布局

代码如下

class Base
{
public :
Base()
{
printf("Base");
}
~Base()
{
printf("~Base");
}
void SetNumber(int number)
{
m_nBase=number;
}
int GetNumber()
{
return m_nBase;
}
private:
int m_nBase;
};
class Derived:public  Base
{
public:
void ShowNumber(int number)
{
SetNumber(number);
m_nDerived=number+1;
printf("%d",GetNumber());
printf("%d",m_nDerived);

}
int m_nDerived;

};
int main()
{

Derived deriv;
deriv.ShowNumber(5);
return 0;
}

通过反汇编初步结果为

首先我们先看主函数，

00401070 push ebp

00401071 mov ebp,esp

00401073 push 0FFh

00401075 push offset __ehhandler$_main (0041f279)

0040107A mov eax,fs:[00000000]

00401080 push eax

00401081 mov dword ptr fs:[0],esp

00401088 sub esp,4Ch

0040108B push ebx

0040108C push esi

0040108D push edi

0040108E lea edi,[ebp-58h]

00401091 mov ecx,13h

00401096 mov eax,0CCCCCCCCh

0040109B rep stos dword ptr [edi]

这里的栈初始化有点不一样，规定基址ebp后，却压入了三个DWORD，也就是FFh, offset __ehhandler$_main (0041f279),还有eax,这点要注意。

Derived deriv;

0040109D lea ecx,[ebp-14h]

004010A0 call @ILT+45(Derived::Derived) (00401032)

004010A5 mov dword ptr [ebp-4],0

往下走，就是子类的构造函数，00401032是个跳转语句，跳转到了

Derived::Derived:

00401220 push ebp

00401221 mov ebp,esp

00401223 sub esp,44h

00401226 push ebx

00401227 push esi

00401228 push edi

00401229 push ecx

0040122A lea edi,[ebp-44h]

0040122D mov ecx,11h

00401232 mov eax,0CCCCCCCCh

00401237 rep stos dword ptr [edi]

00401239 pop ecx

0040123A mov dword ptr [ebp-4],ecx

0040123D mov ecx,dword ptr [ebp-4]

00401240 call @ILT+15(Base::Base) (00401014)

00401245 mov eax,dword ptr [ebp-4]

00401248 pop edi

00401249 pop esi

0040124A pop ebx

0040124B add esp,44h

0040124E cmp ebp,esp

00401250 call __chkesp (00408810)

00401255 mov esp,ebp

00401257 pop ebp

这里面我们要插入一句，C++里面总是说什么this指针，指向的是本对象的地址，这样讲有点云里雾里，不如我们用汇编来分析

00401088 sub esp,4Ch

这一句代码是主函数的，意思是申请一个大小为0x4C的栈空间，栈空间存放的是子类对象。既然有了子类对象，如何初始化呢

0040109D lea ecx,[ebp-14h]

004010A0 call @ILT+45(Derived::Derived) (00401032)

这里是讲ebp-14处的地址，其实也就是ebp-14h这个值，付给ecx，然后调用子类构造函数，为什么是ebp-14h呢，因为前面压入了三个双字变量，这里子类对象大小我们知道是父类大小+新增成员变量大小，为8，所以子类的对象的起始地址为ebp-14h（这里的14h，换成十进制，就是20）

图如下

44h的空间（填充了0xCC）

子类对象首地址 （ebp-14h） this （这里其实存放的是从父类继承的m_nBase）

子类对象首地址+4 （ebp-10h） this+4 (这里存储的是子类新增的m_nDerived) 红色的两个框，8个字节，就是子类对象

压入的第三个双字（ebp-C）

压入的第二个双字（ebp-8）

压入的第一个双字（ebp-4）

ebp

本图从下往上，是栈的增长方向。

我们看主函数这一句，0040109D lea ecx,[ebp-14h]，意思是把地址为ebp-14h处的单元的地址付给ecx，也就是ebp-14h付给ecx，ebp-14h是子类的首地址，连接往下四个字节，一共八个字节，是子类的总大小。

然后进入 004010A0 call @ILT+45(Derived::Derived) (00401032)

在子类的构造函数中我们可以看到，

00401239 pop ecx

0040123A mov dword ptr [ebp-4],ecx

0040123D mov ecx,dword ptr [ebp-4]

00401240 call @ILT+15(Base::Base) (00401014)

将传入的子类的首地址用ecx传入，在弹出，在保存在ebp-4h处，再传给ecx，并调用基类的构造函数。

我们这里的ecx，实际上存储的就是传说中的this指针了，也就是子类对象的首地址，通过传递这个地址，我们可以方便的对子类进行操作，比如对其成员变量进行赋值。

这一点算是分析完毕了，跳回去，我们接着分析子类构造函数。

看这句

00401240 call @ILT+15(Base::Base) (00401014)

这个意思是调用父类的构造函数，明显，此时ecx存储的还是子类传过来的地址

Base()

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]

00401289 pop ecx

0040128A mov dword ptr [ebp-4],ecx

19: {

20: printf("Base");

0040128D push offset string "Base" (00431020)

00401292 call printf (00408940)

00401297 add esp,4

21: }

这个就是我们在构造函数中调用的父类构造函数，可以看到这里面打印了一个字符串，并没有进行赋值什么的，如果进行赋值呢？比如Base构造函数里把从父类继承过来的m_nBase=2,这样应该会变为，mov [ecx],2

有兴趣的可以修改下源程序，然后看下这里的反汇编代码。

到这里，子类的构造函数就分析完了，我们接着分析

deriv.ShowNumber(5);

  void ShowNumber(int number)
41:      {
00401110   push        ebp
00401111   mov         ebp,esp
00401113   sub         esp,44h
00401116   push        ebx
00401117   push        esi
00401118   push        edi
00401119   push        ecx
0040111A   lea         edi,[ebp-44h]
0040111D   mov         ecx,11h
00401122   mov         eax,0CCCCCCCCh
00401127   rep stos    dword ptr [edi]
00401129   pop         ecx
0040112A   mov         dword ptr [ebp-4],ecx
42:        SetNumber(number);
0040112D   mov         eax,dword ptr [ebp+8]
00401130   push        eax
00401131   mov         ecx,dword ptr [ebp-4]
00401134   call        @ILT+10(Base::SetNumber) (0040100f)
43:        m_nDerived=number+1;
00401139   mov         ecx,dword ptr [ebp+8]
0040113C   add         ecx,1
0040113F  mov         edx,dword ptr [ebp-4]
00401142   mov         dword ptr [edx+4],ecx
44:        printf("%d",GetNumber());
00401145   mov         ecx,dword ptr [ebp-4]
00401148   call        @ILT+35(Base::GetNumber) (00401028)
0040114D   push        eax
0040114E   push        offset string "%d" (0043101c)
00401153   call        printf (00408940)
00401158   add         esp,8
45:       printf("%d",m_nDerived);
0040115B   mov         eax,dword ptr [ebp-4]
0040115E   mov         ecx,dword ptr [eax+4]
00401161   push        ecx
00401162   push        offset string "%d" (0043101c)
00401167   call        printf (00408940)
0040116C   add         esp,8
46:
47:     }

可以看到里面又调用了继承自父类的Setnumber函数，这里面还是用的ebp-14h进行传递，不多讲，SetNumber执行完后，ebp-14h这个地方，就变成了5，我们可以知道，这个双字，实际上是继承的父类的成员变量。

往下走，就是

 m_nDerived=number+1;
00401139   mov         ecx,dword ptr [ebp+8]
0040113C   add         ecx,1
0040113F  mov         edx,dword ptr [ebp-4]
00401142   mov         dword ptr [edx+4],ecx

这里可以看到，首先将形参自增1，变成6，然后

mov         edx,dword ptr [ebp-4]

将首地址付给edx寄存器，然后将6，付给了edx+4处的内存，edx+4处的内存是哪里?我们看图，就知道，是首地址往下四个字节，也就是ebp-10h，也就是this+4处，也就是子类新增的成员变量的位置。

后面就基本结束了。

反汇编确实是利器，剖开C++晦涩的语法糖，直窥本源。