在 C++ 中，什么是虚拟基类？

Question

我想知道“虚拟基类”是什么以及它的含义。

让我举个例子：

class Foo
{
public:
    void DoSomething() { /* ... */ }
};

class Bar : public virtual Foo
{
public:
    void DoSpecific() { /* ... */ }
};

Answer 1

你有点令人困惑。 我不知道你是否混淆了一些概念。

你的OP中没有虚拟基类。 你只有一个基类。

你做了虚拟继承。 这通常用在多重继承中，以便多个派生类使用基类的成员而不复制它们。

具有纯虚函数的基类不能被实例化。 这需要保罗掌握的语法。 它通常用于派生类必须定义这些函数。

我不想再解释这一点，因为我不完全明白你在问什么。

Answer 2

这意味着对虚函数的调用将被转发到“正确的”类。

C++ FAQ Lite FTW。

简而言之，它经常用于多重继承场景，形成“钻石”层次结构。 当您调用该类中的函数并且该函数需要解析为该底层类之上的类 D1 或 D2 时，虚拟继承将打破底层类中创建的歧义。 有关图表和详细信息，请参阅常见问题解答项。

它也用于姐妹代表团，这是一个强大的功能（尽管不适合胆小的人）。 请参阅此常见问题解答。

另请参阅《Effective C++》第 3 版中的第 40 条（第 2 版中为 43 条）。

Answer 3

虚拟类与虚拟继承不同。 虚拟类无法实例化，虚拟继承完全是另一回事。

维基百科对它的描述比我更好。 http://en.wikipedia.org/wiki/Virtual_inheritance

Answer 4

虚拟继承中使用的虚拟基类是一种在使用多重继承时防止给定类的多个“实例”出现在继承层次结构中的方法。

考虑以下场景：

class A { public: void Foo() {} };
class B : public A {};
class C : public A {};
class D : public B, public C {};

上面的类层次结构导致“可怕的菱形”，如下所示：

  A
 / \
B   C
 \ /
  D

D 的实例将由 B（包括 A）和 C（也包括 A）组成。因此，您有两个“实例” （为了更好的表达）A。

当你遇到这种情况时，你就有可能产生歧义。 当你这样做时会发生什么：

D d;
d.Foo(); // is this B's Foo() or C's Foo() ??

虚拟继承就是为了解决这个问题。 当您在继承类时指定 virtual 时，您就告诉编译器您只需要一个实例。

class A { public: void Foo() {} };
class B : public virtual A {};
class C : public virtual A {};
class D : public B, public C {};

这意味着层次结构中仅包含 A 的一个“实例”。 因此，

D d;
d.Foo(); // no longer ambiguous

这是一个简短的摘要。 有关更多信息，请阅读此和此。 此处也提供了一个很好的示例。

Answer 5

关于内存布局

附带说明一下，Dreaded Diamond 的问题是基类出现了多次。 因此，对于常规继承，您相信您拥有：

  A
 / \
B   C
 \ /
  D

但在内存布局中，您拥有：

A   A
|   |
B   C
 \ /
  D

这解释了为什么在调用 D::foo() 时，您会遇到歧义问题。 但当您想要使用 A 的数据成员时，真正的问题就出现了。 例如，假设我们有：

class A
{
    public :
       foo() ;
       int m_iValue ;
} ;

当您尝试从 D 访问 m_iValue 时，编译器会抗议，因为在层次结构中，它会看到两个 m_iValue，没有之一。 如果您修改其中一个，例如 B::m_iValue（即 B 的 A::m_iValue 父级），C ::m_iValue 不会被修改（即 C 的 A::m_iValue 父级）。

这就是虚拟继承派上用场的地方，有了它，您将回到真正的菱形布局，不仅只有一个 foo() 方法，而且只有一个 m_iValue。

可能会出什么问题？

想象一下：

• A 有一些基本特征。
• B 向其中添加了某种很酷的数据数组（例如）
• C 向其中添加了一些很酷的功能，例如观察者模式（例如，在 m_iValue< /代码>）。
• D 继承自 B 和 C，因此也继承自 A。

对于正常继承，从 D 修改 m_iValue 是不明确的，必须解决这个问题。 即使是这样，D 内部也有两个 m_iValues，所以你最好记住这一点，并同时更新这两个。

使用虚拟继承，从 D 修改 m_iValue 是可以的...但是...假设您有 D。 通过其 C 接口，您附加了一个观察者。 而通过它的B接口，你更新了cool数组，这样就有直接改变m_iValue的副作用...

随着m_iValue的改变直接完成（不使用虚拟访问器方法），通过C“监听”的观察者不会被调用，因为实现监听的代码是在C中，并且B 不知道这一点...

结论

如果您的层次结构中有菱形，则意味着您有 95% 的可能性在所述层次结构中做错了事情。

Answer 6

用虚拟基解释多重继承需要了解 C++ 对象模型。 最好在文章中而不是在评论框中清楚地解释该主题。

我发现解决我对这个主题的所有疑问的最好的、可读的解释是这篇文章： http://www.phpcompiler.org/articles/virtualinheritance.html

您真的不需要阅读有关该主题的任何其他内容（除非您是编译器编写者）读完之后...

Answer 7

虚拟基类是这样的类
无法实例化：你不能
用它创建直接对象。

我认为你混淆了两种截然不同的东西。 虚拟继承与抽象类不同。 虚拟继承修改函数调用的行为； 有时它会解析函数调用，否则会产生歧义，有时它会将函数调用处理推迟到非虚拟继承中期望的类之外的类。

Answer 8

我想补充 OJ 的善意澄清。

虚拟继承并不是没有代价的。 与所有虚拟事物一样，您的性能也会受到影响。 有一种方法可以解决这种性能问题，但可能不太优雅。

您可以向菱形添加另一层，而不是通过虚拟派生来破坏菱形，以获得如下结果：

   B
  / \
D11 D12
 |   |
D21 D22
 \   /
  DD

没有一个类进行虚拟继承，所有类都公开继承。 然后，类 D21 和 D22 将隐藏虚函数 f()，这对于 DD 来说是不明确的，也许可以通过将函数声明为私有来实现。 他们分别定义一个包装函数 f1() 和 f2()，每个调用类本地（私有）f()，从而解决冲突。 如果 DD 类需要 D11::f()，则调用 f1()；如果需要 D12::f()，则调用 f2()。 如果您内联定义包装器，您可能会获得大约零的开销。

当然，如果您可以更改 D11 和 D12，那么您可以在这些类中执行相同的操作，但通常情况并非如此。

Answer 9

除了已经说过的关于多重继承和虚拟继承之外，Dobb 博士的期刊上还有一篇非常有趣的文章： 多重继承被认为有用

Answer 10

Diamond 继承 runnable 使用示例

此示例展示了如何在典型场景中使用虚拟基类：解决 Diamond 继承问题。

考虑下面的工作示例：

main.cpp

#include <cassert>

class A {
    public:
        A(){}
        A(int i) : i(i) {}
        int i;
        virtual int f() = 0;
        virtual int g() = 0;
        virtual int h() = 0;
};

class B : public virtual A {
    public:
        B(int j) : j(j) {}
        int j;
        virtual int f() { return this->i + this->j; }
};

class C : public virtual A {
    public:
        C(int k) : k(k) {}
        int k;
        virtual int g() { return this->i + this->k; }
};

class D : public B, public C {
    public:
        D(int i, int j, int k) : A(i), B(j), C(k) {}
        virtual int h() { return this->i + this->j + this->k; }
};

int main() {
    D d = D(1, 2, 4);
    assert(d.f() == 3);
    assert(d.g() == 5);
    assert(d.h() == 7);
}

编译并运行：

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

如果我们将 virtual 删除到：

class B : public virtual A

我们会得到一堵关于 GCC 无法解析通过 A 继承两次的 D 成员和方法的错误：

main.cpp:27:7: warning: virtual base ‘A’ inaccessible in ‘D’ due to ambiguity [-Wextra]
   27 | class D : public B, public C {
      |       ^
main.cpp: In member function ‘virtual int D::h()’:
main.cpp:30:40: error: request for member ‘i’ is ambiguous
   30 |         virtual int h() { return this->i + this->j + this->k; }
      |                                        ^
main.cpp:7:13: note: candidates are: ‘int A::i’
    7 |         int i;
      |             ^
main.cpp:7:13: note:                 ‘int A::i’
main.cpp: In function ‘int main()’:
main.cpp:34:20: error: invalid cast to abstract class type ‘D’
   34 |     D d = D(1, 2, 4);
      |                    ^
main.cpp:27:7: note:   because the following virtual functions are pure within ‘D’:
   27 | class D : public B, public C {
      |       ^
main.cpp:8:21: note:    ‘virtual int A::f()’
    8 |         virtual int f() = 0;
      |                     ^
main.cpp:9:21: note:    ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
main.cpp:34:7: error: cannot declare variable ‘d’ to be of abstract type ‘D’
   34 |     D d = D(1, 2, 4);
      |       ^
In file included from /usr/include/c++/9/cassert:44,
                 from main.cpp:1:
main.cpp:35:14: error: request for member ‘f’ is ambiguous
   35 |     assert(d.f() == 3);
      |              ^
main.cpp:8:21: note: candidates are: ‘virtual int A::f()’
    8 |         virtual int f() = 0;
      |                     ^
main.cpp:17:21: note:                 ‘virtual int B::f()’
   17 |         virtual int f() { return this->i + this->j; }
      |                     ^
In file included from /usr/include/c++/9/cassert:44,
                 from main.cpp:1:
main.cpp:36:14: error: request for member ‘g’ is ambiguous
   36 |     assert(d.g() == 5);
      |              ^
main.cpp:9:21: note: candidates are: ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
main.cpp:24:21: note:                 ‘virtual int C::g()’
   24 |         virtual int g() { return this->i + this->k; }
      |                     ^
main.cpp:9:21: note:                 ‘virtual int A::g()’
    9 |         virtual int g() = 0;
      |                     ^
./main.out

在 GCC 9.3.0、Ubuntu 20.04 上测试。

Answer 11

常规继承

对于典型的 3 级非钻石非虚拟继承继承，当您实例化一个新的最派生对象时，将调用 new 并从堆中解析该对象所需的大小编译器的类类型并传递给 new。

new 有一个签名：

_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc)

并调用 malloc，返回 void 指针

这个地址然后传递给最底层派生对象的构造函数，该构造函数将立即调用中间的构造函数构造函数，然后中间构造函数将立即调用基本构造函数。 然后，基类在对象的开头存储指向其虚拟表的指针，然后在其后面存储其属性。 然后返回到中间构造函数，该构造函数将其虚拟表指针存储在同一位置，然后将其属性存储在基本构造函数存储的属性之后。 然后，它返回到最派生的构造函数，该构造函数在同一位置存储指向其虚拟表的指针，然后将其属性存储在中间构造函数存储的属性之后。

由于虚拟表指针被覆盖，因此虚拟表指针最终始终是最派生的类之一。 虚拟性向最派生的类传播，因此如果某个函数在中间类中是虚拟的，那么它在最派生的类中也将是虚拟的，但在基类中不是虚拟的。 如果您将最派生类的实例多态转换为指向基类的指针，则编译器不会将其解析为对虚拟表的间接调用，而是直接调用该函数A::function()< /代码>。 如果一个函数对于您将其转换为的类型来说是虚拟的，那么它将解析为对虚拟表的调用，该虚拟表将始终是最派生类的虚拟表。 如果该类型不是虚拟的，那么它将只调用 Type::function() 并将对象指针传递给它，并强制转换为 Type。

实际上，当我说指向其虚拟表的指针时，它实际上始终是虚拟表中的偏移量 16。

vtable for Base:
        .quad   0
        .quad   typeinfo for Base
        .quad   Base::CommonFunction()
        .quad   Base::VirtualFunction()

pointer is typically to the first function i.e. 

        mov     edx, OFFSET FLAT:vtable for Base+16

如果 virtual 在派生程度较低的类中是 virtual，则在派生程度较高的类中不再需要 virtual，因为它会向派生程度最高的类的方向向下传播。 但它可以用来表明该函数确实是一个虚函数，而不必检查它继承的类的类型定义。 当一个函数被声明为 virtual 时，从那时起，仅使用继承链中的最后一个实现，但在此之前，如果该对象被强制转换为该类中之前的类的类型，则该函数仍然可以非虚拟地使用。定义该方法的继承链。 在该名称和签名的方法的虚拟性开始之前，它可以在链中之前的多个类中进行非虚拟定义，并且它们在引用时将使用自己的方法（并且链中该定义之后的所有类都将使用该方法）定义（如果它们没有自己的定义），这与虚拟相反，虚拟总是使用最终定义）。 当一个方法被声明为虚拟时，它必须在该类或继承链中的更多派生类中实现，以便构建完整的对象才能使用。

override 是另一个编译器防护，它表示此函数正在覆盖某些内容，如果没有覆盖，则抛出编译器错误。

= 0 表示这是一个抽象函数

final 防止在更派生的类中再次实现虚函数，并确保最远派生类的虚表包含该类的最终函数。

= default 在文档中明确指出编译器将使用默认实现

= delete 如果尝试调用此函数，则会出现编译器错误

如果调用非虚函数，它将解析为正确的方法定义，而无需通过虚拟表。 如果您调用在继承类中具有最终定义的虚拟函数，那么如果您在调用方法时未将对象指针强制转换为该类型，它将使用其虚拟表并自动将子对象传递给它。 如果您在该类型的指针上调用在最派生类中定义的虚拟函数，那么它将使用其虚拟表，该虚拟表将是对象开头的虚拟表。 如果您在继承类型的指针上调用它，并且该函数在该类中也是虚拟的，那么它将使用该子对象的 vtable 指针，在第一个子对象的情况下，该指针将与最派生类相同的指针，它不会包含 thunk，因为对象和子对象的地址相同，因此它就像自动重铸此指针的方法一样简单，但对于第二个子对象，其 vtable 将包含一个非- virtual thunk 将继承类型的对象的指针转换为最底层派生类中的实现所期望的类型，即完整对象，因此偏移子对象指针以指向完整对象，并且在基子对象的情况下，将需要一个虚拟 thunk 将指向基类的指针偏移到完整对象，以便可以通过方法隐藏对象参数类型对其进行重铸。

使用带有引用运算符而不是通过指针（取消引用运算符）的对象会破坏多态性，并将虚拟方法视为常规方法。 这是因为由于切片，非指针类型上的多态转换不会发生。

虚拟继承

考虑

class Base
  {
      int a = 1;
      int b = 2;
  public:
      void virtual CommonFunction(){} ; //define empty method body
      void virtual VirtualFunction(){} ;
  };


class DerivedClass1: virtual public Base
  {
      int c = 3;
  public:
    void virtual DerivedCommonFunction(){} ;
     void virtual VirtualFunction(){} ;
  };
  
  class DerivedClass2 : virtual public Base
 {
     int d = 4;
 public:
     //void virtual DerivedCommonFunction(){} ;    
     void virtual VirtualFunction(){} ;
     void virtual DerivedCommonFunction2(){} ;
 };

class DerivedDerivedClass :  public DerivedClass1, public DerivedClass2
 {
   int e = 5;
 public:
     void virtual DerivedDerivedCommonFunction(){} ;
     void virtual VirtualFunction(){} ;
 };
 
 int main () {
   DerivedDerivedClass* d = new DerivedDerivedClass;
   d->VirtualFunction();
   d->DerivedCommonFunction();
   d->DerivedCommonFunction2();
   d->DerivedDerivedCommonFunction();
   ((DerivedClass2*)d)->DerivedCommonFunction2();
   ((Base*)d)->VirtualFunction();
 }

如果没有虚拟继承 bass 类，您将得到一个如下所示的对象：

而不是这样：

即，将有 2 个基础对象。

在上面的虚拟钻石继承情况中，调用new后，它将为对象分配的空间的地址传递给最底层的派生构造函数DerivedDerivedClass::DerivedDerivedClass()，它首先调用 Base::Base()，将其 vtable 写入基础的专用子对象中，然后 DerivedDerivedClass::DerivedDerivedClass() 调用 DerivedClass1::DerivedClass1 ()，它将其虚拟表指针写入其子对象，并通过查询传递的 VTT 覆盖该对象末尾的基子对象指针，然后调用 DerivedClass1::DerivedClass1() 执行相同的操作，最后 DerivedDerivedClass::DerivedDerivedClass() 使用该继承类的虚拟表指针覆盖所有 3 个指针。 这不是（如上面第一张图所示） DerivedDerivedClass::DerivedDerivedClass() 调用 DerivedClass1::DerivedClass1() 和调用 Base::Base ()（覆盖虚拟指针），返回，将地址偏移到下一个子对象，调用 DerivedClass2::DerivedClass2()，然后还调用 Base::Base ()，覆盖该虚拟指针，返回，然后 DerivedDerivedClass 构造函数用其虚拟表指针覆盖两个虚拟指针（在本例中，最派生的构造函数的虚拟表包含 2 个子表）共 3)。

以下全部是在调试模式 -O0 下编译的，因此会出现冗余汇编

main:
.LFB8:
        push    rbp
        mov     rbp, rsp
        push    rbx
        sub     rsp, 24
        mov     edi, 48 //pass size to new
        call    operator new(unsigned long) //call new
        mov     rbx, rax  //move the address of the allocation to rbx
        mov     rdi, rbx  //move it to rdi i.e. pass to the call
        call    DerivedDerivedClass::DerivedDerivedClass() [complete object constructor] //construct on this address
        mov     QWORD PTR [rbp-24], rbx  //store the address of the object on the stack as the d pointer variable on -O0, will be optimised off on -Ofast if the address of the pointer itself isn't taken in the code, because this address does not need to be on the stack, it can just be passed in a register to the subsequent methods

另外，如果代码是 DerivedDerivedClass d = DerivedDerivedClass()，则 main 函数将如下所示：

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 48 // make room for and zero 48 bytes on the stack for the 48 byte object, no extra padding required as the frame is 64 bytes with `rbp` and return address of the function it calls (no stack params are passed to any function it calls), hence rsp will be aligned by 16 assuming it was aligned at the start of this frame
        mov     QWORD PTR [rbp-48], 0
        mov     QWORD PTR [rbp-40], 0
        mov     QWORD PTR [rbp-32], 0
        mov     QWORD PTR [rbp-24], 0
        mov     QWORD PTR [rbp-16], 0
        mov     QWORD PTR [rbp-8], 0
        lea     rax, [rbp-48] // load the address of the cleared 48 bytes
        mov     rdi, rax // pass the address as a pointer to the 48 bytes cleared as the first parameter to the constructor
        call    DerivedDerivedClass::DerivedDerivedClass() [complete object constructor]
        //address is not stored on the stack because the object is used directly -- there is no pointer variable -- d refers to the object on the stack as opposed to being a pointer

回到最初的示例，DerivedDerivedClass 构造函数：

DerivedDerivedClass::DerivedDerivedClass() [complete object constructor]:
.LFB20:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
.LBB5:
        mov     rax, QWORD PTR [rbp-8] // object address now in rax 
        add     rax, 32 //increment address by 32
        mov     rdi, rax // move object address+32 to rdi i.e. pass to call
        call    Base::Base() [base object constructor]
        mov     rax, QWORD PTR [rbp-8] //move object address to rax
        mov     edx, OFFSET FLAT:VTT for DerivedDerivedClass+8 //move address of VTT+8 to edx
        mov     rsi, rdx //pass VTT+8 address as 2nd parameter 
        mov     rdi, rax //object address as first (DerivedClass1 subobject)
        call    DerivedClass1::DerivedClass1() [base object constructor]
        mov     rax, QWORD PTR [rbp-8] //move object address to rax
        add     rax, 16  //increment object address by 16
        mov     edx, OFFSET FLAT:VTT for DerivedDerivedClass+24  //store address of VTT+24 in edx
        mov     rsi, rdx //pass address of VTT+24 as second parameter
        mov     rdi, rax //address of DerivedClass2 subobject as first
        call    DerivedClass2::DerivedClass2() [base object constructor]
        mov     edx, OFFSET FLAT:vtable for DerivedDerivedClass+24 //move this to edx
        mov     rax, QWORD PTR [rbp-8] // object address now in rax
        mov     QWORD PTR [rax], rdx. //store address of vtable for DerivedDerivedClass+24 at the start of the object
        mov     rax, QWORD PTR [rbp-8] // object address now in rax
        add     rax, 32  // increment object address by 32
        mov     edx, OFFSET FLAT:vtable for DerivedDerivedClass+120 //move this to edx
        mov     QWORD PTR [rax], rdx  //store vtable for DerivedDerivedClass+120 at object+32 (Base) 
        mov     edx, OFFSET FLAT:vtable for DerivedDerivedClass+72 //store this in edx
        mov     rax, QWORD PTR [rbp-8] //move object address to rax
        mov     QWORD PTR [rax+16], rdx //store vtable for DerivedDerivedClass+72 at object+16 (DerivedClass2)
        mov     rax, QWORD PTR [rbp-8]
        mov     DWORD PTR [rax+28], 5 // stores e = 5 in the object
.LBE5:
        nop
        leave
        ret

DerivedDerivedClass 构造函数使用指向对象偏移量的指针调用 Base::Base() 32. Base 将一个指向其虚拟表的指针存储在它收到的地址及其后面的成员中。

Base::Base() [base object constructor]:
.LFB11:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi //stores address of object on stack (-O0)
.LBB2:
        mov     edx, OFFSET FLAT:vtable for Base+16  //puts vtable for Base+16 in edx
        mov     rax, QWORD PTR [rbp-8] //copies address of object from stack to rax
        mov     QWORD PTR [rax], rdx  //stores it address of object
        mov     rax, QWORD PTR [rbp-8] //copies address of object on stack to rax again
        mov     DWORD PTR [rax+8], 1 //stores a = 1 in the object
        mov     rax, QWORD PTR [rbp-8] //junk from -O0
        mov     DWORD PTR [rax+12], 2  //stores b = 2 in the object
.LBE2:
        nop
        pop     rbp
        ret

DerivedDerivedClass::DerivedDerivedClass() 然后使用指向对象偏移量 0 的指针调用 DerivedClass1::DerivedClass1()，并传递 DerivedDerivedClass+8 的 VTT 地址

DerivedClass1::DerivedClass1() [base object constructor]:
.LFB14:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi //address of object
        mov     QWORD PTR [rbp-16], rsi  //address of VTT+8
.LBB3:
        mov     rax, QWORD PTR [rbp-16]  //address of VTT+8 now in rax
        mov     rdx, QWORD PTR [rax]     //address of DerivedClass1-in-DerivedDerivedClass+24 now in rdx
        mov     rax, QWORD PTR [rbp-8]   //address of object now in rax
        mov     QWORD PTR [rax], rdx     //store address of DerivedClass1-in-.. in the object
        mov     rax, QWORD PTR [rbp-8]  // address of object now in rax
        mov     rax, QWORD PTR [rax]    //address of DerivedClass1-in.. now implicitly in rax
        sub     rax, 24                 //address of DerivedClass1-in-DerivedDerivedClass+0 now in rax
        mov     rax, QWORD PTR [rax]    //value of 32 now in rax
        mov     rdx, rax                // now in rdx
        mov     rax, QWORD PTR [rbp-8]  //address of object now in rax
        add     rdx, rax                //address of object+32 now in rdx
        mov     rax, QWORD PTR [rbp-16]  //address of VTT+8 now in rax
        mov     rax, QWORD PTR [rax+8]   //derference VTT+8+8; address of DerivedClass1-in-DerivedDerivedClass+72 (Base::CommonFunction()) now in rax
        mov     QWORD PTR [rdx], rax     //store at address object+32 (offset to Base)
        mov     rax, QWORD PTR [rbp-8]  //store address of object in rax, return
        mov     DWORD PTR [rax+8], 3    //store its attribute c = 3 in the object
.LBE3:
        nop
        pop     rbp
        ret

VTT for DerivedDerivedClass:
        .quad   vtable for DerivedDerivedClass+24
        .quad   construction vtable for DerivedClass1-in-DerivedDerivedClass+24 //(DerivedClass1 uses this to write its vtable pointer)
        .quad   construction vtable for DerivedClass1-in-DerivedDerivedClass+72 //(DerivedClass1 uses this to overwrite the base vtable pointer)
        .quad   construction vtable for DerivedClass2-in-DerivedDerivedClass+24
        .quad   construction vtable for DerivedClass2-in-DerivedDerivedClass+72
        .quad   vtable for DerivedDerivedClass+120 // DerivedDerivedClass supposed to use this to overwrite Bases's vtable pointer
        .quad   vtable for DerivedDerivedClass+72 // DerivedDerivedClass supposed to use this to overwrite DerivedClass2's vtable pointer
//although DerivedDerivedClass uses vtable for DerivedDerivedClass+72 and DerivedDerivedClass+120 directly to overwrite them instead of going through the VTT

construction vtable for DerivedClass1-in-DerivedDerivedClass:
        .quad   32
        .quad   0
        .quad   typeinfo for DerivedClass1
        .quad   DerivedClass1::DerivedCommonFunction()
        .quad   DerivedClass1::VirtualFunction()
        .quad   -32
        .quad   0
        .quad   -32
        .quad   typeinfo for DerivedClass1
        .quad   Base::CommonFunction()
        .quad   virtual thunk to DerivedClass1::VirtualFunction()
construction vtable for DerivedClass2-in-DerivedDerivedClass:
        .quad   16
        .quad   0
        .quad   typeinfo for DerivedClass2
        .quad   DerivedClass2::VirtualFunction()
        .quad   DerivedClass2::DerivedCommonFunction2()
        .quad   -16
        .quad   0
        .quad   -16
        .quad   typeinfo for DerivedClass2
        .quad   Base::CommonFunction()
        .quad   virtual thunk to DerivedClass2::VirtualFunction()
vtable for DerivedDerivedClass:
        .quad   32
        .quad   0
        .quad   typeinfo for DerivedDerivedClass
        .quad   DerivedClass1::DerivedCommonFunction()
        .quad   DerivedDerivedClass::VirtualFunction()
        .quad   DerivedDerivedClass::DerivedDerivedCommonFunction()
        .quad   16
        .quad   -16
        .quad   typeinfo for DerivedDerivedClass
        .quad   non-virtual thunk to DerivedDerivedClass::VirtualFunction()
        .quad   DerivedClass2::DerivedCommonFunction2()
        .quad   -32
        .quad   0
        .quad   -32
        .quad   typeinfo for DerivedDerivedClass
        .quad   Base::CommonFunction()
        .quad   virtual thunk to DerivedDerivedClass::VirtualFunction()

virtual thunk to DerivedClass1::VirtualFunction():
        mov     r10, QWORD PTR [rdi]
        add     rdi, QWORD PTR [r10-32]
        jmp     .LTHUNK0
virtual thunk to DerivedClass2::VirtualFunction():
        mov     r10, QWORD PTR [rdi]
        add     rdi, QWORD PTR [r10-32]
        jmp     .LTHUNK1
virtual thunk to DerivedDerivedClass::VirtualFunction():
        mov     r10, QWORD PTR [rdi]
        add     rdi, QWORD PTR [r10-32]
        jmp     .LTHUNK2
non-virtual thunk to DerivedDerivedClass::VirtualFunction():
        sub     rdi, 16
        jmp     .LTHUNK3

        .set    .LTHUNK0,DerivedClass1::VirtualFunction()
        .set    .LTHUNK1,DerivedClass2::VirtualFunction()
        .set    .LTHUNK2,DerivedDerivedClass::VirtualFunction()
        .set    .LTHUNK3,DerivedDerivedClass::VirtualFunction()

每个继承类都有自己的构造虚表，而最底层的派生类 DerivedDerivedClass 有一个虚表，每个类都有一个子表，它使用指向子表的指针来覆盖构造虚表继承类的构造函数为每个子对象存储的指针。 每个需要 thunk 的虚拟方法（虚拟 thunk 将对象指针从基对象偏移到对象的开头，非虚拟 thunk 将对象指针从非基对象的继承类对象偏移到对象的开头DerivedDerivedClass 类型的整个对象）。 DerivedDerivedClass 构造函数还使用虚拟表表 (VTT) 作为它需要使用的所有虚拟表指针的串行列表，并将其传递给每个构造函数（以及构造函数所在的子对象地址） for)，它们用它来覆盖它们和基的 vtable 指针。

DerivedDerivedClass::DerivedDerivedClass() 然后将对象的地址+16 和 DerivedDerivedClass+2​​4 的 VTT 地址传递给 DerivedClass2::DerivedClass2() 的程序集与 DerivedClass1::DerivedClass1() 相同，但 mov DWORD PTR [rax+8], 3 行显然有 4 而不是 3 d = 4。

此后，它将对象中的所有 3 个虚拟表指针替换为指向 DerivedDerivedClass 的 vtable 中该类表示形式的偏移量的指针。

main 中对 d->VirtualFunction() 的调用：

        mov     rax, QWORD PTR [rbp-24] //store pointer to object (and hence vtable pointer) in rax
        mov     rax, QWORD PTR [rax] //dereference this pointer to vtable pointer and store virtual table pointer in rax
        add     rax, 8 // add 8 to the pointer to get the 2nd function pointer in the table
        mov     rdx, QWORD PTR [rax] //dereference this pointer to get the address of the method to call
        mov     rax, QWORD PTR [rbp-24] //restore pointer to object in rax (-O0 is inefficient, yes)
        mov     rdi, rax  //pass object to the method
        call    rdx

d->DerivedCommonFunction();:

        mov     rax, QWORD PTR [rbp-24]
        mov     rdx, QWORD PTR [rbp-24]
        mov     rdx, QWORD PTR [rdx]
        mov     rdx, QWORD PTR [rdx]
        mov     rdi, rax  //pass object to method
        call    rdx  //call the first function in the table

d->; DerivedCommonFunction2();:

        mov     rax, QWORD PTR [rbp-24] //get the object pointer
        lea     rdx, [rax+16]  //get the address of the 2nd subobject in the object
        mov     rax, QWORD PTR [rbp-24] //get the object pointer
        mov     rax, QWORD PTR [rax+16] // get the vtable pointer of the 2nd subobject
        add     rax, 8  //call the 2nd function in this table
        mov     rax, QWORD PTR [rax]  //get the address of the 2nd function
        mov     rdi, rdx  //call it and pass the 2nd subobject to it
        call    rax

d->DerivedDerivedCommonFunction();:

        mov     rax, QWORD PTR [rbp-24] //get the object pointer
        mov     rax, QWORD PTR [rax] //get the vtable pointer
        add     rax, 16 //get the 3rd function in the first virtual table (which is where virtual functions that that first appear in the most derived class go, because they belong to the full object which uses the virtual table pointer at the start of the object)
        mov     rdx, QWORD PTR [rax] //get the address of the object
        mov     rax, QWORD PTR [rbp-24]
        mov     rdi, rax  //call it and pass the whole object to it
        call    rdx

((DerivedClass2*)d)->DerivedCommonFunction2();:

//it casts the object to its subobject and calls the corresponding method in its virtual table, which will be a non-virtual thunk

        cmp     QWORD PTR [rbp-24], 0
        je      .L14
        mov     rax, QWORD PTR [rbp-24]
        add     rax, 16
        jmp     .L15
.L14:
        mov     eax, 0
.L15:
        cmp     QWORD PTR [rbp-24], 0
        cmp     QWORD PTR [rbp-24], 0
        je      .L18
        mov     rdx, QWORD PTR [rbp-24]
        add     rdx, 16
        jmp     .L19
.L18:
        mov     edx, 0
.L19:
        mov     rdx, QWORD PTR [rdx]
        add     rdx, 8
        mov     rdx, QWORD PTR [rdx]
        mov     rdi, rax
        call    rdx

((Base*)d)->VirtualFunction();:

//it casts the object to its subobject and calls the corresponding function in its virtual table, which will be a virtual thunk

        cmp     QWORD PTR [rbp-24], 0
        je      .L20
        mov     rax, QWORD PTR [rbp-24]
        mov     rax, QWORD PTR [rax]
        sub     rax, 24
        mov     rax, QWORD PTR [rax]
        mov     rdx, rax
        mov     rax, QWORD PTR [rbp-24]
        add     rax, rdx
        jmp     .L21
.L20:
        mov     eax, 0
.L21:
        cmp     QWORD PTR [rbp-24], 0
        cmp     QWORD PTR [rbp-24], 0
        je      .L24
        mov     rdx, QWORD PTR [rbp-24]
        mov     rdx, QWORD PTR [rdx]
        sub     rdx, 24
        mov     rdx, QWORD PTR [rdx]
        mov     rcx, rdx
        mov     rdx, QWORD PTR [rbp-24]
        add     rdx, rcx
        jmp     .L25
.L24:
        mov     edx, 0
.L25:
        mov     rdx, QWORD PTR [rdx]
        add     rdx, 8
        mov     rdx, QWORD PTR [rdx]
        mov     rdi, rax
        call    rdx