C++ 虚函数表解析（64位版）

蔚天灿雨

已于 2022-09-19 16:54:11 修改

阅读量558

点赞数

分类专栏：实验测试-语言特性底层函数实现/数据结构找工作文章标签： c++ 开发语言

于 2022-08-03 22:01:33 首次发布

本文链接：https://blog.csdn.net/ahundredmile/article/details/126149764

版权

底层函数实现/数据结构同时被 3 个专栏收录

25 篇文章

订阅专栏

实验测试-语言特性

12 篇文章

订阅专栏

找工作

8 篇文章

订阅专栏

C++ 虚函数表解析（64位系统版）

备注：本文的主要内容摘自 C++ 虚函数表解析—*陈皓*，本文主要是重做了原文的实验部分（原文是32位系统，我这里是64位系统）。

文章目录

C++ 虚函数表解析（64位系统版）
0.前言
1.虚函数表
2.一般继承（无虚函数覆盖）
3.一般继承（有虚函数覆盖）
4.多重继承（无虚函数覆盖）
5.多重继承（有虚函数覆盖）
6.安全性
- 6.1通过父类型的指针访问子类自己的虚函数
- 6.2访问non-public的虚函数
7.结束语
8.例程

0.前言

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家一个清晰的剖析。

当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。

言归正传，让我们一起进入虚函数的世界。

1.虚函数表

对C++了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {
public: 
    virtual void f(void) {cout << "Base::f" << endl;}
    virtual void g(void) {cout << "Base::g" << endl;}
    virtual void h(void) {cout << "Base::h" << endl;}
};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。下面是实际例程：

// g++ virtual_funcs.cpp -o virtual_funcs
// ./virtual_funcs
#include <bits/stdc++.h>

using namespace std;

// typedef unsigned long uint64_t;


class Base {
public: 
    virtual void f(void) {cout << "Base::f" << endl;}
    virtual void g(void) {cout << "Base::g" << endl;}
    virtual void h(void) {cout << "Base::h" << endl;}
};

typedef void(*Func)(void); //这是在声明一个void(*)() 类型的函数指针Func


int main() {
    Base b;
    Func pFunc = NULL;
    cout << "虚函数表地址：" << (uint64_t*)(&b) << endl;
    cout << "虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&b) << endl;

    // Invoke the first virtual function 
    pFunc = (Func)*((uint64_t*)*(uint64_t*)(&b));
    pFunc();
    exit(0);
}

实际运行结果如下：(Ubuntu - Linux - 64bit) （注意这里是64bit系统，如果是32bit请将uint64_t替换为int）。

虚函数表地址：0x7ffffbca1e18
虚函数表 — 第一个函数地址：0x7fc0b3601d58
Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b（即Base类的实体的地址——因为我是64bit的机器，因此这个值其实是64bit的）转成uint64_t *（解析为unsigned long的64bit的地址）类型，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把uint64_t *强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

// 如果调用Base::f()，Base::g()， Base::h()
((Func)*((uint64_t*)*(uint64_t*)(&b)+0))();  // Base::f()
((Func)*((uint64_t*)*(uint64_t*)(&b)+1))();  // Base::g()
((Func)*((uint64_t*)*(uint64_t*)(&b)+2))();  // Base::h()

这里解释一下，为什么可以用如上代码：

&b是Base实体b的首地址，而按照前面介绍，所有实体的虚函数表都放在实体的首地址，因此&b指向的内容，就是虚函数的表头，即：

*(uint64_t*)(&b) 就是虚函数表头（即虚函数表的首地址），因此👇

*(uint64_t*)(&b)+0 就是虚函数表中第一个元素的内容；
*(uint64_t*)(&b)+0就是虚函数表中第二个元素的内容；
*(uint64_t*)(&b)+0就是虚函数表中第三个元素的内容；

虚函数表中的元素，是函数的地址，因此，*((uint64_t*)*(uint64_t*)(&b)+0)就是表中的内容了，但是这里还有问题，这个指针应该解释称什么类型捏？——应该是void类型才可以运行，因此，(Func)*((uint64_t*)*(uint64_t*)(&b)+0)就是Base::f，后面加一个()变成Base::f()就可以运行了。

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

在这里插入图片描述

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在Win下，这个值是NULL。而在Ubuntu + Linux 下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

2.一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d 的虚函数表如下：

在这里插入图片描述

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

验证程序如下👇

// g++ virtual_funcs.cpp -o virtual_funcs
// ./virtual_funcs
#include <bits/stdc++.h>

using namespace std;

// typedef unsigned long uint64_t;


class Base {
public: 
    virtual void f(void) {cout << "Base::f" << endl;}
    virtual void g(void) {cout << "Base::g" << endl;}
    virtual void h(void) {cout << "Base::h" << endl;}
};

class Derive : public Base {
    virtual void f1(void) {cout << "Derive::f1" << endl;}
    virtual void g1(void) {cout << "Derive::g1" << endl;}
    virtual void h1(void) {cout << "Derive::h1" << endl;}
};

typedef void(*Func)(void); //这是在声明一个void(*)() 类型的函数指针Func


void test_base_virtual_table();
void test_derive_virtual_table();
int main() {
    // test_base_virtual_table();
    test_derive_virtual_table();
    exit(0);
}

void test_base_virtual_table() {
    Base b;
    Func pFunc = NULL;
    cout << "虚函数表地址：" << (uint64_t*)(&b) << endl;
    cout << "虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&b) << endl;

    // Invoke the first virtual function 
    pFunc = (Func)*((uint64_t*)*(uint64_t*)(&b));
    pFunc();

    // 如果调用Base::f()，Base::g()， Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+0))();  // Base::f()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+2))();  // Base::h()
}
void test_derive_virtual_table() {
    Derive d;
    Func pFunc = NULL;
    cout << "Derive 虚函数表地址：" << (uint64_t*)(&d) << endl;
    cout << "Derive 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&d) << endl;

    // // Invoke the first virtual function 
    // pFunc = (Func)*((uint64_t*)*(uint64_t*)(&d));
    // pFunc();

    // 调用Base::f()，Base::g()， Base::h()，Derive::f1()，Derive::g1()，Derive::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+0))();  // Base::f()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+3))();  // Derive::f1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+4))();  // Derive::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+5))();  // Derive::h1()
}

输出结果如下👇

Derive 虚函数表地址：0x7fffcb5bf178
Derive 虚函数表 — 第一个函数地址：0x7f3e47e01cf8
Base::f
Base::g
Base::h
Derive::f1
Derive::g1
Derive::h1

3.一般继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序，

class Base {
public: 
    virtual void f(void) {cout << "Base::f" << endl;}
    virtual void g(void) {cout << "Base::g" << endl;}
    virtual void h(void) {cout << "Base::h" << endl;}
};

// 注意这里的继承是有覆盖的（将f覆盖）
class Derive1 : public Base {
    virtual void f(void) {cout << "Derive::f" << endl;}
    virtual void g1(void) {cout << "Derive::g1" << endl;}
    virtual void h1(void) {cout << "Derive::h1" << endl;}
};

void test_derive1_virtual_table();
int main() {
    // test_base_virtual_table();
    // test_derive_virtual_table();
    test_derive1_virtual_table();
    exit(0);
}

void test_derive1_base_virtual_table() {
    Base* b = new Derive1();
    // Derive1 d1;
    Func pFunc = NULL;
    cout << "Derive1 虚函数表地址：" << (uint64_t*)(b) << endl;
    cout << "Derive1 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(b) << endl;

    // 调用Derive1::f()，Base::g()， Base::h()，Derive1::g1()，Derive1::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+0))();  // Derive1::f()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+3))();  // Derive1::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+4))();  // Derive1::h1()

    b -> f(); 
}

输出结果如下👇

levi@LEVI1:~/code$ ./virtual_funcs
Derive1 虚函数表地址：0x7fffde44b4f8
Derive1 虚函数表 — 第一个函数地址：0x7fe7db001cf8
Base::f
Base::g
Base::h
Derive1::g1
Derive1::h1

由b所指的内存中的虚函数表的f()的位置已经被Derive1::f()函数地址所取代，于是在实际调用发生时，是Derive1::f()被调用了。这就实现了多态。

但是这里的这两条语句，其实是很不安全的👇

((Func)*((uint64_t*)*(uint64_t*)(b)+3))();  // Derive1::g1()
((Func)*((uint64_t*)*(uint64_t*)(b)+4))();  // Derive1::h1()

理论上，我们不应该具备从b 访问h1() 和 g1() 的能力。即，如果我们使用b -> g1()是会报错的，但是这里下面两条语句可以正确执行，是因为我们把g1和h1当作普通的函数来调用，强制类型转换导致g1和h1已经不知道调用它们的类是什么了。关于这一点可以看下面的例子👇（不看也行，并不影响对虚函数的学习）

我们将Derive1::f()稍微修改一下，让他输出this指针。

class Derive1 : public Base {
    // int a = 123;
    // virtual void f(void) {cout << "Derive1::f" << endl;}
    virtual void f(void) {cout << "in Derive1::f, this = " << this << endl;}
    virtual void g1(void) {cout << "Derive1::g1" << endl;}
    virtual void h1(void) {cout << "Derive1::h1" << endl;}
};

void test_derive1_base_virtual_table() {
    Base* b = new Derive1();
    // Derive1 d1;
    Func pFunc = NULL;
    cout << "Derive1 虚函数表地址：" << (uint64_t*)(b) << endl;
    cout << "Derive1 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(b) << endl;

    // 调用Derive1::f()，Base::g()， Base::h()，Derive1::g1()，Derive1::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+0))();  // Derive1::f()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+3))();  // Derive1::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+4))();  // Derive1::h1()

    b -> f();
}

输出结果如👇，可以看到，两次输出的this不同，显然b -> f()输出的是b的地址，是正确的。那么((Func)*((uint64_t*)*(uint64_t*)(b)+0))();的输出呢？我也不知道是什么，我猜是函数类的指针this（因为我们的强制类型转换，转换后的函数，已经完全不知道它是属于哪个对象了）。

levi@LEVI1:~/code$ ./virtual_funcs
Derive1 虚函数表地址：0x7fffe2940e70
Derive1 虚函数表 — 第一个函数地址：0x7f38d5001ca0
in Derive1::f, this = 0x7f38d465c760
Base::g
Base::h
Derive1::g1
Derive1::h1
in Derive1::f, this = 0x7fffe2940e70

4.多重继承（无虚函数覆盖）

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TT5jqQj0-1659535044906)(https://raw.githubusercontent.com/LEVI-Tempset/picgo-pics-for-typora/main/imgo_vtable4.JPG)]

我们可以看到：

1）每个父类都有自己的虚表。

2）子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

5.多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

class Base1 {
public:
        virtual void f() { cout << "Base1::f" << endl; }
        virtual void g() { cout << "Base1::g" << endl; }
        virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
        virtual void f() { cout << "Base2::f" << endl; }
        virtual void g() { cout << "Base2::g" << endl; }
        virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
        virtual void f() { cout << "Base3::f" << endl; }
        virtual void g() { cout << "Base3::g" << endl; }
        virtual void h() { cout << "Base3::h" << endl; }
};

class Derive3 : public Base1, public Base2, public Base3 {
public:
        virtual void f() { cout << "Derive3::f" << endl; }
        virtual void g1() { cout << "Derive3::g1" << endl; }
};

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

void test_multi_base_vitual_table() {
    Derive3 d;
    Base1 *b1 = &d;
    Base2 *b2 = &d;
    Base3 *b3 = &d;
    b1 -> f(); //Derive3::f()
    b2 -> f(); //Derive3::f()
    b3 -> f(); //Derive3::f()
    b1 -> g(); //Base1::g()
    b2 -> g(); //Base2::g()
    b3 -> g(); //Base3::g()
}

6.安全性

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

6.1通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

Base1 *b1 = new Derive();
b1->f1();  //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

（这里指的就是前面我对this的调用的例子，也就是通过C++的地址，我们就可以访问和调用函数，并不用真正的通过对象来进行访问，这是十分危险的！）

6.2访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。（同样是通过指针，调用函数（而且是private的函数——理论上没有Base类我们是无法访问的，但是这里我们通过强制类型转换，就把函数转换成一个普通的函数，失去了类的封装特性））

class Base {
private:
	virtual void f() { cout << "Base::f" << endl; }
};
class Derive : public Base{
};

typedef void(*Fun)(void);

void main() {
    Derive d;
    Fun  pFun = (Fun)*((int*)*(int*)(&d)+0);
    pFun();
}

7.结束语

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。

原文的联系方式：

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我交流，我的MSN和Email是：haoel@hotmail.com

8.例程

本文的示例程序如下👇（包含文中的所有示例）

// g++ virtual_funcs.cpp -o virtual_funcs
// ./virtual_funcs
#include <bits/stdc++.h>

using namespace std;

// typedef unsigned long uint64_t;


class Base {
public: 
    virtual void f(void) {cout << "Base::f" << endl;}
    virtual void g(void) {cout << "Base::g" << endl;}
    virtual void h(void) {cout << "Base::h" << endl;}
};

class Derive : public Base {
    virtual void f1(void) {cout << "Derive::f1" << endl;}
    virtual void g1(void) {cout << "Derive::g1" << endl;}
    virtual void h1(void) {cout << "Derive::h1" << endl;}
};

// 注意这里的继承是有覆盖的（将f覆盖）
class Derive1 : public Base {
    // int a = 123;
    // virtual void f(void) {cout << "Derive1::f" << endl;}
    virtual void f(void) {cout << "in Derive1::f, this = " << this << endl;}
    virtual void g1(void) {cout << "Derive1::g1" << endl;}
    virtual void h1(void) {cout << "Derive1::h1" << endl;}
};

class Base1 {
public:
        virtual void f() { cout << "Base1::f" << endl; }
        virtual void g() { cout << "Base1::g" << endl; }
        virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
        virtual void f() { cout << "Base2::f" << endl; }
        virtual void g() { cout << "Base2::g" << endl; }
        virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
        virtual void f() { cout << "Base3::f" << endl; }
        virtual void g() { cout << "Base3::g" << endl; }
        virtual void h() { cout << "Base3::h" << endl; }
};

class Derive3 : public Base1, public Base2, public Base3 {
public:
        virtual void f() { cout << "Derive3::f" << endl; }
        virtual void g1() { cout << "Derive3::g1" << endl; }
};

typedef void(*Func)(void); //这是在声明一个void(*)() 类型的函数指针Func


void test_base_virtual_table();
void test_derive_virtual_table();
void test_derive1_virtual_table();
void test_derive1_base_virtual_table();
void test_multi_base_vitual_table();

int main() {
    // test_base_virtual_table();
    // test_derive_virtual_table();
    // test_derive1_virtual_table();
    // test_derive1_base_virtual_table();
    test_multi_base_vitual_table();
    exit(0);
}

void test_base_virtual_table() {
    Base b;
    Func pFunc = NULL;
    cout << "虚函数表地址：" << (uint64_t*)(&b) << endl;
    cout << "虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&b) << endl;

    // Invoke the first virtual function 
    pFunc = (Func)*((uint64_t*)*(uint64_t*)(&b));
    pFunc();

    // 如果调用Base::f()，Base::g()， Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+0))();  // Base::f()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(&b)+2))();  // Base::h()
}
void test_derive_virtual_table() {
    Derive d;
    Func pFunc = NULL;
    cout << "Derive 虚函数表地址：" << (uint64_t*)(&d) << endl;
    cout << "Derive 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&d) << endl;

    // // Invoke the first virtual function 
    // pFunc = (Func)*((uint64_t*)*(uint64_t*)(&d));
    // pFunc();

    // 调用Base::f()，Base::g()， Base::h()，Derive::f1()，Derive::g1()，Derive::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+0))();  // Base::f()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+3))();  // Derive::f1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+4))();  // Derive::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d)+5))();  // Derive::h1()
}

void test_derive1_virtual_table() {
    Derive1 d1;
    Func pFunc = NULL;
    cout << "Derive1 虚函数表地址：" << (uint64_t*)(&d1) << endl;
    cout << "Derive1 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(&d1) << endl;

    // 调用Derive1::f()，Base::g()， Base::h()，Derive1::g1()，Derive1::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d1)+0))();  // Derive1::f()
    ((Func)*((uint64_t*)*(uint64_t*)(&d1)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(&d1)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(&d1)+3))();  // Derive1::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(&d1)+4))();  // Derive1::h1()
}


void test_derive1_base_virtual_table() {
    Base* b = new Derive1();
    // Derive1 d1;
    Func pFunc = NULL;
    cout << "Derive1 虚函数表地址：" << (uint64_t*)(b) << endl;
    cout << "Derive1 虚函数表 — 第一个函数地址：" << (uint64_t*)*(uint64_t*)(b) << endl;

    // 调用Derive1::f()，Base::g()， Base::h()，Derive1::g1()，Derive1::h1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+0))();  // Derive1::f()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+1))();  // Base::g()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+2))();  // Base::h()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+3))();  // Derive1::g1()
    ((Func)*((uint64_t*)*(uint64_t*)(b)+4))();  // Derive1::h1()

    b -> f();
}

void test_multi_base_vitual_table() {
    Derive3 d;
    Base1 *b1 = &d;
    Base2 *b2 = &d;
    Base3 *b3 = &d;
    b1 -> f(); //Derive3::f()
    b2 -> f(); //Derive3::f()
    b3 -> f(); //Derive3::f()
    b1 -> g(); //Base1::g()
    b2 -> g(); //Base2::g()
    b3 -> g(); //Base3::g()
}