C++ 继承分析

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

单继承

首先看下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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,我们没有在派生类中定义这个变量,很明显这个变量来自于基类,子类会继承基类中的函数成员和数据成员,下面的汇编代码展示了它是如何存储以及如何调用函数的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
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中的有很大的不同,编译器根据这个符号名称可以知道这个函数的形参列表,和作用范围,所以在继承的情况下,父类的成员函数的作用范围在父类中,而派生类则包含了父类的成员,所以自然包含了父类的作用范围,在进行函数调用时,会首先在其自身的范围中查找,然后再在其父类中查找,因此子类可以调用父类的函数。在子类中将父类的成员放到内存的前段是为了方便子类调用父类中的成员。但是当子类中有对应的函数,这个时候会直接调用子类中的函数,这个时候发生了覆盖。
当类中定义了其他类成员,并定义了初始化列表时,构造的顺序又是怎样的呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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]

综上分析,编译器在对对象进行初始化时是根据各个部分在内存中的排放顺序来进行初始化的,就上面的例子来说,最上面的是基类的所以它首先调用的是基类的构造,然后是类的成员,所以接着调用成员对象的构造函数,最后是自身定义的变量,所以最后初始化自身的变量,但是初始化列表中的操作是先于类自身构造函数中的代码的。
由于父类的成员在内存中的分步是先于派生类自身的成员,所以通过派生类的指针可以很容易寻址到父类的成员,而且可以将派生类的指针转化为父类进行操作,并且不会出错,但是反过来将父类的指针转化为派生类来使用则会造成越界访问。
下面我们来看一下对于虚表指针的初始化问题,如果在基类中存在虚函数,而且在派生类中重写这个虚函数的话,编译器会如何初始化虚表指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
;函数地址
@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上面我们列出的虚函数地址可以看到,这个值正是基类中虚函数的地址。当基类的构造函数调用完成后,接着执行派生类的虚表指针的初始化,将它自身虚函数的地址存入到虚表中。
通过上面的分析可以知道,在派生类中如果重写了基类中的虚函数,那么在创建新的类对象时会有两次虚表指针的初始化操作,第一次是将基类的虚表指针赋值给对象,然后再将自身的虚表指针赋值给对象,将前一次的覆盖,如果是在基类的构造中调用虚函数,这个时候由于还没有生成派生类,所以会直接寻址,找到基类中的虚函数,这个时候不会构成多态,但是如果在派生类的构造函数中调用,这个时候已经初始化了虚表指针,会进行虚表的间接寻址调用派生类的虚函数构成多态。
析构函数与构造函数相反,在执行析构时,会首先将虚表指针赋值为当前类的虚表地址,调用当前类的虚函数,然后再将虚表指针赋值为其基类的虚表地址,执行基类的虚函数。

多重继承

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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对象转化为它的两个基类的指针,通过指针调用虚函数,实现多态。下面是它的反汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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进行类型转化。

抽象类

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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继承这个抽象类并实现了其中的纯虚函数,在主函数中通过基类的指针掉用虚函数,形成多态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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函数,主要是为了防止误调纯虚函数。

菱形继承

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
上述内存的分步与我们之前想象的有很大的不同,所有变量的确只有一份,但是总内存大小还是变大了,同时它的存储顺序也不是按照我们之前所说的父类的排在子类的前面,而且还多了一些我们并不了解的数据
下面通过反汇编代码来说明这些数值的作用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
;主函数部分
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字节。