当前位置: 开发笔记 > 编程语言 > 正文

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

作者：xin新的 | 来源：互联网 | 2023-09-24 13:28

链接：C++虚函数探索笔记（1）——虚函数的简单示例分析C++虚函数探索笔记（2）——虚函数与多继承C++虚函数探索笔记（3）——延伸思考：虚函数应用的一些其他情形关注

链接：

C++虚函数探索笔记（1）——虚函数的简单示例分析
C++虚函数探索笔记（2）——虚函数与多继承
C++虚函数探索笔记（3）——延伸思考：虚函数应用的一些其他情形

关注问题：

虚函数的作用
虚函数的实现原理
虚函数表在对象布局里的位置
虚函数的类的sizeof
纯虚函数的作用
多级继承时的虚函数表内容
虚函数如何执行父类代码
多继承时的虚函数表定位，以及对象布局
虚析构函数的作用
虚函数在QT的信号与槽中的应用
虚函数与inline修饰符，static修饰符

前面我们尝试了一个简单的例子，接下来尝试一个多级继承的例子，以及一个多继承的例子。主要涉及到以下问题：多级继承时虚函数表的内容是如何填写的，如何在多级继承的情况下调用某一级父类里的虚函数，以及在多继承（多个父类）的情况下的对象布局。

多级继承

在这里，多级继承指的是有3层或者多层继承关系的情形。让我们看看下面的代码：

多层继承代码示例

```
//Source filename: Win32Con.cpp
```
```
 #include 
```
```
 using namespace std;
```
```
class parent1
```
```
 {
```
```
public:
```

    virtual int fun1(){cout<<"parent1::fun1()"<<endl;return 0;};

```
    virtual int fun2()=0;
```
```
};
```
```
class child1:public parent1
```
```
 {
```
```
public:
```
```
    virtual int fun1()
```
```
    {
```
```
        cout<<"child1::fun1()"<<endl;
```
```
        parent1::fun1();
```
```
        return 0;
```
```
    }
```
```
    virtual int fun2()
```
```
    {
```
```
        cout<<"child1::fun2()"<<endl;
```
```
        return 0;
```
```
    }
```
```
};
```
```
class grandson:public child1
```
```
 {
```
```
public:
```
```
    virtual int fun2()
```
```
    {
```
```
        cout<<"grandson::fun2()"<<endl;
```
```
        //parent1::fun2();
```
```
        parent1::fun1();
```
```
        child1::fun2();
```
```
        return 0;
```
```
    }
```
```
};
```
```
void test_func1(parent1 *pp)
```
```
{
```
```
    pp->fun1();
```
```
    pp->fun2();
```
```
}
```
```
int main(int argc, char* argv[])
```
```
{
```
```
    grandson sunzi;
```
```
    test_func1(&sunzi);
```
```
    return 0;
```
```
}
```

这段代码展示了三个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的目标代码从而报错。

其实有了对虚函数的正确的认识，上面的多级继承是很自然就能明白的。然而在多继承的情况下，情况就有所不同了。。。

多继承下虚函数的使用

假如一个类，它由多个父类继承而来，而在不同的父类的继承体系里，都存在虚函数的时候，这个类的对象布局又会是怎样的？它又是怎样定位虚函数的呢？

让我们看看下面的代码：

程序输出结果

```
//Source filename: Win32Con.cpp
```
```
 #include 
```
```
 using namespace std;
```
```
class parent1
```
```
 {
```
```
public:
```

    virtual int fun1(){cout<<"parent1::fun1()"<<endl;return 0;};

```
};
```
```
class parent2
```
```
 {
```
```
public:
```

    virtual int fun2(){cout<<"parent2::fun2()"<<endl;return 0;};

```
};
```

class child1:public parent1,public parent2

```
 {
```
```
public:
```
```
    virtual int fun1()
```
```
    {
```
```
        cout<<"child1::fun1()"<<endl;
```
```
        return 0;
```
```
    }
```
```
    virtual int fun2()
```
```
    {
```
```
        cout<<"child1::fun2()"<<endl;
```
```
        return 0;
```
```
    }
```
```
};
```
```
void test_func1(parent1 *pp)
```
```
{
```
```
    pp->fun1();
```
```
}
```
```
void test_func2(parent2 *pp)
```
```
{
```
```
    pp->fun2();
```
```
}
```
```
int main(int argc, char* argv[])
```
```
{
```
```
    child1 chobj;
```
```
    test_func1(&chobj);
```
```
    test_func2(&chobj);
```
```
    return 0;
```
```
}
```

这一次，我们有两个父类，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函数里这部分代码的反汇编代码：

反汇编代码

```
    child1 chobj;
```

00F5162E 8D 4D F4         lea         ecx,[chobj]

00F51631 E8 F5 FB FF FF   call        child1::child1 (0F5122Bh)

```
    test_func1(&chobj);
```

00F51636 8D 45 F4         lea         eax,[chobj]

00F51639 50               push        eax

00F5163A E8 6F FB FF FF   call        test_func1 (0F511AEh)

00F5163F 83 C4 04         add         esp,4

```
    test_func2(&chobj);
```

00F51642 8D 45 F4         lea         eax,[chobj]

00F51645 85 C0            test        eax,eax

00F51647 74 0E            je          main+47h (0F51657h)

00F51649 8D 4D F4         lea         ecx,[chobj]

```
00F5164C 83 C1 04 add ecx,4 
```

00F5164F 89 8D 2C FF FF FF mov         dword ptr [ebp-0D4h],ecx

00F51655 EB 0A            jmp         main+51h (0F51661h)

00F51657 C7 85 2C FF FF FF 00 00 00 00 mov         dword ptr [ebp-0D4h],0

00F51661 8B 95 2C FF FF FF mov         edx,dword ptr [ebp-0D4h]

00F51667 52               push        edx

00F51668 E8 F6 FA FF FF   call        test_func2 (0F51163h)

00F5166D 83 C4 04         add         esp,4

```
    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()

执行test_func2函数，调用的是parent2::fun2，但是居然执行的是child1::fun1()函数！！！

这中间发生了些什么呢？我们再看看反汇编的代码：

反汇编的代码

```
    child1 chobj;
```

013D162E 8D 4D F4         lea         ecx,[chobj]

013D1631 E8 F5 FB FF FF   call        child1::child1 (13D122Bh)

```
    test_func1(&chobj);
```

013D1636 8D 45 F4         lea         eax,[chobj]

013D1639 50               push        eax

013D163A E8 6F FB FF FF   call        test_func1 (13D11AEh)

013D163F 83 C4 04         add         esp,4

    test_func2((parent2*)(void *)&chobj);

013D1642 8D 45 F4         lea         eax,[chobj]

013D1645 50               push        eax

013D1646 E8 18 FB FF FF   call        test_func2 (13D1163h)

013D164B 83 C4 04         add         esp,4

```
    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里的其他成员变量此时也可以同样的方式访问了！

虽然解决方案有了，但是在一个系统的设计里，如果有一个基类出现多继承冲突的情况，大部分情况下都说明这样的设计是有问题的，应该尽量避免这样的设计，并且尽量用纯虚函数，来提取一些抽象的接口类，把共同的方法接口都抽取出来，通常就能避免多继承的问题。

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

多级继承

多继承下虚函数的使用

多继承与虚函数重复

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

Android Studio SQLite 数据库增删改查简单（代码参考）

Leetcode学习成长记：天池leetcode基础训练营Task01数组

开发技巧：在Interface Builder中实现UIButton文本居中对齐的方法与步骤

OpenGLPBO

vue引入echarts地图的四种方式

使用Tkinter构建51Ape无损音乐爬虫UI

Spring Boot 中使用 spring-boot-starter-quartz 实现定时任务

SoundPool

实验九：使用SharedPreferences存储简单数据

Go语言中的命令设计模式详解

理解和优化进程与线程状态转换机制

Python 伦理黑客技术：深入探讨后门攻击（第三部分）

Python中调整数据分辨率的方法

Spring Data JdbcTemplate 入门指南

Java Socket 关键参数详解与优化建议