C++虚函数表在多重继承下的内存布局与指针调整

理解 C++ 多重继承下的内存布局是深入掌握对象模型的关键。在单一继承中，对象内存通常只包含一个虚函数表指针（vptr），但在多重继承下，情况会变得复杂：一个对象可能包含多个 vptr，且基类指针与派生类指针之间的转换会涉及内存地址的偏移调整。本文将深入剖析这一机制。

1. 构建多重继承模型

为了演示内存布局，首先定义两个基类和一个派生类。这些类包含虚函数，以确保编译器为其生成虚函数表。

定义 基类 Base1，包含一个整型成员和一个虚函数：

class Base1 {
public:
    int base1_data;
    virtual void func1() { cout << "Base1::func1" << endl; }
};

定义 基类 Base2，同样包含一个整型成员和一个虚函数：

class Base2 {
public:
    int base2_data;
    virtual void func2() { cout << "Base2::func2" << endl; }
};

定义 派生类 Derived，公开继承 Base1 和 Base2，并覆盖基类的虚函数，同时添加自己的虚函数：

class Derived : public Base1, public Base2 {
public:
    int derived_data;
    void func1() override { cout << "Derived::func1" << endl; }
    void func2() override { cout << "Derived::func2" << endl; }
    virtual void func3() { cout << "Derived::func3" << endl; }
};

2. 分析内存布局结构

在多重继承下，Derived 对象的内存并非简单拼接，而是由多个“子对象”组成。编译器会为每一个拥有虚函数的基类子对象维护一个独立的虚函数表指针。

观察 Derived 对象在 64 位系统下的典型内存布局（假设指针大小为 8 字节，int 为 4 字节，且存在内存对齐）：

注意 以下关键点：

1. 多个 vptr：Derived 对象内有两个 vptr。vptr1 属于 Base1 子对象，vptr2 属于 Base2 子对象。
2. func3 的归属：Derived::func3 被追加到了第一个虚函数表（即 Base1 的虚表）中，而不是创建第三个表。
3. 内存顺序：子对象在内存中的排列顺序通常与继承声明的顺序一致（先 Base1 后 Base2）。

3. 理解指针调整原理

当使用基类指针指向派生类对象时，编译器会根据基类在对象中的位置自动调整指针的值。

计算 地址偏移的逻辑：

假设 Derived 对象的起始地址为 $Address_Derived$。

• Base1 子对象位于起始位置，因此：
  $$Address_{Base1} = Address_{Derived} + 0$$

• Base2 子对象紧跟在 Base1 之后，因此：
  $$Address_{Base2} = Address_{Derived} + sizeof(Base1)$$

执行 以下指针转换代码：

Derived d;
Base1* p1 = &d;
Base2* p2 = &d;

在此代码中：

• p1 的值与 &d 相同。
• p2 的值等于 &d 加上 Base1 子对象的大小（通常为 16 字节：8 字节 vptr + 4 字节 int + 4 字节对齐）。

4. 深入 this 指针的修正

当通过 Base2 类型的指针调用虚函数时，this 指针必须进行调整，以确保函数体内访问成员变量时使用的是对象首地址。

分析 p2->func2() 的调用过程：

1. 查表：通过 p2 指向的 vptr2 找到虚函数表，获取 Derived::func2 的地址。
2. 调整 this：由于 p2 指向的是 Base2 子对象（偏移了 16 字节），编译器会在进入 func2 函数体之前，将 this 指针减去 16 字节，使其指向 Derived 对象的首地址。
3. 跳转：执行函数代码。

对于 p2->func1()（如果 Base2 有访问 func1 的途径，或者通过 static_cast 转换后调用），情况类似。由于 func1 在 Base1 的虚表中，Base2 的虚表中可能包含一个“非虚调整 thunk”。这个 thunk 负责先调整 this 指针（减去偏移量），再跳转到 func1 的实际代码。

5. 实际代码验证

通过编写代码打印 this 指针和成员地址，可以直观地验证上述布局。

编写 验证程序：

#include <iostream>
using namespace std;

class Base1 {
public:
    int base1_data;
    virtual void func1() { cout << "Base1 func1, this: " << this << endl; }
};

class Base2 {
public:
    int base2_data;
    virtual void func2() { cout << "Base2 func2, this: " << this << endl; }
};

class Derived : public Base1, public Base2 {
public:
    int derived_data;
    void func1() override { 
        cout << "Derived func1, this: " << this << endl; 
    }
    void func2() override { 
        cout << "Derived func2, this: " << this << endl; 
    }
    virtual void func3() { 
        cout << "Derived func3, this: " << this << endl; 
    }
};

int main() {
    Derived d;

    // 打印成员地址以观察布局
    cout << "=== 内存布局观察 ===" << endl;
    cout << "&d (Derived start):       " << &d << endl;
    cout << "&d.base1_data:            " << &d.base1_data << endl;
    cout << "&d.base2_data (Offset):   " << &d.base2_data << " (+ " << (char*)&d.base2_data - (char*)&d << ")" << endl;
    cout << "&d.derived_data:          " << &d.derived_data << endl;

    cout << "\n=== 指针转换与调整 ===" << endl;
    Base1* p1 = &d;
    Base2* p2 = &d;

    cout << "p1 (Base1*):              " << p1 << endl;
    cout << "p2 (Base2*):              " << p2 << endl;

    cout << "\n=== this 指针修正验证 ===" << endl;
    // p2->func2() 内部输出的 this 应该等于 &d (Derived 的首地址)
    // 而不是 p2 的值
    p2->func2();

    return 0;
}

编译 并 运行 该程序。观察输出结果，重点关注：

1. &d.base2_data 的地址与 &d 的差值，即为 Base1 子对象的大小。
2. p2 的值应该等于 &d.base2_data 的地址附近（通常 vptr 在对象头部，所以 p2 指向的地址实际上是 Base2 子对象的 vptr，地址值通常小于 base2_data 几个字节，但绝对大于 &d）。
3. 在 p2->func2() 的输出中，虽然调用者是 p2（指向中间偏移位置），但函数内部打印的 this 指针应恢复为 Derived 对象的首地址（即与 &d 相同）。这证明了编译器自动完成了 this 指针的修正。

6. 总结偏移量规则表

为了方便查阅，下表总结了在 64 位系统中，不同指针类型转换时的行为。

通过以上步骤和代码验证，即可彻底掌握 C++ 多重继承下的内存布局与指针调整机制。