C++继承分析

面向对象的三大特性之一就是继承，继承运行我么重用基类中已经存在的内容，这样就简化了代码的编写工作。继承中有三种继承方式即:public protected private，这三种方式规定了不同的访问权限，这些权限的检查由编译器在语法检查阶段进行，不参与生成最终的机器码，所以在这里不对这三中权限进行讨论，一下的内容都是采用的共有继承。

单继承

首先看下面的代码：

class CParent
{
public:
    CParent(){
        printf("CParent()\n");
    }
    ~CParent(){
        printf("~CParent()\n");
    }

    void setNumber(int n){
        m_nParent = n;
    }

    int getNumber(){
        return m_nParent;
    }

protected:
    int m_nParent;
};

class CChild : public CParent
{
public:
    void ShowNumber(int n){
        setNumber(n);
        m_nChild = 2 *m_nParent;
        printf("child:%d\n", m_nChild);
        printf("parent:%d\n", m_nParent);
    }
protected:
    int m_nChild;
};
int main()
{
    CChild cc;
    cc.ShowNumber(2);
    return 0;
}

上面的代码中定义了一个基类，以及一个对应的派生类，在派生类的函数中，调用和成员m_nParent，我们没有在派生类中定义这个变量，很明显这个变量来自于基类，子类会继承基类中的函数成员和数据成员，下面的汇编代码展示了它是如何存储以及如何调用函数的:

41:       CChild cc;
004012AD   lea         ecx,[ebp-14h];将类对象的首地址this放入ecx中
004012B0   call        @ILT+5(CChild::CChild) (0040100a);调用构造函数
004012B5   mov         dword ptr [ebp-4],0
42:       cc.ShowNumber(2);
004012BC   push        2
004012BE   lea         ecx,[ebp-14h]
004012C1   call        @ILT+10(CChild::ShowNumber) (0040100f);调用自身的函数
43:       return 0;
004012C6   mov         dword ptr [ebp-18h],0
004012CD   mov         dword ptr [ebp-4],0FFFFFFFFh
004012D4   lea         ecx,[ebp-14h]
004012D7   call        @ILT+25(CChild::~CChild) (0040101e);调用析构函数
004012DC   mov         eax,dword ptr [ebp-18h]
;构造函数
0040140A   mov         dword ptr [ebp-4],ecx
0040140D   mov         ecx,dword ptr [ebp-4];到此ecx和ebp - 4位置的值都是对象的首地址
00401410   call        @ILT+35(CParent::CParent) (00401028);调用父类的构造
00401415   mov         eax,dword ptr [ebp-4]
;ShowNumber函数
00401339   pop         ecx;还原this指针
0040133A   mov         dword ptr [ebp-4],ecx;ebp - 4存储的是this指针
31:           setNumber(n);
0040133D   mov         eax,dword ptr [ebp+8];ebp + 8是showNumber参数
00401340   push        eax
00401341   mov         ecx,dword ptr [ebp-4]
00401344   call        @ILT+0(CParent::setNumber) (00401005)
32:           m_nChild = 2 *m_nParent;
00401349   mov         ecx,dword ptr [ebp-4]
0040134C   mov         edx,dword ptr [ecx];取this对象的头4个字节的值到edx中
0040134E   shl         edx,1;edx左移1位，相当于edx = edx * 2
00401350   mov         eax,dword ptr [ebp-4]
00401353   mov         dword ptr [eax+4],edx ;将edx的值放入到对象的第4个字节处
33:           printf("child:%d\n", m_nChild);
00401356   mov         ecx,dword ptr [ebp-4]
00401359   mov         edx,dword ptr [ecx+4]
0040135C   push        edx
0040135D   push        offset string "child:%d\n" (0042f02c)
00401362   call        printf (00401c70)
00401367   add         esp,8
34:           printf("parent:%d\n", m_nParent);
0040136A   mov         eax,dword ptr [ebp-4]
0040136D   mov         ecx,dword ptr [eax]
0040136F   push        ecx
00401370   push        offset string "parent:%d\n" (0042f01c)
00401375   call        printf (00401c70)
0040137A   add         esp,8
;setNumber函数
16:           m_nParent = n;
004013CD   mov         eax,dword ptr [ebp-4]
004013D0   mov         ecx,dword ptr [ebp+8]
004013D3   mov         dword ptr [eax],ecx;给对象的头四个字节赋值

从上面的汇编代码可以看到大致的执行流程，首先调用编译器提供的默认构造函数，在这个构造函数中调用父类的构造函数，然后在showNumber中调用setNumber为父类的m_nParent赋值，然后为m_nChild赋值，最后执行输出语句。

上面的汇编代码在执行为m_nParent赋值时操作的内存地址是this，而为m_nChild赋值时操作的是this + 4通过这一点可以看出，类CChild在内存中的分布，首先在低地址位分步的是基类的成员，高地址为分步的是派生类的成员，我们随着代码的执行，查看寄存器和内存的值也发现，m_nParent在低地址位m_nChild在高地址位：



当父类中含有构造函数，而子类中没有时，编译器会提供默认构造函数，这个构造只调用父类的构造，而不做其他多余的操作，但是如果子类中构造，而父类中没有构造，则不会为父类提供默认构造。但是当父类中有虚函数时又例外，这个时候会为父类提供默认构造，以便初始化虚函数表指针。

在析构时，为了可以析构父类会首先调用子类的析构，当析构到父类的部分时，调用父类的构造，也就是说析构的调用顺序与构造正好相反。

子类在内存中的排列顺序为先依次摆放父类的成员，后安排子类的成员。

C++中的函数符号名称与C中的有很大的不同，编译器根据这个符号名称可以知道这个函数的形参列表，和作用范围，所以在继承的情况下，父类的成员函数的作用范围在父类中，而派生类则包含了父类的成员，所以自然包含了父类的作用范围，在进行函数调用时，会首先在其自身的范围中查找，然后再在其父类中查找，因此子类可以调用父类的函数。在子类中将父类的成员放到内存的前段是为了方便子类调用父类中的成员。但是当子类中有对应的函数，这个时候会直接调用子类中的函数，这个时候发生了覆盖。

当类中定义了其他类成员，并定义了初始化列表时，构造的顺序又是怎样的呢？

class CParent
{
public:
    CParent(){
        m_nParent = 0;
    }
protected:
    int m_nParent;
};
class CInit
{
public:
    CInit(){
        m_nNumber = 0;
    }
protected:
    int m_nNumber;
};
class CChild : public CParent
{
public:
    CChild(): m_nChild(1){}
protected:
    CInit m_Init;
    int m_nChild;
};

34:       CChild cc;
00401288   lea         ecx,[ebp-0Ch]
0040128B   call        @ILT+5(CChild::CChild) (0040100a)
;构造函数
004012C9   pop         ecx
004012CA   mov         dword ptr [ebp-4],ecx
004012CD   mov         ecx,dword ptr [ebp-4]
004012D0   call        @ILT+25(CParent::CParent) (0040101e);先调用父类的构造
004012D5   mov         ecx,dword ptr [ebp-4]
004012D8   add         ecx,4
004012DB   call        @ILT+0(CInit::CInit) (00401005);然后调用类成员的构造
004012E0   mov         eax,dword ptr [ebp-4]
004012E3   mov         dword ptr [eax+8],1;最后调用初始化列表中的操作
004012EA   mov         eax,dword ptr [ebp-4]

综上分析，编译器在对对象进行初始化时是根据各个部分在内存中的排放顺序来进行初始化的，就上面的例子来说，最上面的是基类的所以它首先调用的是基类的构造，然后是类的成员，所以接着调用成员对象的构造函数，最后是自身定义的变量，所以最后初始化自身的变量，但是初始化列表中的操作是先于类自身构造函数中的代码的。

由于父类的成员在内存中的分步是先于派生类自身的成员，所以通过派生类的指针可以很容易寻址到父类的成员，而且可以将派生类的指针转化为父类进行操作，并且不会出错，但是反过来将父类的指针转化为派生类来使用则会造成越界访问。

下面我们来看一下对于虚表指针的初始化问题，如果在基类中存在虚函数，而且在派生类中重写这个虚函数的话，编译器会如何初始化虚表指针。

class CParent
{
public:
    virtual void print(){
        printf("CParent()\n");
    }
};

class CChild : public CParent
{
public:
    virtual void print(){
        printf("CChild()\n");
    }
};

int main()
{
    CChild cc;
    return 0;
}

;函数地址
@ILT+0(?print@CParent@@UAEXXZ):
00401005   jmp         CParent::print
@ILT+10(?print@CChild@@UAEXXZ):
0040100F   jmp         CChild::print
;派生类构造函数
004012C9   pop         ecx
004012CA   mov         dword ptr [ebp-4],ecx
004012CD   mov         ecx,dword ptr [ebp-4]
004012D0   call        @ILT+30(CParent::CParent) (00401023)
004012D5   mov         eax,dword ptr [ebp-4]
004012D8   mov         dword ptr [eax],offset CChild::`vftable' (0042f01c)
004012DE   mov         eax,dword ptr [ebp-4]
;基类构造函数
00401379   pop         ecx
0040137A   mov         dword ptr [ebp-4],ecx
0040137D   mov         eax,dword ptr [ebp-4]
00401380   mov         dword ptr [eax],offset CParent::`vftable' (0042f02c)

上述代码的基本流程是首先执行基类的构造函数，在基类中首先初始化虚函数指针，从上面的汇编代码中可以看到，这个虚函数指针的值为0x0042f02c查看这块内存可以看到，它保存的值为0x00401005上面我们列出的虚函数地址可以看到，这个值正是基类中虚函数的地址。当基类的构造函数调用完成后，接着执行派生类的虚表指针的初始化，将它自身虚函数的地址存入到虚表中。

通过上面的分析可以知道，在派生类中如果重写了基类中的虚函数，那么在创建新的类对象时会有两次虚表指针的初始化操作，第一次是将基类的虚表指针赋值给对象，然后再将自身的虚表指针赋值给对象，将前一次的覆盖，如果是在基类的构造中调用虚函数，这个时候由于还没有生成派生类，所以会直接寻址，找到基类中的虚函数，这个时候不会构成多态，但是如果在派生类的构造函数中调用，这个时候已经初始化了虚表指针，会进行虚表的间接寻址调用派生类的虚函数构成多态。

析构函数与构造函数相反，在执行析构时，会首先将虚表指针赋值为当前类的虚表地址，调用当前类的虚函数，然后再将虚表指针赋值为其基类的虚表地址，执行基类的虚函数。

多重继承

多重继承的情况与单继承的情况类似，只是其父类变为多个，首先来分析多重继承的内存分布情况

class CParent1
{
public:
    virtual void fnc1(){
        printf("CParent1 fnc1\n");
    }

protected:
    int m_n1;
};

class CParent2
{
public:
    virtual void fnc2(){
        printf("CParent2 fnc2\n");
    }

protected:
    int m_n2;
};

class CChild : public CParent1, public CParent2
{
public:
    virtual void fnc1(){
        printf("CChild fnc1()\n");
    }

    virtual void fnc2(){
        printf("CChild fnc2()\n");
    }

protected:
    int m_n3;
};
int main()
{
    CChild cc;
    CParent1 *p = &cc;
    p->fnc1();
    CParent2 *p1 = &cc;
    p1->fnc2();
    p = NULL;
    p1 = NULL;
    return 0;
}

上述代码中，CChild类有两个基类，CParent1 CParent2 ，并且重写了这两个类中的函数：fnc1 fnc2，然后在主函数中分别将cc对象转化为它的两个基类的指针，通过指针调用虚函数，实现多态。下面是它的反汇编代码

43:       CChild cc;
004012A8   lea         ecx,[ebp-14h];对象的this指针
004012AB   call        @ILT+15(CChild::CChild) (00401014)
44:       CParent1 *p = &cc;
004012B0   lea         eax,[ebp-14h]
004012B3   mov         dword ptr [ebp-18h],eax;[ebp - 18h]是p的值
45:       p->fnc1();
004012B6   mov         ecx,dword ptr [ebp-18h]
004012B9   mov         edx,dword ptr [ecx];对象的头四个字节是虚函数表指针
004012BB   mov         esi,esp
004012BD   mov         ecx,dword ptr [ebp-18h]
004012C0   call        dword ptr [edx];通过虚函数地址调用虚函数
;部分代码略
46:       CParent2 *p1 = &cc;
004012C9   lea         eax,[ebp-14h];eax = this
004012CC   test        eax,eax
004012CE   je          main+48h (004012d8);校验this是否为空
004012D0   lea         ecx,[ebp-0Ch];this指针向下偏移8个字节
004012D3   mov         dword ptr [ebp-20h],ecx
004012D6   jmp         main+4Fh (004012df)
004012D8   mov         dword ptr [ebp-20h],0;如果this为null会将edx赋值为0
004012DF   mov         edx,dword ptr [ebp-20h];edx = this + 8
004012E2   mov         dword ptr [ebp-1Ch],edx;[ebp - 1CH]是p1的值
47:       p1->fnc2();
004012E5   mov         eax,dword ptr [ebp-1Ch]
004012E8   mov         edx,dword ptr [eax]
004012EA   mov         esi,esp
004012EC   mov         ecx,dword ptr [ebp-1Ch]
004012EF   call        dword ptr [edx]
004012F1   cmp         esi,esp
004012F3   call        __chkesp (00401680)
;CChild构造函数
0040135A   mov         dword ptr [ebp-4],ecx
0040135D   mov         ecx,dword ptr [ebp-4]
00401360   call        @ILT+40(CParent1::CParent1) (0040102d)
00401365   mov         ecx,dword ptr [ebp-4]
00401368   add         ecx,8;将指向对象首地址的指针向下偏移了8个字节
0040136B   call        @ILT+45(CParent2::CParent2) (00401032)
00401370   mov         eax,dword ptr [ebp-4]
00401373   mov         dword ptr [eax],offset CChild::`vftable' (0042f020)
00401379   mov         ecx,dword ptr [ebp-4]
0040137C   mov         dword ptr [ecx+8],offset CChild::`vftable' (0042f01c)
00401383   mov         eax,dword ptr [ebp-4]
;CParent1构造函数
00401469   pop         ecx
0040146A   mov         dword ptr [ebp-4],ecx
0040146D   mov         eax,dword ptr [ebp-4]
00401470   mov         dword ptr [eax],offset CParent1::`vftable' (0042f04c);初始化虚表指针
00401476   mov         eax,dword ptr [ebp-4]
;CParent2构造函数
004014F9   pop         ecx
004014FA   mov         dword ptr [ebp-4],ecx
004014FD   mov         eax,dword ptr [ebp-4]
00401500   mov         dword ptr [eax],offset CParent2::`vftable' (0042f064);初始化虚表指针
00401506   mov         eax,dword ptr [ebp-4]
;虚函数地址
@ILT+0(?fnc2@CChild@@UAEXXZ):
00401005   jmp         CChild::fnc2 (00401400)
@ILT+5(?fnc1@CParent1@@UAEXXZ):
0040100A   jmp         CParent1::fnc1 (00401490)
@ILT+10(?fnc1@CChild@@UAEXXZ):
0040100F   jmp         CChild::fnc1 (004013b0)
@ILT+20(?fnc2@CParent2@@UAEXXZ):
00401019   jmp         CParent2::fnc2 (00401520)

内存地址	存储的值
0012FF6C	20 F0 42 00
0012FF70	CC CC CC CC
0012FF74	1C F0 42 00
0012FF78	CC CC CC CC
0012FF7C	CC CC CC CC

从上面的汇编代码中可以看到，在为该类对象分配内存时，会根据继承的顺序，依次调用基类的构造函数，在构造函数中，与单继承类似，在各个基类的构造中，先将虚表指针初始化为各个基类的虚表地址，然后在调用完各个基类的构造函数后将虚表指针覆盖为对象自身的虚表地址，唯一不同的是，派生类有多个虚表指针，有几个派生类就有几个虚表指针。另外派生类的内存分布与单继承的分布情况相似，根据继承顺序从低地址到高地址依次摆放，最后是派生类自己定义的部分，每个基类都会在其自身所在位置的首地址处构建一个虚表。

在调用各自基类的构造函数时，并不是笼统的将对象的首地址传递给基类的构造函数，而是经过相应的地址偏移之后，将偏移后的地址传递给对应的构造。在转化为父类的指针时也是经过了相应的地址偏移。

在析构时首先析构自身，然后按照与构造相反的顺序调用基类的析构函数。

dynamic_cast强制类型转化与static_cast类型转化

根据上面的说明我们可以简单的画一张图：



这个对象中有三个虚表，分别位于各个基类所在内存的首地址处，如果我们利用多态的特性进行类型转化的话如果采用static_cast的方式会进行静态转化，也就是说它只是简单的将对象的首地址进行类型转化，这个时候如果调用CParent2的函数，在编译的时候不会报错，但是在运行时可能在虚表中（注意如果是这种情况它找到的虚表其实是CParent1的虚表）找不到想要的虚函数，这个时候调用会引起非法内存访问，造成程序崩溃。但是用dynamic_cast可以进行偏移地址的计算，自动偏移到CParent2内存部分的首地址，这个时候调用虚函数不会产生崩溃的问题。所以在有多重继承和多继承的时候尽量使用dynamic_cast进行类型转化。

抽象类

抽象类是不能实例化的类，只要有纯虚函数就是一个抽象类。纯虚函数是只有定义而没有实现的函数，由于虚函数的地址需要填入虚表，所以必须提供虚函数的定义，以便编译器能够将虚函数的地址放入虚表，所以虚函数必须定义，但是纯虚函数不一样，它不能定义。

class CParent
{
public:
    virtual show() = 0;
};

class CChild : public CParent
{
public:
    virtual show(){
        printf("CChild()\n");
    }
};

int main()
{
    CChild cc;
    CParent *p = &cc;
    p->show();
    return 0;
}

上面的代码定义了一个抽象类CParent，而CChild继承这个抽象类并实现了其中的纯虚函数，在主函数中通过基类的指针掉用虚函数，形成多态。

22:       CChild cc;
00401288   lea         ecx,[ebp-4]
0040128B   call        @ILT+0(CChild::CChild) (00401005)
23:       CParent *p = &cc;
00401290   lea         eax,[ebp-4]
00401293   mov         dword ptr [ebp-8],eax
24:       p->show();
00401296   mov         ecx,dword ptr [ebp-8]
00401299   mov         edx,dword ptr [ecx]
0040129B   mov         esi,esp
0040129D   mov         ecx,dword ptr [ebp-8]
004012A0   call        dword ptr [edx]
;CChild构造函数
004012F0   call        @ILT+25(CParent::CParent) (0040101e)
004012F5   mov         eax,dword ptr [ebp-4]
004012F8   mov         dword ptr [eax],offset CChild::`vftable' (0042f01c)
CParent构造函数
00401399   pop         ecx
0040139A   mov         dword ptr [ebp-4],ecx
0040139D   mov         eax,dword ptr [ebp-4]
004013A0   mov         dword ptr [eax],offset CParent::`vftable' (0042f02c)
004013A6   mov         eax,dword ptr [ebp-4]

构造函数中仍然是调用了基类的构造函数，并在基类的构造中对虚表指针进行了赋值，但是基类中并没有定义show函数，而是将它作为纯虚函数，那么虚表中存储的的是什么东西呢，这个位置存储的是一个_purecall函数，主要是为了防止误调纯虚函数。

菱形继承

菱形继承是最为复杂的一种继承方式，它结合了单继承和多继承

class CGrand
{
public:
    virtual void func1(){
        printf("CGrand func1()\n");
    }
protected:
    int m_nNum1;
}; 

class CParent1 : public CGrand
{
public:
    virtual void func2(){
        printf("CParent1 func2()\n");
    }

    virtual void func3(){
        printf("CParent1 func3()\n");
    }
protected:
    int m_nNum2;
};

class CParent2 : public CGrand
{
public:
    virtual void func4(){
        printf("CParent2 func4()\n");
    }

    virtual void func5(){
        printf("CParent2 func5()\n");
    }
protected:
    int m_nNum3;
};

class CChild : public CParent1, public CParent2
{
public:
    virtual void func2(){
        printf("CChild func2()\n");
    }

    virtual void func4(){
        printf("CChild func4()\n");
    }

protected:
    int m_nNum4;
};

int main()
{
    CChild cc;
    CParent1 *p1 = &cc;
    CParent2 *p2 = &cc;
    return 0;
}

上面的代码中有4个类，其中CGrand类为祖父类，而CParent1 CParent2为父类，他们都派生自组父类，而子类继承与CParent1 CParent2，根据前面的经验可以知道sizeof(CGrand) = 4(vt) + 4(int) = 8，而sizeof(CParent1) = sizeof(CParent2) = sizeof(CGrand) + 4(int) = 12， sizeof(CChild) = sizeof(CParent1) + sizeof(CParent2) + 4(int) = 28;

大致可以知道CChild对象的内存分布是CParent1 CParent2 int这种情况，通过反汇编的方式我们可以看出对象的内存分布如下：



内存的分步来看，CParent1 CParent2都继承自CGrand类，所以他们都有CGrand类的成员，而CChild类继承自两个类，所以CGrand类的成员在CChild类中有两份，所以在调用m_nNum1成员时会产生二义性，编译器不知道你准备调用那个m_nNum1成员，所以一般这个时候需要指定调用的是哪个部分的m_nNum1成员。同时在转化为祖父类的时候也会产生二义性。而虚继承可以有效的解决这个问题。一般来说虚继承可以有效的避免二义性是因为重复的内容在对象中只有一份。下面对上述例子进行相应的修改，为每个类添加构造函数构造初始化这些成员变量：m_nNum1 = 1；m_nNum2 = 2； m_nNum3 = 3； m_nNum4 = 4；

另外再为CParent1 CParent2类添加虚继承。这个时候我们运行程序输入类CChild的大小：sizeof(CChild) = 36；按照之前所说的同样的内容只保留的一份，那内存大小应该会减少才对，为何突然增大了8个字节呢，下面来看看对象在内存中的分步：

0012FF5C 30 F0 42 00

0012FF60 48 F0 42 00

0012FF64 02 00 00 00

0012FF68 24 F0 42 00

0012FF6C 3C F0 42 00

0012FF70 03 00 00 00

0012FF74 04 00 00 00

0012FF78 20 F0 42 00

0012FF7C 01 00 00 00

上述内存的分步与我们之前想象的有很大的不同，所有变量的确只有一份，但是总内存大小还是变大了，同时它的存储顺序也不是按照我们之前所说的父类的排在子类的前面，而且还多了一些我们并不了解的数据

下面通过反汇编代码来说明这些数值的作用：

;主函数部分
73:       CChild cc;
004012D8   push        1;是否构造祖父类1表示构造，0表示不构造
004012DA   lea         ecx,[ebp-24h]
004012DD   call        @ILT+5(CChild::CChild) (0040100a)
74:       printf("%d\n", sizeof(cc));
004012E2   push        24h
004012E4   push        offset string "%d\n" (0042f01c)
004012E9   call        printf (00401a70)
004012EE   add         esp,8
75:       CParent1 *p1 = &cc;
004012F1   lea         eax,[ebp-24h]
004012F4   mov         dword ptr [ebp-28h],eax
76:       CParent2 *p2 = &cc;
004012F7   lea         ecx,[ebp-24h]
004012FA   test        ecx,ecx
004012FC   je          main+46h (00401306)
004012FE   lea         edx,[ebp-18h]
00401301   mov         dword ptr [ebp-34h],edx
00401304   jmp         main+4Dh (0040130d)
00401306   mov         dword ptr [ebp-34h],0
0040130D   mov         eax,dword ptr [ebp-34h]
00401310   mov         dword ptr [ebp-2Ch],eax
77:       CGrand *p3 = &cc;
00401313   lea         ecx,[ebp-24h]
00401316   test        ecx,ecx;this指针不为空
00401318   jne         main+63h (00401323);不为空则跳转
0040131A   mov         dword ptr [ebp-38h],0
00401321   jmp         main+70h (00401330)
00401323   mov         edx,dword ptr [ebp-20h];edx = 0x0040f048
00401326   mov         eax,dword ptr [edx+4];eax = 0x18这个可以通过查看内存获得
00401329   lea         ecx,[ebp+eax-20h]; ebp + eax - 20h = 0x0012ff78, ecx = 0x0012FF78
0040132D   mov         dword ptr [ebp-38h],ecx;经过偏移后获得这个地址
00401330   mov         edx,dword ptr [ebp-38h]
00401333   mov         dword ptr [ebp-30h],edx
;CChild构造
0040135A   mov         dword ptr [ebp-4],ecx
0040135D   cmp         dword ptr [ebp+8],0
00401361   je          CChild::CChild+42h (00401382)
00401363   mov         eax,dword ptr [ebp-4]
00401366   mov         dword ptr [eax+4],offset CChild::`vbtable' (0042f048)
0040136D   mov         ecx,dword ptr [ebp-4]
00401370   mov         dword ptr [ecx+10h],offset CChild::`vbtable' (0042f03c)
00401377   mov         ecx,dword ptr [ebp-4]
0040137A   add         ecx,1Ch
0040137D   call        @ILT+0(CGrand::CGrand) (00401005);this 指针向下偏移1ch，开始构造父类
00401382   push        0;保证父类只构造一次
00401384   mov         ecx,dword ptr [ebp-4]
00401387   call        @ILT+60(CParent1::CParent1) (00401041)
0040138C   push        0
0040138E   mov         ecx,dword ptr [ebp-4]
00401391   add         ecx,0Ch
00401394   call        @ILT+65(CParent2::CParent2) (00401046)
00401399   mov         edx,dword ptr [ebp-4]
0040139C   mov         dword ptr [edx],offset CChild::`vftable' (0042f030)
004013A2   mov         eax,dword ptr [ebp-4]
004013A5   mov         dword ptr [eax+0Ch],offset CChild::`vftable' (0042f024)
004013AC   mov         ecx,dword ptr [ebp-4]
004013AF   mov         edx,dword ptr [ecx+4]
004013B2   mov         eax,dword ptr [edx+4]
004013B5   mov         ecx,dword ptr [ebp-4]
004013B8   mov         dword ptr [ecx+eax+4],offset CChild::`vftable' (0042f020)
57:           m_nNum4 = 4;
004013C0   mov         edx,dword ptr [ebp-4]
004013C3   mov         dword ptr [edx+18h],4
58:       }
;CGrand构造
00401429   pop         ecx
0040142A   mov         dword ptr [ebp-4],ecx
0040142D   mov         eax,dword ptr [ebp-4]
00401430   mov         dword ptr [eax],offset CGrand::`vftable' (0042f054);虚表指针后期会被替代
10:           m_nNum1 = 1;
00401436   mov         ecx,dword ptr [ebp-4]
00401439   mov         dword ptr [ecx+4],1
11:       }
;CParent1构造
04014C9   pop         ecx
004014CA   mov         dword ptr [ebp-4],ecx
004014CD   cmp         dword ptr [ebp+8],0;不再调用祖父类构造
004014D1   je          CParent1::CParent1+38h (004014e8)
004014D3   mov         eax,dword ptr [ebp-4]
004014D6   mov         dword ptr [eax+4],offset CParent1::`vbtable' (0042f07c)
004014DD   mov         ecx,dword ptr [ebp-4]
004014E0   add         ecx,0Ch
004014E3   call        @ILT+0(CGrand::CGrand) (00401005);这个时候会跳过这个构造函数的调用

通过上面的代码可以看出，为了使得相同的内容只有一份，在程序中额外传入一个参数作为标记，用于表示是否调用祖父类构造函数，当初始化完祖父类后将此标记置0以后不再初始化，另外程序在每个父类中都多添加了一个四字节的成员用来存储一个一个偏移地址，以便能正确的将派生类转化为父类。所以每当多出一个虚继承就多了一个记录偏移量的4字节内存，所以这个类总共多出了8个字节。所以这时候的类所占内存大小为28 + 4 * 2 = 36字节。