C++虚函数探索笔记（2）——虚函数与多继承

C++虚函数探索笔记（2）——虚函数与多继承
2009年7月30日 kunlun 发表评论阅读评论
链接：
关注问题：
- 虚函数的作用
- 虚函数的实现原理
- 虚函数表在对象布局里的位置
- 虚函数的类的sizeof
- 纯虚函数的作用
- 多级继承时的虚函数表内容
- 虚函数如何执行父类代码
- 多继承时的虚函数表定位，以及对象布局
- 虚析构函数的作用
- 虚函数在QT的信号与槽中的应用
- 虚函数与inline修饰符，static修饰符
前面我们尝试了一个简单的例子，接下来尝试一个多级继承的例子，以及一个多继承的例子。主要涉及到以下问题：多级继承时虚函数表的内容是如何填写的，如何在多级继承的情况下调用某一级父类里的虚函数，以及在多继承（多个父类）的情况下的对象布局。
多级继承

在这里，多级继承指的是有3层或者多层继承关系的情形。让我们看看下面的代码：
多层继承代码示例
1. ```
//Source filename: Win32Con.cpp
```
3. ```
 #include <iostream>
```
4. ```
 using namespace std;
```
5. ```
class parent1
```
6. ```
 {
```
7. ```
public:
```
8. ```
    virtual int fun1(){cout<<"parent1::fun1()"<<endl;return 0;};
```
9. ```
    virtual int fun2()=0;
```
10. ```
};
```
11. ```
class child1:public parent1
```
12. ```
 {
```
13. ```
public:
```
15. ```
    virtual int fun1()
```
16. ```
    {
```
17. ```
        cout<<"child1::fun1()"<<endl;
```
18. ```
        parent1::fun1();
```
19. ```
        return 0;
```
20. ```
    }
```
21. ```
    virtual int fun2()
```
22. ```
    {
```
23. ```
        cout<<"child1::fun2()"<<endl;
```
24. ```
        return 0;
```
25. ```
    }
```
26. ```
};
```
28. ```
class grandson:public child1
```
29. ```
 {
```
30. ```
public:
```
31. ```
    virtual int fun2()
```
32. ```
    {
```
33. ```
        cout<<"grandson::fun2()"<<endl;
```
34. ```
        //parent1::fun2();
```
35. ```
        parent1::fun1();
```
36. ```
        child1::fun2();
```
37. ```
        return 0;
```
38. ```
    }
```
39. ```
};
```
41. ```
void test_func1(parent1 *pp)
```
42. ```
{
```
43. ```
    pp->fun1();
```
44. ```
    pp->fun2();
```
45. ```
}
```
47. ```
int main(int argc, char* argv[])
```
48. ```
{
```
49. ```
    grandson sunzi;
```
50. ```
    test_func1(&sunzi);
```
51. ```
    return 0;
```
52. ```
}
```
这段代码展示了三个class，分别是parent1,child1,grandson。
- 类parent1定义了两个虚函数，其中fun2是一个纯虚函数，这个类是一个不可实例化的抽象基类。
- 类child1继承了parent1，并且对两个虚函数fun1和fun2都编写了实现的代码，这个类可以被实例化。
- 类grandson继承了child1，但是只对虚函数fun2编写了实现的代码。
此外，我们还改写了test_func1函数，它的参数为parent1类型的指针，我们可以将parent1的子孙类作为这个函数的参数传入。在这个函数里，我们将依次调用parent1类的两个虚函数。
可以先通过阅读代码预测一下程序的输出内容。
程序的输出内容将是：
```
child1::fun1()
parent1::fun1()
grandson::fun2()
parent1::fun1()
child1::fun2()
```
先看第一行输出child1::fun1()，为什么会输出它呢？我们定义的具体对象sunzi是grandson类型的，test_func1的参数类型是parent1类型。在调用这个虚函数的时候，是完成了一次怎样的调用过程呢？
让我们再次使用cl命令输出这几个类的对象布局:
```
class parent1   size(4):
        +---
 0      | {vfptr}
        +---

parent1::$vftable@:
        | &parent1_meta
        |  0
 0      | &parent1::fun1
 1      | &parent1::fun2

parent1::fun1 this adjustor: 0
parent1::fun2 this adjustor: 0

class child1    size(4):
        +---
        | +--- (base class parent1)
 0      | | {vfptr}
        | +---
        +---

child1::$vftable@:
        | &child1_meta
        |  0
 0      | &child1::fun1
 1      | &child1::fun2

child1::fun1 this adjustor: 0
child1::fun2 this adjustor: 0

class grandson  size(4): //grandson的对象布局
        +---
        | +--- (base class child1)
        | | +--- (base class parent1)
 0      | | | {vfptr}
        | | +---
        | +---
        +---

grandson::$vftable@:  //grandson虚函数表的内容
        | &grandson_meta
        |  0
 0      | &child1::fun1
 1      | &grandson::fun2

grandson::fun2 this adjustor: 0
```
因为我们实例化的是一个grandson对象，让我们看看它的对象布局。正如前面的例子一样，里面只有一个vfptr指针，但是不一样的却是这个指针所指的虚函数表的内容：
第一个虚函数，填写的是child1类的fun1的地址；第二个虚函数填写的才是grandson类的fun2的地址。
很显然我们可以得出这样一个结论：在一个子对象的虚函数表里，每一个虚函数的实际运行的函数地址，将填写为在继承体系里最后实现该虚函数的函数地址。
所以当我们在test_func1里调用了传入的parent1指针的fun1函数的时候，我们实际执行的是填写在虚函数表里的 child1::fun1()，而调用fun2函数的时候，是从虚函数表里得到了grandson::fun2函数的地址并调用之。在“程序输出结果”表里的第一行和第三行结果证实了上述结论。
再看一下程序代码部分的child1::fun1()的实现代码，在第18行，我们有parent1::fun1();这样的语句，这行代码输出了运行结果里的第二行，而在grandson::fun2()的实现代码第35行的parent1::fun1();以及第36行的child1::fun2();则输出了运行结果里的第四行和第五行的内容。这三行代码展示了如何调用父类以及更高的祖先类里的虚函数。——事实上，这与调用父类的普通函数没有任何区别。
在程序代码的第34行，有一行被注释了的内容//parent1::fun2();，之所以会注释掉，是因为这样的代码是无法通过编译的，因为在parent1类里，fun2是一个“纯虚函数”也就是说这个函数没有代码实体，在编译的时候，链接器将无法找到fun2的目标代码从而报错。
其实有了对虚函数的正确的认识，上面的多级继承是很自然就能明白的。然而在多继承的情况下，情况就有所不同了。。。
多继承下虚函数的使用

假如一个类，它由多个父类继承而来，而在不同的父类的继承体系里，都存在虚函数的时候，这个类的对象布局又会是怎样的？它又是怎样定位虚函数的呢？
让我们看看下面的代码：
程序输出结果
1. ```
//Source filename: Win32Con.cpp
```
2. ```
 #include <iostream>
```
3. ```
 using namespace std;
```
4. ```
class parent1
```
5. ```
 {
```
6. ```
public:
```
7. ```
    virtual int fun1(){cout<<"parent1::fun1()"<<endl;return 0;};
```
8. ```
};
```
9. ```
class parent2
```
10. ```
 {
```
11. ```
public:
```
12. ```
    virtual int fun2(){cout<<"parent2::fun2()"<<endl;return 0;};
```
13. ```
};
```
14. ```
class child1:public parent1,public parent2
```
15. ```
 {
```
16. ```
public:
```
17. ```
    virtual int fun1()
```
18. ```
    {
```
19. ```
        cout<<"child1::fun1()"<<endl;
```
20. ```
        return 0;
```
21. ```
    }
```
22. ```
    virtual int fun2()
```
23. ```
    {
```
24. ```
        cout<<"child1::fun2()"<<endl;
```
25. ```
        return 0;
```
26. ```
    }
```
27. ```
};
```
28. ```
void test_func1(parent1 *pp)
```
29. ```
{
```
30. ```
    pp->fun1();
```
31. ```
}
```
32. ```
void test_func2(parent2 *pp)
```
33. ```
{
```
34. ```
    pp->fun2();
```
35. ```
}
```
36. ```
int main(int argc, char* argv[])
```
37. ```
{
```
38. ```
    child1 chobj;
```
39. ```
    test_func1(&chobj);
```
40. ```
    test_func2(&chobj);
```
41. ```
    return 0;
```
42. ```
}
```
这一次，我们有两个父类，parent1和parent2，在parent1里定义了虚函数fun1，而在parent2里定义了虚函数fun2，然后我们有一个子类child1，在里面重新实现了fun1和 fun2两个虚函数。然后我们编写了test_func1函数来调用parent1类型对象的fun1函数，编写了test_func2函数调用 parent2对象的fun2函数。在main函数里我们实例化了一个child1类型的对象chobj，然后分别传给test_func1和 test_func2去执行。
这段代码的运行结果非常简单就能看出来：
child1::fun1()
child1::fun2()
但是，让我们看看对象布局吧：
```
class child1    size(8):
        +---
        | +--- (base class parent1)
 0      | | {vfptr}
        | +---
        | +--- (base class parent2)
 4      | | {vfptr}
        | +---
        +---

child1::$vftable@parent1@:
        | &child1_meta
        |  0
 0      | &child1::fun1

child1::$vftable@parent2@:
        | -4
 0      | &child1::fun2

child1::fun1 this adjustor: 0
child1::fun2 this adjustor: 4
```
注意到没？在child1的对象布局里，出现了两个vfptr指针！
这两个虚函数表指针分别继承于parent1和parent2类，分别指向了不同的两个虚函数表。
问题来了，当我们使用test_func1调用parent1类的fun1函数的时候，调用个过程还比较好理解，可以从传入的地址参数取得继承自 parent1的vfptr，从而执行正确的fun1函数代码，但是当我们调用test_func2函数的时候，为什么程序可以自动取得来自 parent2的vfptr呢，从而得出正确的fun2函数的地址呢？
其实，这个工作是编译器自动根据实例的类型完成的，在编译阶段就已经确定了在调用test_func2的时候，传入的this指针需要增加一定的偏移（在这里则是第一个vfptr所占用的大小，也就是4字节）。
我们可以看看main函数里这部分代码的反汇编代码：
反汇编代码
1. ```
    child1 chobj;
```
2. ```
00F5162E 8D 4D F4         lea         ecx,[chobj] 
```
3. ```
00F51631 E8 F5 FB FF FF   call        child1::child1 (0F5122Bh) 
```
4. ```
    test_func1(&chobj);
```
5. ```
00F51636 8D 45 F4         lea         eax,[chobj] 
```
6. ```
00F51639 50               push        eax  
```
7. ```
00F5163A E8 6F FB FF FF   call        test_func1 (0F511AEh) 
```
8. ```
00F5163F 83 C4 04         add         esp,4 
```
9. ```
    test_func2(&chobj);
```
10. ```
00F51642 8D 45 F4         lea         eax,[chobj] 
```
11. ```
00F51645 85 C0            test        eax,eax 
```
12. ```
00F51647 74 0E            je          main+47h (0F51657h) 
```
13. ```
00F51649 8D 4D F4         lea         ecx,[chobj] 
```
14. ```
00F5164C 83 C1 04         add         ecx,4 
```
15. ```
00F5164F 89 8D 2C FF FF FF mov         dword ptr [ebp-0D4h],ecx 
```
16. ```
00F51655 EB 0A            jmp         main+51h (0F51661h) 
```
17. ```
00F51657 C7 85 2C FF FF FF 00 00 00 00 mov         dword ptr [ebp-0D4h],0 
```
18. ```
00F51661 8B 95 2C FF FF FF mov         edx,dword ptr [ebp-0D4h] 
```
19. ```
00F51667 52               push        edx  
```
20. ```
00F51668 E8 F6 FA FF FF   call        test_func2 (0F51163h) 
```
21. ```
00F5166D 83 C4 04         add         esp,4 
```
22. ```
    return 0;
```
从第4行至第5行，执行的是test_func1函数，this指针指向 chobj （第2行lea ecx,[chobj]），但是调用test_func2函数的时候，this指针被增加了4（第14行）！于是，在test_func2执行的时候，就可以从&chobj+4的地方获得vfptr指针，从而根据parent2的对象布局得到了fun2的地址并执行了。
为了证实这点，我们可以将代码做如下的修改：
```
1:  int main(int argc, char* argv[])
```
```
2:  {
```
```
3:      child1 chobj;
```
```
4:      test_func1(&chobj);
```
```
5:      test_func2((parent2 *)(void *)&chobj);
```
```
6:      return 0;
```
```
7:  }
```
```
8:  
```
请注意红色部分的变化，在讲chobj传入给test_func2之前，先用(void *)强制转换为无类型指针，再转换为parent2 指针，这样的转换，显然是可行的，因为chobj本身就是parent2的子类，然而，程序的执行效果却是：
child1::fun1()
child1::fun1()
执行test_func2函数，调用的是parent2::fun2，但是居然执行的是child1::fun1()函数！！！
这中间发生了些什么呢？我们再看看反汇编的代码：
反汇编的代码
1. ```
    child1 chobj;
```
2. ```
013D162E 8D 4D F4         lea         ecx,[chobj] 
```
3. ```
013D1631 E8 F5 FB FF FF   call        child1::child1 (13D122Bh) 
```
4. ```
    test_func1(&chobj);
```
5. ```
013D1636 8D 45 F4         lea         eax,[chobj] 
```
6. ```
013D1639 50               push        eax  
```
7. ```
013D163A E8 6F FB FF FF   call        test_func1 (13D11AEh) 
```
8. ```
013D163F 83 C4 04         add         esp,4 
```
9. ```
    test_func2((parent2*)(void *)&chobj);
```
10. ```
013D1642 8D 45 F4         lea         eax,[chobj] 
```
11. ```
013D1645 50               push        eax  
```
12. ```
013D1646 E8 18 FB FF FF   call        test_func2 (13D1163h) 
```
13. ```
013D164B 83 C4 04         add         esp,4 
```
14. ```
    return 0;
```
从调用test_func2的反汇编代码可以看到，这一次ecx寄存器的值没有做改变！所以在执行test_func2的时候，将取得 parent1对象布局里的vfptr，而这个vfptr所指的虚函数表里的第一项就是fun1，并且被填写为child1::fun1的地址了。所以才出现了child::fun1的输出内容！显然这里有一个隐藏的致命问题，加入parent1和parent2的第一个虚函数的参数列表不一致，这样的调用显然就会导致堆栈被破坏掉，程序99%会立即崩溃。之前的程序没有崩溃并且成功输出内容，不过是因为parent1::fun1()和 parent2::fun2()的参数列表一致的关系而已。
所以，千万不要在使用一个多继承对象的时候，将其类型信息丢弃，编译器还需要依靠正确的类型信息，在使用虚函数的时候来得到正确的汇编代码！
多继承与虚函数重复

既然说到了多继承，那么还有一个问题可能会需要解决，那就是如果两个父类里都有相同的虚函数定义，在子对象的布局里会是怎么样个情况？是否依然可以将这个虚函数指向到正确的实现代码上呢？
修改前面一个源代码，在parent2的接口里增加下面的虚函数定义：
```
virtual int fun1(){cout<<"parent2::fun1()"<<endl;return 0;};
```
上面的fun1的定义与parent1类里的完全重复相同（类型，参数列表），增加上面的代码后立即开始编译，程序正常编译通过。运行之，得到下面的结果：
child1::fun1()
child1::fun2()
这个程序居然正确的完成了执行，编译器在其中做了些怎样的工作，是怎么样避免掉队fun1函数的冲突问题呢？
让我们来看看这个时候的child1的对象布局：
```
class child1    size(8):
        +---
        | +--- (base class parent1)
 0      | | {vfptr}
        | +---
        | +--- (base class parent2)
 4      | | {vfptr}
        | +---
        +---

child1::$vftable@parent1@:
        | &child1_meta
        |  0
 0      | &child1::fun1

child1::$vftable@parent2@:
        | -4
 0      | &child1::fun2
 1      | &thunk: this-=4; goto child1::fun1

child1::fun1 this adjustor: 0
child1::fun2 this adjustor: 4
```
恩~~~还是两个vfptr在child1的对象布局里（不一样就怪啦，呵呵），但是第二个vfptr所指的虚函数表的内容有所变化哦！
注意看红色字体部分，虚函数表里并没有直接填写child::fun1的代码，而是多了一个 &thunk: this-=4;然后才goto child1::fun1！注意到一个关键名词thunk了吧？没错，vc在这里使用了名为thunk的技术，避免了虚函数fun1在两个基类里重复出现导致的冲突问题！（除了thunk，还有其他方法可以解决此类问题的）。
现在，我们知道为什么相同的虚函数不会在子类里出现冲突的情况了。
但是，倘若我们在基类里就是由两个冲突的普通函数，而不是虚函数，是个怎样的情况呢？
多继承产生的冲突与虚继承，虚基类

我们在parent1和parent2里添加一个相同的函数void fun3()，然后再进行编译，通过了！查看类对象布局，跟上面的完全一致。但是在main函数里调用chobj.fun3()的时候，编译器却不再能正确编译了，并且会提示“error C2385: 对“fun3”的访问不明确”的错误信息，没错，编译器不知道你要访问哪个fun3了。
如何解决这样的多继承带来的问题呢，其实有一个简单的做法。就是在方法前限定引用的具体是哪个类的函数，比如：chobj.parent1::fun3(); ，这样的写法就写明了是要调用chobj的父类parent1里的fun3()函数！
我们再看看另外一种情况，从parent1和parent2里抹去刚才添加的fun3函数，将之放到一个共同的基类里：
```
class commonbase
```
```
 {
```
```
public:
```
```
    void fun3(){cout<<"commonbase::fun3()"<<endl;}
```
```
};
```
而parent1和parent2都修改为从此类继承。可以看到，在这个情况下，依然需要使用chobj.parent1::fun3(); 的方式才可以正确调用到fun3，难道，在这种情况下，就不能自然的使用chobj.fun3()这样的方式了吗？
虚继承可以解决这个问题——我们在parent1和parent2继承common类的地方添加上一个关键词virtual，如下：
```
class parent1:virtual public commonbase
```
```
 {
```
```
public:
```
```
    virtual int fun1(){cout<<"parent1::fun1()"<<endl;return 0;};
```
```
};
```
给parent2也同样的处理，然后再次编译，这次chobj.fun3()可以编译通过了！！！
编译器这次又在私下里做了哪些工作了呢？？？？
```
class child1    size(16):
        +---
        | +--- (base class parent1)
 0      | | {vfptr}
 4      | | {vbptr}
        | +---
        | +--- (base class parent2)
 8      | | {vfptr}
12      | | {vbptr}
        | +---
        +---
        +--- (virtual base commonbase)
        +---

child1::$vftable@parent1@:
        | &child1_meta
        |  0
 0      | &child1::fun1

child1::$vftable@parent2@:
        | -8
 0      | &child1::fun2
 1      | &thunk: this-=8; goto child1::fun1

child1::$vbtable@parent1@:
 0      | -4
 1      | 12 (child1d(parent1+4)commonbase)

child1::$vbtable@parent2@:
 0      | -4
 1      | 4 (child1d(parent2+4)commonbase)

child1::fun1 this adjustor: 0
child1::fun2 this adjustor: 8

vbi:       class  offset o.vbptr  o.vbte fVtorDisp
      commonbase      16       4       4 0
```
这次变化可大了去了！！！
首先，可以看到两个类parent1和parent2的对象布局里，都多了一个vbptr的指针。而在child1的对象布局里，还有一个virtual base commonbase的虚拟基类。再看看两个vbptr的内容：
12 (child1d(parent1+4)commonbase) 这个很好理解，从parent1的vbptr开始，偏移12个字节，指向的是virtual base commonbase！
再看看4 (child1d(parent2+4)commonbase) ，从parent2的vbptr开始，便宜4个字节，也指向了virtual base commonbase！
这下明白了。虚基类在child1里只有一个共同的对象布局了，所以就可以直接用chobj.fun3()啦，当然，在commonbase里的其他成员变量此时也可以同样的方式访问了！
虽然解决方案有了，但是在一个系统的设计里，如果有一个基类出现多继承冲突的情况，大部分情况下都说明这样的设计是有问题的，应该尽量避免这样的设计，并且尽量用纯虚函数，来提取一些抽象的接口类，把共同的方法接口都抽取出来，通常就能避免多继承的问题。
相关阅读:
事务处理多数据库的方法
 微信定位js
linux命令大全
 git团队协作
 springboot入门的一点基础
 Spring Boot Actutaur + Telegraf + InFluxDB + Grafana 构建监控平台
 Hadoop+HBase+ZooKeeper三者关系与安装配置
 Centos7网络配置-转载
 【Java EE 学习 21 下】【使用易宝支付接口实现java网上支付功能】
linux 中 iptables关于ping的问题
原文地址：https://www.cnblogs.com/dongzhiquan/p/2091790.html

C++虚函数探索笔记（2）——虚函数与多继承

多级继承

多继承下虚函数的使用

多继承与虚函数重复

多继承产生的冲突与虚继承，虚基类