一文读懂C++虚函数的内存模型_gdp c++ 内存模型 虚函数表(1)

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

+ [4.2、单继承有虚函数覆盖的情况](#42_170)
+ [4.3、多重继承的情况](#43_259)
+ [4.4、多层继承的情况](#44_427)

• 5、总结

1、前言

C++虚函数的内存模型是一个经典的问题，其具体实现依赖于编译器，可能会出现较大差异，但原理和最终的目的是大体相同的。本文将对g++中虚函数的内存模型进行详细解析。

2、虚函数简介

C++中有两种方式实现多态，即重载和覆盖。

• 重载：是指允许存在多个同名函数，而这些函数的参数表不同（参数个数不同、参数类型不同或者两者都不同）。
• 覆盖：是指子类重新定义父类虚函数的做法，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针拥有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法，比如：模板元编程是在编译期完成的泛型技术，RTTI、虚函数则是在运行时完成的泛型技术。

关于虚函数的具体使用方法，建议大家先去阅读相关的C++的书籍，本文只剖析虚函数的内存模型，让大家对虚函数有一个更加清晰的认识，并不对虚函数的具体使用方法作过多介绍。

3、虚函数表简介

学过C++的人都应该知道虚函数（Virtual Function）是通过虚函数表（Virtual Table，简称为V-Table）来实现的。虚函数表主要存储的是指向一个类的虚函数地址的指针，通过使用虚函数表，继承、覆盖的问题都都得到了解决。假如一个类有虚函数，当我们构建这个类的实例时，将会额外分配一个指向该类虚函数表的指针，当我们用父类的指针来操作一个子类的时候，这个指向虚函数表的指针就派上用场了，它指明了此时应该使用哪个虚函数表，而虚函数表本身就像一个地图一样，为编译器指明了实际所应该调用的函数。指向虚函数表的指针是存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下），这就意味着理论上我们可以通过对象实例的地址得到这张虚函数表（实际上确实可以做到），然后对虚函数表进行遍历，并调用其中的函数。

前面说了一大堆理论，中看不中用，下面还是通过一个实际的例子验证一下前面讲的内容，首先定义一个Base类，该类有三个虚函数，代码如下：

#include <iostream>
#include <string>

typedef void (\*Fun)(void);

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

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

接下来按照前面的说法，我们通过Base类的实例对象base来获取虚函数表，代码如下：

int main(int argc, char\* argv[])
{
    Base base;
    Fun fun = nullptr;

    std::cout << "指向虚函数表指针的地址：" << (long\*)(&base) << std::endl;
    std::cout << "虚函数表的地址：" << (long\*)\*(long\*)(&base) << std::endl;

    std::cout << "offset\_to\_top：" << \*((long\*)\*(long\*)(&base) - 2) << std::endl;
    std::cout << "typeinfo for Base：" << (long\*)\*((long\*)\*(long\*)(&base) - 1) << std::endl;

    fun = (Fun)\*((long\*)\*(long\*)(&base));
    std::cout << "虚函数表中第一个函数的地址：" << (long\*)fun << std::endl;
    fun();

    fun = (Fun)\*((long\*)\*(long\*)(&base) + 1);
    std::cout << "虚函数表中第二个函数的地址：" << (long\*)fun << std::endl;
    fun();

    fun = (Fun)\*((long\*)\*(long\*)(&base) + 2);
    std::cout << "虚函数表中第三个函数的地址：" << (long\*)fun << std::endl;
    fun();
}

运行结果图3-1所示（GCC 4.8.5）：

图3-1 程序运行结果

接下来我们就画一张内存布局图来更直观地看一下类Base的内存布局，如图3-2所示：

图3-2 类Base内存布局

可以看到因为类Base没有类成员，所以只要一个虚函数表指针。上述内容也可以在GDB中调试验证，如图3-3所示：

图3-3 GDB查看基类虚函数表内存布局

在上面的例子中我们通过把&base强制转换成long *类型，来取得指向虚函数表的指针的地址，然后对这个地址取值就得到对应的虚函数表了。从测试程序中可以看到，我们取到的指向虚函数表的指针指向的并非是虚函数表的首地址，虚函数表应该还包括虚函数表指针指向的地址的前两个地址空间（64位系统，也就是16个字节）。
接下来具体分析一下这个内存模型：

1. _vptr.Base - 2：这里存储的是offset_to_top，这个表示的是当前的虚表指针距离类开头的距离，可以看到对于_vptr.Base来说这个值就是0，因为_vptr.Base就存在于类Base的起始位置。后续的例子中会有该值不是0的情况出现的。

offset_to_top深度解析：在多继承中，由于不同基类的起点可能处于不同的位置，因此当需要将它们转化为实际类型时，this指针的偏移量也不相同。由于实际类型在编译时是未知的，这要求偏移量必须能够在运行时获取。实体offset_to_top表示的就是实际类型起始地址到当前这个形式类型起始地址的偏移量。在向上动态转换到实际类型时（即基类转派生类），让this指针加上这个偏移量即可得到实际类型的地址。需要注意的是，由于一个类型即可以被单继承，也可以被多继承，因此即使只有单继承，实体offset_to_top也会存在于每一个多态类型之中。
（这里要注意一点就是offset_to_top只存在于多态类型中，非多态类型的类根本就没有什么所谓的虚函数表之类的东西，它也就不支持RTTI，最简单的大家可以使用dynamic_cast去试试，会报错说该类型不具备多态性质的。那么问题来了，怎样才能以最简短的方式让它具备多态的性质呢？很简单，定义一个析构函数，用virtual修饰即可）

2. _vptr.Base - 1：这里存储的是typeinfo for Base，里面的内容其实也是一个指针，指向的是类Base的运行时信息，这些玩意都是为了支持RTTI的。RTTI的相关内容以后会讲，这里就先不多分析了。
3. _vptr.Base：从这里开始的内存地址存储的就是指向各个虚函数的指针了，顺序与类中定义的顺序一致，这个就是我们平时从书中看到的虚函数表主要存储的数据内容了，比较直观这里就不多做分析了。

4、有继承关系的虚函数表剖析

前面分析虚函数表的场景是没有继承关系的，然而在实际开发中，没有继承关系的虚函数纯属浪费表情，所以接下来我们就来看看有继承关系下虚函数表会呈现出什么不一样的特点，分析的时候会分别就单继承无虚函数覆盖、单继承有虚函数覆盖、多重继承、多层继承这几个场景进行说明。

4.1、单继承无虚函数覆盖的情况

先定义一个Base类，再定义一个Derived类，Derived类继承于Base类，代码如下：

#include <iostream>
#include <string>

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

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void f1()
    {
        std::cout << "Derived::f1()" << std::endl;
    }

    virtual void g1()
    {
        std::cout << "Derived::g1()" << std::endl;
    }

    virtual void h1()
    {
        std::cout << "Derived::h1()" << std::endl;
    }
};

继承关系如图4-1所示：

图4-1 类继承关系UML图

测试的代码如下，因为等下要使用GDB来验证，所以就随便写点，定义个Derived类实例就行了

int main(int argc, char\* argv[])
{
    Derived derived;
    derived.f();
}

派生类Derived的内存布局如图4-2所示：

图4-2 单继承无虚函数覆盖情况下派生类内存布局

接下来就用GDB调试一下，验证图4-2是否正确，如图4-3所示：

图4-3 GDB查看单继承无虚函数覆盖情况下派生类内存布局

从调试结果可以看出图4-2是正确的，Derived的虚函数确实是接在Base的虚函数后面的，而这里的虚函数表指针依然叫做_vptr.Base（因为继承于类Base），其余的内容与第三节的一致，就不重复讲了。

4.2、单继承有虚函数覆盖的情况

派生类覆盖基类的虚函数是很有必要的事情，不这么做的话虚函数的存在将毫无意义。下面我们就来看一下如果派生类中有虚函数覆盖了基类的虚函数的话，对应的虚函数表会是一个什么样子。还是老规矩先定义两个有继承关系的类，注意一下我这里只覆盖了基类的虚函数g()

#include <iostream>
#include <string>

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

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void f1()
    {
        std::cout << "Derived::f1()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Derived::g()" << std::endl;
    }

    virtual void h1()
    {
        std::cout << "Derived::h1()" << std::endl;
    }
};

继承关系如图4-4所示：

图4-4 类继承关系UML图

测试的代码如下，因为等下要使用GDB来验证，所以就随便写点，定义个Derived类实例就行了

int main(int argc, char\* argv[])
{
    Derived derived;
    derived.g();
}

派生类Derived的内存布局如图4-5所示：

图4-5 单继承有虚函数覆盖情况下派生类内存布局

接下来就用GDB调试一下，验证图4-5是否正确，如图4-6所示：

图4-6 GDB查看单继承有虚函数覆盖情况下派生类内存布局

从调试结果可以看出图4-5是正确的，并且可以得到以下几点信息：

1. 覆盖的g()被放到了虚表中原来父类虚函数的位置
2. 没有被覆盖的虚函数位置排序依旧不变

有了前面的理论基础，我们可以知道对于下面的代码，原先虚函数表中存储指向Base::g()指针的位置已经被指向Derived::g()的指针所取代，于是在实际调用发生时，调用的是Derived::g()，从而实现了多态

int main(int argc, char\* argv[])
{
    Base\* base = new Derived();
    base->f();
    base->g();
    base->h();
}

输出结果如图4-7所示：

图4-7 程序运行结果

注意：在前面的例子中，我们分配内存的实例对象的类型是Derived，但是却用Base的指针去引用它，这个过程中数据并没有发生任何的转换，实例的真实类型依旧是Derived，但是由于我们使用时用的是Base类型，所以函数调用要依据Base类来，不能胡乱调用，比如说我们此时是无法调用Derived的f1()和h1()的。

4.3、多重继承的情况

多重继承就不分开讲有覆盖和无覆盖的情况了，其实结合前面讲的就差不多知道是什么个情况了，下面的例子中会设计成派生类既有自己的虚函数，又有用于覆盖基类的虚函数，这样就能兼顾有覆盖和无覆盖的情况了。类的设计如下：

#include <iostream>
#include <string>

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

    virtual void g()
    {
        std::cout << "Base1::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base1::h()" << std::endl;
    }
};

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

    virtual void g()
    {
        std::cout << "Base2::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base2::h()" << std::endl;
    }
};

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



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/8b2e0267325d05a4056af9095a972ade.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

    }

    virtual void h()
    {
        std::cout << "Base2::h()" << std::endl;
    }
};

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



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-SgHo83BG-1713367173645)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**