引言
在C++的多重继承中，虚函数表的布局是一个复杂但有趣的话题。最近我在调试一个多重继承的代码时，通过监视窗口和内存窗口观察到了有趣的现象，验证了一个重要的结论：在多重继承中，如果派生类新增了虚函数，这个新增的虚函数会被放在第一个基类的虚表末尾。本文将详细分析这个过程，并通过实际的内存数据来验证。
目录
[1. D类对象有两个虚表指针](#1. D类对象有两个虚表指针)
[2. 虚表内容分析](#2. 虚表内容分析)
[1. 内存布局的连续性](#1. 内存布局的连续性)
[2. 历史原因和兼容性](#2. 历史原因和兼容性)
[3. 性能考虑](#3. 性能考虑)
[1. 编译器和平台差异](#1. 编译器和平台差异)
[2. 多重继承中的虚函数调用](#2. 多重继承中的虚函数调用)
[3. 虚继承的影响](#3. 虚继承的影响)
代码示例
首先，我们来看一个简单的多重继承示例：
cpp
#include <iostream>
using namespace std;
// 基类B1
class B1 {
public:
virtual void func1() { cout << "B1::func1()" << endl; }
};
// 基类B2
class B2 {
public:
virtual void func2() { cout << "B2::func2()" << endl; }
};
// 派生类D，先继承B1，再继承B2
class D : public B1, public B2 {
public:
// 重写B1虚函数
virtual void func1() override {
cout << "D::func1() - 重写B1" << endl;
}
// 重写B2虚函数
virtual void func2() override {
cout << "D::func2() - 重写B2" << endl;
}
// 新增虚函数
virtual void newFunc() {
cout << "D::newFunc() - D新增虚函数" << endl;
}
};
int main() {
D d;
return 0;
}内存布局分析
1. D类对象有两个虚表指针
从调试器的监视窗口可以看到：
text
名称 值
d {...}
B1 {...}
vfptr 0x00bf9b6c{test_12_26_02.exe!void(D::*)(void)}
[0] 0x00bf1348{test_12_26_02.exe!D::func1(void)}
B2 {...}
vfptr 0x00bf9b7c{test_12_26_02.exe!void(D::*)(void)}
[0] 0x00bf11cc{test_12_26_02.exe!D::func2(void)}关键发现：
-
D类对象
d包含两个虚表指针（vfptr） -
第一个vfptr位于地址
0x00bf9b6c，属于B1部分 -
第二个vfptr位于地址
0x00bf9b7c，属于B2部分
2. 虚表内容分析
B1的虚表（地址：0x00bf9b6c）
查看内存窗口，地址0x00bf9b6c处的内容：
text
地址: 0x00BF9B6C
0x00BF9B6C 48 13 bf 00 H.?.
0x00BF9B70 61 13 bf 00 a.?.
0x00BF9B74 00 00 00 00 . . . . 解析：
-
第一个4字节：
0x00bf1348→ 这是D::func1()的地址 -
第二个4字节：
0x00bf1361→ 这是D::newFunc()的地址 -
第三个4字节：
0x00000000→ 虚表结束标记（VS编译器特性）
B2的虚表（地址：0x00bf9b7c）
查看内存窗口，地址0x00bf9b7c处的内容：
text
地址: 0x00BF9B7C
0x00BF9B7C cc 11 bf 00 ?.?.
0x00BF9B80 00 00 00 00 . . . . 解析：
-
第一个4字节：
0x00bf11cc→ 这是D::func2()的地址 -
第二个4字节：
0x00000000→ 虚表结束标记
验证结论：D类新增加的虚函数放在第一张虚表最后
通过上述内存分析，我们可以得出以下结论：
-
B1的虚表包含两个函数：
-
0x00bf1348：D::func1()（重写B1的虚函数） -
0x00bf1361：D::newFunc()（D类新增的虚函数）
-
-
B2的虚表只包含一个函数：
0x00bf11cc：D::func2()（重写B2的虚函数）
这验证了我们的假设：在多重继承中，派生类新增的虚函数会被放在第一个基类的虚表末尾。
为什么这样设计？
1. 内存布局的连续性
D类对象在内存中的布局如下：
text
+----------------+
| B1部分 |
| - vfptr | → 指向B1的虚表（包含func1和newFunc）
| - B1数据成员 |
+----------------+
| B2部分 |
| - vfptr | → 指向B2的虚表（只包含func2）
| - B2数据成员 |
+----------------+
| D类新增数据成员 |
+----------------+2. 历史原因和兼容性
-
保持与单一继承的兼容性
-
第一个基类被当作"主要"基类
-
其他基类被视为"次要"基类
3. 性能考虑
-
减少虚表指针的数量
-
保持虚函数调用的效率
实际验证代码
我们可以通过打印函数地址来进一步验证：
cpp
#include <iostream>
using namespace std;
class B1 {
public:
virtual void func1() { cout << "B1::func1()" << endl; }
};
class B2 {
public:
virtual void func2() { cout << "B2::func2()" << endl; }
};
class D : public B1, public B2 {
public:
virtual void func1() override { cout << "D::func1()" << endl; }
virtual void func2() override { cout << "D::func2()" << endl; }
virtual void newFunc() { cout << "D::newFunc()" << endl; }
};
int main() {
D d;
// 通过函数指针获取虚函数地址
typedef void (*FuncPtr)();
// 获取B1虚表中的函数
cout << "B1虚表内容：" << endl;
cout << "func1地址: " << (void*)(&D::func1) << endl;
cout << "newFunc地址: " << (void*)(&D::newFunc) << endl;
// 获取B2虚表中的函数
cout << "\nB2虚表内容：" << endl;
cout << "func2地址: " << (void*)(&D::func2) << endl;
return 0;
}重要注意事项
1. 编译器和平台差异
-
VS编译器会在虚表末尾添加
0x00000000作为结束标记 -
GCC编译器可能不会添加结束标记
-
64位系统中指针大小为8字节
2. 多重继承中的虚函数调用
cpp
int main() {
D d;
B1* b1 = &d;
B2* b2 = &d;
// 通过B1指针可以调用newFunc吗？
// b1->newFunc(); // 错误：B1类中没有newFunc
// 需要向下转型
D* dPtr = dynamic_cast<D*>(b1);
if (dPtr) {
dPtr->newFunc(); // 正确
}
}3. 虚继承的影响
如果使用虚继承，内存布局会更加复杂，虚表结构也会不同。
总结
通过实际的内存分析，我们验证了在多重继承中：
-
每个基类都有自己的虚表指针
-
派生类对象包含多个虚表指针
-
派生类新增的虚函数被放在第一个基类的虚表末尾
-
其他基类的虚表只包含自己相关的虚函数
这个设计既保持了与单一继承的兼容性，又提供了多重继承的灵活性。理解这个原理对于调试复杂的继承关系和性能优化都有重要意义。
参考资源
-
《深度探索C++对象模型》- Stanley B. Lippman
-
C++标准文档
-
MSVC编译器实现细节
希望这篇博客能帮助你更好地理解C++多重继承中的虚表布局！