虚！

本来想让AI帮忙总结一下关于C++虚字辈的知识点。结果一看，确实是整理了，但是真的就是纯粹的知识点的堆砌。看了一遍毫无章法。我还是自己写吧，毕竟自己才知道自己对哪一部分比较模糊陌生。

我看了一些面试题，大多数就是让你阐述一下虚函数，然后开始以此深挖。我觉得可以把这些题分为以下这几个类型：

• 各种基本概念，各种实现实体的内存空间长什么样
• 在不同的情况下的调用过程
• 在哪些情况下，为什么要用它
• 在哪些情况下，为什么不用它
• 其他零零散散的知识点

我会按照我的思路，一点点复盘这些知识点。

一、各种基本概念和内存布局

1. 虚函数是什么

虚函数，是C++实现多态的一种重要机制，这里主要指的是动态多态。这种重要机制主要靠虚函数指针和虚函数表来实现（主流编译器的实现方式如此，C++的标准没有规定）。这时候就要想，为什么需要多态？主要想解决的问题就是想用基类的指针，去调用派生类的一些方法，能让代码简洁一些，管理起来也更方便，可扩展性也更高。实现呢就是在类里的成员函数前加上virtual关键字。派生类继承基类的时候，virtual成员函数会被自动继承为virtual，重写的时候即使不加override关键字它也是virtual虚函数。

2. 虚函数表vtable是什么

虚函数表就是存储虚函数地址的一张表。由虚函数表指针vptr来指向这张表，来获取表里的虚函数地址，以此调用相应的虚函数。

虚函数表又是什么时候生成的呢？这张表是在编译期就生成好的，所以这是个静态的表。存放在程序的只读数据段里（.rodata）。如果一个派生类重写了基类的虚函数，那么在编译期，我们的编译器就会用派生类重写好的虚函数的地址去替换掉原来虚函数表中对应的那个虚函数的地址。这里要注意，多继承里，虚函数表可不是只有一张。而是每一个被继承的类自己管理自己的虚函数表。关于这部分内容可以看我之前的博客：多继承的虚函数表有几张？

这里要补充一点：虚函数表里只有一堆虚函数地址吗？并非如此。如果开启了RTTI（运行时类型识别），则可能还包含运行时类型信息RTTI的指针还有其他元数据，这个取决于编译器的实现。

还有一个混淆的点：虚函数是存储在代码段的。虚函数表是一个存储函数指针的数据结构，所以存在只读数据段中。

3. 虚函数表指针vptr是什么

这是个指针，存的就是虚函数表的地址。这个指针是由编译器为包含虚函数的类隐式插入的一个指针。这个指针有多大呢？系统有多少位就有多少位。32位系统就是4个字节，64位系统就是8个字节。这个指针通常存在对象内存的起始位置（C++标准并未规定）。
vptr是在对象构造的期间才被赋值的，在析构的时候被销毁。
但是对于多继承的情况下，一个对象内存里可能有多个虚函数表指针，详见我之前的博客：多继承的虚函数表有几张？我简单总结一下，多继承的派生类的内存布局可理解为：按照继承顺序，依次包含每个基类的完整子对象（包括各自的vptr和数据成员），最后是派生类自身新增的成员。
使用其中一个基类的指针或引用去指向派生类的对象的话，编译器会将这个对象的this指针更新为那个基类的起始地址，也就是那个基类的虚函数表指针那里。这样，调用起基类被重写的虚函数，this就直接访问到相应基类的虚函数表了。
这里要说一下多继承里，调整this时的offset是怎么来的。符号表会维护类的内存布局，生成代码的时候会硬编码在指令中。

对于一个多继承来说，比如下面这个代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

class Base1 {public: virtual void a() = 0; };
class Base2 {public:virtual void b() = 0; };
class Derived : public Base1, public Base2 {
    void a() override {}
    void b() override {}
    virtual void c() {}  // 只应在Base1的vtable中
};

int main()
{
Base2* pb = new Derived();
pb->b();  
}

我用MSVC的编译器编译出来，截一段：

1
2
3
4
5
6
7
8

const Derived::`vftable'{for `Base1`} 
        DQ FLAT:const Derived::`RTTI Complete Object Locator'{for `Base1`}
        DQ FLAT:virtual void Derived::a(void)  // 偏移0处：Derived::a
        DQ FLAT:virtual void Derived::c(void)  // 偏移8处：Derived::c

const Derived::`vftable'{for `Base2`}
        DQ FLAT:const Derived::`RTTI Complete Object Locator'{for `Base2`}
        DQ FLAT:virtual void Derived::b(void)  // 偏移0处：Derived::b

还有一段：

1
2
3
4

Derived::`RTTI Complete Object Locator'{for `Base2`}
Derived::`RTTI Complete Object Locator'{for `Base1`}
Base2::`RTTI Complete Object Locator`
Base1::`RTTI Complete Object Locator`

每个虚函数表开头都有一个RTTI Complete Object Locator，用于：

1. dynamic_cast类型转换
2. typeid操作符
3. 异常处理（exception handling）

1
2
3
4

; main代码：
mov     rax, QWORD PTR tv73[rsp]  ; rax = Derived* (新创建的对象)
add     rax, 8                    ; rax += 8 ← 调整到Base2子对象,硬编码
mov     QWORD PTR pb$[rsp], rax   ; 存储到pb (Base2*)

我们再看看用gcc编译的，截取相关：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

vtable for Derived:
        .quad   0
        .quad   typeinfo for Derived
        .quad   Derived::a()
        .quad   Derived::b()
        .quad   Derived::c()
        .quad   -8
        .quad   typeinfo for Derived
        .quad   non-virtual thunk to Derived::b()
vtable for Base2:
        .quad   0
        .quad   typeinfo for Base2
        .quad   __cxa_pure_virtual
vtable for Base1:
        .quad   0
        .quad   typeinfo for Base1
        .quad   __cxa_pure_virtual

(太复杂了后面再说)

4. 虚继承是什么

虚继承是C++中解决菱形继承问题的一种机制。什么是菱形继承呢？就是两个基类都继承自同一个基类，而派生类又同时继承这两个基类，形成一个菱形的继承结构。在普通继承中，派生类会包含两份最顶层基类的副本，这会导致数据冗余和二义性。

举个例子，如果A是基类，B和C都继承自A，然后D同时继承B和C，那么普通继承下D会包含两份A的副本。当你通过D访问A的成员时，编译器不知道你要访问哪一份，就会报二义性错误。

虚继承通过引入虚基类表（vbtable）和虚基类指针（vbptr），确保在菱形继承结构中，最顶层的基类只有一个实例被共享。使用虚继承时，在继承声明前加上virtual关键字，比如class B : virtual public A。

5. 虚继承类的内存结构

虚继承对内存布局的影响比较复杂。在虚继承的情况下，虚基类通常被放置在派生类对象的尾部，而不是按照继承顺序排列。这意味着访问虚基类成员需要通过多次间接寻址。

具体来说，内存布局大致是：派生类数据成员在前，然后是各个非虚基类的数据成员，最后是虚基类的数据成员。每个虚继承的基类都会引入一个虚基类表指针（vbptr），这个指针指向虚基类表，用于存储虚基类在对象中的偏移量。

访问虚基类成员的过程是：首先通过对象的vptr找到虚函数表，然后通过虚基类表指针找到虚基类表，最后通过虚基类表中的偏移量找到虚基类在对象中的实际位置。这种三次间接寻址的设计虽然保证了正确性，但也带来了一定的性能开销。

6. 虚基类表是什么，长什么样

虚基类表（vbtable）是虚继承机制中用于存储虚基类偏移量的数据结构。当通过非最终派生类的指针访问虚基类成员时，需要通过虚基类表来找到虚基类在派生类对象中的实际位置。

虚基类表存储的是虚基类相对于当前对象的偏移量信息。不同的继承路径可能需要不同的偏移量，因此虚基类表的存在使得编译器能够在运行时正确计算虚基类的地址。

举个例子，在菱形继承中，如果D继承自B和C，而B和C都虚继承自A，那么B和C各自都会有一个虚基类表，表中存储着A在D对象中的偏移量。当通过B的指针访问A的成员时，编译器会通过B的虚基类表找到A的实际位置。

7. 虚基类表指针是什么，存在哪

虚基类表指针（vbptr）是指向虚基类表的指针。这个指针是由编译器为每个虚继承的基类隐式插入的。vbptr的大小和vptr一样，32位系统4字节，64位系统8字节。

vbptr通常存储在虚继承基类子对象的起始位置，但具体位置取决于编译器的实现。在MSVC中，vbptr可能存储在vtable的特定位置；在GCC/Clang中，vbptr可能作为独立的数据成员存储。

每个虚继承的基类都会有自己的vbptr，指向自己的虚基类表。这样设计的好处是，不同的继承路径可以通过各自的虚基类表找到共享的虚基类实例，而不需要知道完整的继承层次结构。

8. 纯虚函数又是什么

纯虚函数是一种特殊的虚函数，它只有声明而没有实现，通过在函数声明后添加= 0来标识，比如virtual void func() = 0;。包含纯虚函数的类被称为抽象类，抽象类不能直接实例化对象，只能作为基类存在。

纯虚函数的作用是为派生类提供接口规范，强制派生类必须实现特定的行为。派生类必须实现所有纯虚函数才能成为具体类，才能被实例化。如果派生类没有实现所有纯虚函数，那么派生类仍然是抽象类，无法创建对象。

在基类的虚函数表中，纯虚函数的地址位置通常被设置为nullptr或特定占位值。当尝试调用纯虚函数时，程序会抛出异常或导致未定义行为。这确保了抽象类不能被实例化，因为调用未实现的纯虚函数会导致程序崩溃。

有一个特殊情况：纯虚析构函数必须提供定义，即使它是纯虚的。这是因为即使基类是抽象类，派生类对象销毁时仍需要调用基类的析构函数。如果不提供纯虚析构函数的定义，链接器会报错。

二、各种调用的过程

1. 单继承里，虚函数被调用的过程

单继承情况下，虚函数调用的过程相对简单。当我们通过基类指针或引用调用虚函数时，编译器首先会获取对象的vptr，这个指针通常位于对象的起始位置。然后通过vptr找到对应的虚函数表，这是一个函数指针数组。

接下来，编译器会根据函数在虚函数表中的偏移量，找到具体的函数地址。这个偏移量是在编译时确定的，因为函数在类中的声明顺序是固定的。最后，通过函数地址进行函数调用。

如果派生类重写了基类的虚函数，那么虚函数表中对应位置的条目会被替换为派生类的函数地址。如果派生类没有重写，那么虚函数表中仍然保留基类的函数地址。调用时，无论哪种情况，都是通过同一个vptr和同一个虚函数表进行查找。

这个调用过程的时间复杂度是O(1)，因为虚函数表是一个数组，函数地址通过编译期确定的偏移量直接访问，只需要一次指针解引用和一次跳转。

2. 多继承里，虚函数被调用的过程

多继承情况下，调用过程会复杂一些。派生类对象可能包含多个vptr，分别对应不同的基类。当我们通过某个基类指针调用虚函数时，编译器会使用该基类对应的vptr和虚函数表。

如果派生类重写了某个基类的虚函数，那么该基类的虚函数表中对应位置的条目会被更新。不同的基类可能有不同的虚函数表，即使它们包含相同的虚函数。

当我们使用其中一个基类的指针或引用去指向派生类的对象时，编译器会将这个对象的this指针更新为那个基类的起始地址，也就是那个基类的虚函数表指针那里。这样，调用起基类被重写的虚函数，this就直接访问到相应基类的虚函数表了。

这个this指针的调整是在编译期确定的，offset会被硬编码在指令中。比如前面看到的汇编代码中，add rax, 8就是硬编码的偏移量，将Derived调整为Base2。

3. 虚继承里，虚函数被调用的过程

虚继承情况下，调用过程更加复杂。除了虚函数表的查找，还需要考虑虚基类的访问。当我们通过非最终派生类的指针访问虚基类的成员时，编译器需要通过虚基类表来调整this指针。

这个过程包括：首先通过对象的vptr找到虚函数表，然后通过虚基类表指针找到虚基类表，最后通过虚基类表中的偏移量计算虚基类的实际地址。这种三次间接寻址的设计虽然保证了正确性，但也带来了一定的性能开销。

当通过非最终派生类的指针访问虚基类成员时，编译器会自动调整this指针。例如，在D类中访问B的A基类成员时，实际this指针会被调整为指向D对象中A的实例。这种调整是通过虚基类表中的偏移量来实现的，确保访问到正确的虚基类实例。

4. 虚函数表指针的生命周期

vptr是在对象构造的期间才被赋值的，在析构的时候被销毁。具体来说，在对象创建前，vptr未初始化；基类构造阶段，vptr指向基类vtable；派生类构造阶段，vptr更新为派生类vtable；对象销毁时，vptr仍指向派生类vtable（直到析构完成）。

这解释了为什么在构造函数中调用虚函数不会跳转到派生类实现，因为此时vptr还没有更新为派生类的vtable。在基类构造函数中，vptr指向基类的虚函数表，因此调用的是基类的虚函数实现。只有当进入派生类构造函数后，vptr才会更新为派生类的虚函数表。

在析构过程中，顺序相反：先执行派生类析构函数，此时vptr仍指向派生类的虚函数表；然后执行基类析构函数，vptr被更新为指向基类的虚函数表。这解释了为什么在析构函数中调用虚函数也不会产生多态行为。

5. 虚基类表指针的生命周期

虚基类表指针（vbptr）的生命周期和vptr类似，也是在对象构造期间被赋值，在析构时被销毁。但是虚继承的构造和析构顺序更加复杂，因为需要确保虚基类只被构造一次。

在虚继承的情况下，虚基类的构造由最底层的派生类负责，而不是由中间层的基类负责。这意味着即使B和C都虚继承自A，当D继承B和C时，A的构造只会在D的构造函数中被调用一次，而不是在B和C的构造函数中各调用一次。

vbptr的初始化也是在最底层的派生类构造函数中完成的。编译器会确保虚基类表在访问虚基类成员之前就已经正确设置，这样通过vbptr访问虚基类表时才能找到正确的偏移量。

new：菱形继承里，最底下的那个类的构造过程

菱形继承中最底层类的构造过程比较特殊，因为需要确保虚基类只被构造一次。我们用一个典型的例子来说明：A是基类，B和C都虚继承自A，D继承B和C（D是最底层的类）。

构造顺序是这样的：首先构造虚基类A，而且只构造一次。然后按照继承顺序构造B和C，但B和C的构造函数中不会再去构造A，因为A已经在第一步构造好了。最后构造D本身。

具体来说，当创建D的对象时，构造函数的调用顺序是：

1. A的构造函数（虚基类，只调用一次）
2. B的构造函数（跳过A的构造）
3. C的构造函数（跳过A的构造）
4. D的构造函数

这个顺序是由编译器自动安排的，不需要我们手动控制。编译器会确保虚基类A在任何使用它的基类（B和C）之前就已经构造完成。

在构造过程中，vbptr的初始化也很关键。B和C各自的vbptr会在它们的构造函数中被初始化，指向各自的虚基类表。这些虚基类表中存储着A在D对象中的偏移量，使得B和C能够通过各自的vbptr找到共享的A实例。

析构的顺序正好相反：先析构D，然后析构C，再析构B，最后析构A。同样，A只会被析构一次，即使B和C都有析构函数，它们也不会再去析构A，因为A的析构由最底层的D负责。

这种设计确保了在菱形继承中，虚基类只有一个实例，避免了数据冗余和二义性问题。但代价是构造和析构的顺序变得复杂，而且访问虚基类成员需要通过额外的间接寻址。

6. 构造函数和析构函数中调用虚函数的行为

在构造函数和析构函数中调用虚函数不会产生多态行为，而是静态绑定到当前构造或析构阶段的类版本。这是因为对象类型在构造和析构过程中被视为”不完整”。

构造时，派生类部分尚未构造完成，无法保证其虚函数的正确性。析构时，派生类部分已经销毁，其虚函数可能无法安全调用。C++标准明确禁止在构造/析构函数中通过动态绑定调用虚函数，这是为了确保对象状态的一致性。

如果必须在构造或析构过程中使用多态行为，可以考虑使用初始化函数模式：在对象完全构造后调用一个初始化函数，此时对象已经完整，可以安全地调用虚函数。但一般来说，应该避免在构造函数和析构函数中调用虚函数。

虚继承

在C++面向对象编程中，虚继承（virtual inheritance）是一种解决多重继承问题的高级机制，特别是针对菱形继承问题。本文将深入解析虚继承的底层实现原理，包括虚基类表、虚基类表指针的定义、产生时机、生命周期，以及虚继承类对象的构造过程，特别是菱形继承结构中底层类的构造顺序，同时分析通过不同基类调用派生类虚函数的实现机制。通过这些底层原理的剖析，我们可以更好地理解C++虚继承的工作方式及其在实际应用中的影响。

一、虚基类表(vbtable)与虚基类表指针(vbptr)机制

1. 虚基类表(vbtable)的定义与作用

虚基类表是C++编译器为支持虚继承而自动生成的一种数据结构。它的核心功能是存储虚基类子对象在派生类对象中的偏移地址。在标准的Itanium C++ ABI中，每个虚基类表包含以下信息：

• 虚基类的类型信息：标识该虚基类的类型
• 虚基类子对象的偏移地址：记录虚基类子对象在最终派生类对象中的相对位置
• 虚函数表指针：指向最终派生类中覆盖虚基类虚函数的虚函数表

2. 虚基类表(vbtable)的产生时机与生命周期

虚基类表的产生和生命周期遵循以下规则：

• 产生时机：当且仅当一个类使用virtual关键字继承某个基类时，编译器才会为该继承关系生成对应的虚基类表。例如在以下代码中：

1
2
3

class A { /* ... */ };
class B : virtual public A { /* ... */ }; // B继承A为虚基类
class C : public B { /* ... */ }; // C继承B，此时B的虚基类A也会影响C的内存布局

编译器会在编译阶段为B生成一个虚基类表。

• 生命周期：虚基类表是静态存储的，其生命周期与整个程序一致。这些表在程序加载时被初始化，驻留在只读内存区域，所有对象共享同一份虚基类表数据。当对象被创建或销毁时，不会影响虚基类表的存在，它只在对象构造和析构时被引用以确定虚基类子对象的位置。

3. 虚基类表指针(vbptr)的定义与作用

虚基类表指针是虚继承机制的关键实现组件。每个虚继承的子类（如上述代码中的B）都会包含一个指向其虚基类表的指针成员，称为vbptr（virtual base pointer）。

• 存储位置：vbptr作为隐式成员存储在虚继承的子类对象中。例如，类B的对象布局会包含一个指向A的虚基类表的vbptr。
• 核心功能：vbptr存储虚基类表的地址，通过该地址可以查询到虚基类子对象在最终派生类中的偏移量，从而正确地访问虚基类的成员。

4. 虚基类表指针(vbptr)的构造时机与生命周期

• 构造时机：vbptr在对象构造过程中被初始化。在虚继承的类层次中，只有最底层的派生类负责设置所有虚基类的vbptr。例如，在菱形继承结构中：

1
2
3
4

class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ }; // 最底层派生类

当构造D对象时，D的构造函数会初始化B和C中的vbptr，指向正确的虚基类表。而B和C的构造函数本身不会初始化自己的vbptr，因为虚基类的初始化责任已经被转移到了最底层派生类。

• 生命周期：vbptr的生命周期与包含它的对象完全一致。它在对象构造时被初始化，指向正确的虚基类表；在对象析构时，随着对象内存的释放而失效。值得注意的是，即使虚基类本身没有虚函数，只要存在虚继承关系，编译器也会为该继承路径生成vbptr和对应的虚基类表。

二、虚继承类对象的构造过程

1. 虚继承对象的构造顺序

虚继承类对象的构造遵循严格的顺序规则，这是确保虚基类正确共享的关键：

1. 虚基类优先构造：首先构造所有虚基类，按照它们在继承层次中被声明的顺序进行。
2. 非虚基类按声明顺序构造：然后构造非虚基类，同样按照它们在继承列表中声明的顺序。
3. 成员对象按声明顺序构造：接下来构造派生类中声明的成员对象，按照它们在类体中声明的顺序。
4. 派生类自身构造：最后执行派生类自身的构造函数。

构造顺序示例：考虑以下继承结构：

1
2
3
4

class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ };

构造D对象的顺序为：A → B → C → D的成员 → D自身的构造函数。

2. 虚基类初始化权的转移

在虚继承结构中，虚基类的初始化责任被转移到了最底层派生类。这是虚继承区别于普通继承的关键特性：

• 在普通继承中，中间派生类（如B和C）负责初始化它们直接继承的基类（如A）。
• 在虚继承中，中间派生类不再初始化其虚基类，而是由最底层派生类（如D）统一初始化所有虚基类。这意味着在D的构造函数初始化列表中，必须显式调用所有虚基类的构造函数，否则会导致编译错误。

例如，D的构造函数必须显式初始化A：

1
2
3
4

class D : public B, public C {
public:
    D() : A(), B(), C() { /* ... */ } // 必须显式初始化A
};

3. 虚基类表指针(vbptr)的初始化过程

在构造过程中，vbptr的初始化是确保虚基类正确共享的关键步骤：

• 当构造最底层派生类（如D）时，编译器会首先为所有虚基类（如A）分配内存空间并执行构造。
• 然后，编译器会计算每个虚基类子对象相对于最终派生类对象的偏移量。
• 接着，编译器会为每个虚继承的中间类（如B和C）初始化其vbptr，使其指向包含正确偏移量的虚基类表。
• 最后，当构造非虚基类（如B和C）时，它们的虚函数表指针（vptr）会被设置为指向最终派生类中的虚函数表，以确保虚函数的正确动态绑定。

4. 菱形继承结构中的构造过程

菱形继承（Diamond Inheritance）是C++中典型的多重继承场景，也是虚继承的主要应用场景：

1
2
3
4
5

  A
 / \
B   C
 \ /
  D

在菱形继承结构中，若没有使用虚继承，D对象将包含A的两个独立副本，导致数据冗余和访问歧义。通过在中间层使用虚继承，可以确保D中仅保留一个A实例：

1
2
3
4

class A { /* ... */ };
class B : virtual public A { /* ... */ }; // 虚继承
class C : virtual public A { /* ... */ }; // 虚继承
class D : public B, public C { /* ... */ }; // 底层派生类

D对象的构造过程如下：

1. 首先构造虚基类A。
2. 然后构造B，此时B的vbptr被设置为指向包含A偏移量的虚基类表。
3. 接着构造C，其vbptr同样指向虚基类表，但由于A已经被构造，C的A子对象不会被再次构造。
4. 最后构造D的成员对象和执行D自身的构造函数。

内存布局示例：D对象的典型内存布局为：

1
2
3
4
5
6

[ B的vbptr ] → 指向B的虚基类表
[ B的成员变量 ]
[ C的vbptr ] → 指向C的虚基类表
[ C的成员变量 ]
[ D的成员变量 ]
[ A的成员变量 ] → 虚基类A的共享实例

虚基类A的成员变量位于对象的末尾，通过B和C的vbptr指向的虚基类表中的偏移信息，可以正确访问该共享实例。

三、虚函数调用机制与this指针调整

1. 虚函数表(vtable)与虚函数指针(vptr)的关系

在C++中，虚函数的多态性通过虚函数表和虚函数指针实现：

• **虚函数表(vtable)**：每个包含虚函数的类都有一个或多个虚函数表，存储该类中所有虚函数的地址。
• **虚函数指针(vptr)**：每个对象包含一个指向其类虚函数表的指针，用于动态绑定到正确的函数实现。

在虚继承结构中，虚函数表和虚函数指针的管理更为复杂：

• 每个虚继承的中间类（如B和C）都包含一个vptr，指向自己的虚函数表。
• 最底层派生类（如D）的虚函数表会覆盖所有继承路径上的虚函数实现。
• 当通过中间基类（如B或C）的指针调用虚函数时，需要调整this指针以指向正确的虚函数表。

2. this指针调整技术

在虚继承结构中，this指针调整（this pointer adjustment） 是确保正确虚函数调用的关键机制：

• thunk技术：当通过一个中间基类（如B）的指针调用虚函数时，编译器会生成一个短小的适配代码段（称为thunk），负责调整this指针，使其指向最终派生类对象的正确位置。

例如，考虑以下继承结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class A {
public:
    virtual void func() { /* ... */ }
};

class B : virtual public A {
public:
    virtual void func() override { /* ... */ }
};

class C : virtual public A {
public:
    virtual void func() override { /* ... */ }
};

class D : public B, public C {
public:
    virtual void func() override { /* ... */ }
};

当通过B*指针调用func()时，实际调用的路径如下：

1. 首先通过B的vptr找到B的虚函数表。
2. 若D重写了func()，则B的虚函数表中存储的不是B::func的地址，而是一个指向thunk的指针。
3. thunk代码执行后，会将this指针调整为指向D对象的正确位置。
4. 调整后的this指针被用来访问D的虚函数表，最终调用D::func()。

3. 菱形继承中虚函数调用的路径分析

在菱形继承结构中，虚函数调用的路径分析如下：

• 通过虚基类（A）调用：当通过A*指针调用D的虚函数时，由于A是虚基类，其虚函数表已被D覆盖。因此，调用会直接跳转到D的虚函数实现，无需this指针调整。

• 通过中间基类（B或C）调用：当通过B或C指针调用D的虚函数时，需要执行以下步骤：

  1. 根据当前指针类型（B或C）找到对应的虚函数表。
  2. 通过虚函数表中的条目找到对应的thunk代码。
  3. thunk代码通过虚基类表中的偏移信息，计算出D对象中A子对象的正确地址。
  4. 将this指针调整为指向该地址后，再通过调整后的this指针访问D的虚函数表。
  5. 最终调用D中覆盖的虚函数实现。

4. 虚继承与虚函数的内存开销

虚继承和虚函数都会引入额外的内存开销：

• 空间开销：

  • 每个虚继承的中间类（如B和C）需要额外的vbptr存储空间（通常是4或8字节）。
  • 虚基类表和虚函数表是静态存储的，驻留在只读内存区域，不占用对象空间。
  • 在最终派生类中，虚基类的成员变量仅存储一次，减少了内存占用。

• 时间开销：

  • 访问虚基类成员需要三次间接寻址：首先通过vptr找到虚函数表，再通过虚函数表找到thunk，最后通过thunk找到最终派生类的虚函数表。
  • 构造和析构过程中需要执行复杂的虚基类初始化和this指针调整逻辑。
  • 虚继承的构造顺序管理比普通继承更复杂，增加了编译时和运行时的开销。

四、实际案例分析

1. 菱形继承构造过程示例

考虑以下菱形继承结构：

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

#include <iostream>

class Base {
public:
    Base(int x) : value(x) { std::cout << "Base构造: " << value << std::endl; }
};

class A : public Base {
public:
    A(int x) : Base(x) {}
    virtual void show() { std::cout << "A::show" << std::endl; }
};

class B : virtual public A {
public:
    B(int x) : A(x) {}
    virtual void show() override { std::cout << "B::show" << std::endl; }
};

class C : virtual public A {
public:
    C(int x) : A(x) {}
    virtual void show() override { std::cout << "C::show" << std::endl; }
};

class D : public B, public C {
public:
    D(int x) : A(x), B(x), C(x) {}
    virtual void show() override { std::cout << "D::show" << std::endl; }
};

2. 虚函数调用示例

通过不同基类指针调用D的虚函数：

• A* a = new D(1); a->show(); → 输出”D::show”
• B* b = new D(1); b->show(); → 输出”D::show”
• C* c = new D(1); c->show(); → 输出”D::show”

3. this指针调整的实现机制

在上述案例中，当通过B*指针调用D的show()函数时，实际的底层实现如下：

1
2
3
4
5
6
7
8
9
10
11
12

// 假设B的虚函数表中存储的是以下内容
// B的虚函数表：
// [0] = B的析构函数地址
// [1] = B::show的地址 → 实际是一个thunk指针

// B::show的thunk实现（伪代码）：
void B::show_thunk(A* this调整) {
    // 计算D对象中A子对象的正确地址
    A* correctThis = this调整 + 虚基类表中的偏移量;
    // 调用D实际的show函数
    D::show(correctThis);
}

通过这种thunk技术，编译器能够确保无论通过哪个基类指针调用，最终都能正确地调用到派生类的虚函数实现。

五、虚继承的优化与权衡

1. 虚继承的适用场景

虚继承虽然强大，但应谨慎使用，仅在以下场景中考虑：

• 解决菱形继承问题：当一个类需要同时继承多个继承自同一基类的中间类时，使用虚继承可以避免数据冗余和访问歧义。
• 接口继承：当多个中间类需要继承同一接口基类时，使用虚继承可以确保最终派生类只保留一个接口实现。
• 共享基类状态：当多个继承路径需要共享同一基类的状态时，虚继承提供了这一机制。

2. 虚继承的性能优化建议

为减少虚继承带来的性能开销，可考虑以下优化：

• 避免不必要的虚继承：仅在真正需要解决菱形继承问题时使用虚继承。
• 使用接口类：将虚基类设计为不包含数据成员的纯接口类，减少内存占用。
• 减少虚函数调用频率：将频繁调用的虚函数改为非虚函数，或通过其他方式（如模板或策略模式）实现多态。
• 合理设计继承层次：避免过深的虚继承层次，减少this指针调整的复杂度。

3. 虚继承与组合模式的比较

在解决类似问题时，组合模式（Composition）可以作为虚继承的替代方案：

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

// 虚继承方案
class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ };

// 组合方案
class A { /* ... */ };
class B {
public:
    B(A* a) : a(a) { /* ... */ }
private:
    A* a;
};
class C {
public:
    C(A* a) : a(a) { /* ... */ }
private:
    A* a;
};
class D {
public:
    D(int x) : a(x), b(&a), c(&a) { /* ... */ }
private:
    A a;
    B b;
    C c;
};

组合模式避免了虚继承的内存和时间开销，但牺牲了部分面向对象的特性（如类型转换和多态继承）。在性能敏感的场景中，组合模式可能是更优选择。

六、总结

虚继承是C++中解决多重继承问题的重要机制，其核心实现依赖于虚基类表（vbtable）和虚基类表指针（vbptr）。虚基类表是静态存储的只读数据结构，存储虚基类子对象的偏移信息；而虚基类表指针是对象的隐式成员，指向对应的虚基类表。虚基类表指针的生命周期与对象一致，但其初始化责任被转移到了最底层派生类。

虚继承类对象的构造遵循严格的顺序规则：虚基类优先构造，非虚基类按声明顺序构造，成员对象按声明顺序构造，最后执行派生类自身的构造函数。最底层派生类负责初始化所有虚基类，并设置中间基类的vbptr。

在菱形继承结构中，虚函数调用的正确性依赖于this指针调整机制。编译器通过生成thunk代码，根据虚基类表中的偏移信息，修正this指针指向，确保无论通过哪个基类指针调用，最终都能正确地动态绑定到派生类的虚函数实现。

虚继承虽然解决了数据冗余和访问歧义问题，但也带来了额外的内存和时间开销。在实际应用中，应根据具体需求权衡虚继承的语义优势与性能开销，必要时考虑组合模式等替代方案。