一文读懂C++虚函数的内存模型

  • 1、前言
  • 2、虚函数简介
  • 3、虚函数表简介
  • 4、有继承关系的虚函数表剖析
    • 4.1、单继承无虚函数覆盖的情况
    • 4.2、单继承有虚函数覆盖的情况
    • 4.3、多重继承的情况
    • 4.4、多层继承的情况
  • 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修饰即可）

  1. _vptr.Base - 1：这里存储的是typeinfo for Base，里面的内容其实也是一个指针，指向的是类Base的运行时信息，这些玩意都是为了支持RTTI的。RTTI的相关内容以后会讲，这里就先不多分析了。

  2. _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;}virtual void g(){std::cout << "Base3::g()" << std::endl;}virtual void h(){std::cout << "Base3::h()" << std::endl;}
};class Derived : public Base1, public Base2, public Base3
{public:virtual void f(){std::cout << "Derived::f()" << std::endl;}virtual void g1(){std::cout << "Derived::g1()" << std::endl;}virtual void h1(){std::cout << "Derived::h1()" << std::endl;}
};

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

图4-8 类继承关系UML图

测试的代码如下：

int main(int argc, char* argv[])
{Derived* d = new Derived();Base1* b1 = d;Base2* b2 = d;Base3* b3 = d;std::cout << (long*)(*(long*)b1) << std::endl;std::cout << (long*)(*(long*)b2) << std::endl;std::cout << (long*)(*(long*)b3) << std::endl;
}

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

图4-9 程序运行结果

输出信息非常有趣，明明b1、b2、b3指向的都是d，但是它们各自取出来的虚函数表的地址却完全不同，按理来说不是应该相同吗？别急，下面我们通过图4-10来看一看多继承下派生类内存布局是什么样的

图4-10 多重继承情况下派生类内存布局

从图4-10中可以看出以下几点信息：

  1. 无论派生类继承与几个基类，虚函数表永远只有一个
  2. 虽然只有一个虚函数表，但是每个基类都有一个属于自己的虚函数表指针，这个指针指向自己虚函数在虚函数表中的位置
  3. 派生类自己特有的虚函数被放到了第一个基类的表中（第一个基类是按照继承顺序来确定的）
  4. 可以看到对于_vptr.Base2来说，offset_to_top不是0而是-8，表示_vptr.Base2的位置与类开头相差为8个字节（64为系统），至于为什么是负数，这是因为堆内存是向下增长的，越往下地址数值越大。_vptr.Base3同理。
  5. 对于_vptr.Base2和_vptr.Base3来说，他们的第一个虚函数本来应该指向的是Derived::f()，但是事实并非如此，其指向的是代码段non-virtual thunk to Derived::f()，因为对于Base2类型，其this指针已经相对于Derived进行了偏移，所以需要由代码段non-virtual thunk to Derived::f()先将this转换为派生类Derived类型，之后才跳转到真正的Derived::f()函数。

到这里我们就可以解释前面那个问题了，对于上面例子中的b1，这个没啥问题，因为它的类型Base1就是第一个被继承的，所以我们当然可以认为这个不会出任何问题，但是对于b2呢，它被继承的位置可不是第一个啊，运行时要怎么确定它的虚函数表呢？它有没有可能一不小心找到Base1的虚函数去？恰好这个例子中几个基类的虚函数名字和参数又都是完全相同的。这里其实就涉及到编译器的处理了，当我们执行赋值操作Base2* b2 = d;时，编译器会自动把b2的虚函数表指针指向正确的位置，这个过程是编译期间完成的，所以虚函数所实现的多态应该是“静动结合”的，有部分工作需要在编译时期完成的。

下面我们依然借助GDB来看一下实际的内存布局，详见图4-11，从调试信息中可以看出确实有三个虚函数表指针，对应三个基类

图4-11 GDB查看多重继承情况下派生类虚函数表内存布局

_vptr.Base1相关信息如图4-12所示，可以看到和图4-10描述的内容是一致的，Derived自己特有的虚函数确实被加入到了第一张表中了

图4-12 _vptr.Base1相关信息

_vptr.Base2相关信息如图4-13所示

图4-13 _vptr.Base2相关信息

_vptr.Base3相关信息如图4-14所示

图4-14 _vptr.Base3相关信息

补充说明：如果继承的某个类没有虚函数的话，比如说将上面的Base2修改为以下格式：

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

main函数不变，再运行以下程序，输出结果如图4-15所示，说明此时Base2就不再拥有自己的虚函数表的指针了，因为它本来就没有虚函数表。

图4-15 程序运行结果

4.4、多层继承的情况

多层继承的在有前面的基础上来理解就非常简单了，测试程序如下：

#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 f(){std::cout << "Derived::f()" << std::endl;}virtual void g1(){std::cout << "Derived::g1()" << std::endl;}
};class DDerived : public Derived
{public:virtual void f(){std::cout << "DDerived::f()" << std::endl;}virtual void h(){std::cout << "DDerived::h()" << std::endl;}virtual void g2(){std::cout << "DDerived::g2()" << std::endl;}
};int main(int argc, char* argv[])
{DDerived dd;dd.f();
}

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

图4-16 类继承关系UML图

派生类DDerived内存布局如图4-17所示：

图4-17 多层继承情况下派生类内存布局

多层继承的情况这里就不使用GDB去看内存布局了，比较简单，大家可以自行去测试一下。

5、总结

本文先对虚函数的概念进行了简单介绍，引出了虚函数表这个实现虚函数的关键要素，然后对g++下不同继承案例的虚函数内存模型进行画图分析，最后使用GDB查看实际的内存情况来验证内存模型图的正确性。下一篇文章《一文读懂C++虚继承的内存模型》已完成，是关于虚继承的，有兴趣的小伙伴可以跳转过去看看，相信对学C++的同学一定会有所帮助的。

最后，如果大家觉得本文写得好的话麻烦点赞收藏关注一下谢谢，也可以关注该专栏，以后会有更多优质文章输出的。

一文读懂C++虚函数的内存模型相关推荐

  1. 一文读懂C++虚继承的内存模型

    一文读懂C++虚继承的内存模型 1.前言 2.多继承存在的问题 3.虚继承简介 4.虚继承在标准库中的使用 5.虚继承下派生类的内存布局解析 6.总结 1.前言 C++虚继承的内存模型是一个经典的问题 ...

  2. 一文搞懂C++虚函数的实现原理

    虚函数的概念 虚函数是实现C++中面向对象的三大特性之一--多态的一种技术手段. 什么是多态呢? 在基类的成员函数前,使用virtual修饰得到的就是虚函数.在派生类中,对继承得到的虚函数,进行重写, ...

  3. 运用高斯核模型进行最小二乘回归_比特币价格与时间存在关系？一文读懂比特币价值的对数增长模型...

    免责声明:本文旨在传递更多市场信息,不构成任何投资建议.文章仅代表作者观点,不代表火星财经官方立场. 小编:记得关注哦

  4. 从根上理解高性能、高并发(七)：深入操作系统，一文读懂进程、线程、协程

    本文引用了"一文读懂什么是进程.线程.协程"一文的主要内容,感谢原作者的无私分享. 1.系列文章引言 1.1 文章目的 作为即时通讯技术的开发者来说,高性能.高并发相关的技术概念早 ...

  5. 网络编程懒人入门(十一)：一文读懂什么是IPv6

    本文同时发布于"即时通讯技术圈"公众号,链接是:https://mp.weixin.qq.com/s/cS5xB2DrjF52rmz6EGVJ6A. 本文参考了公众号鲜枣课堂的&q ...

  6. 一文读懂什么是Python魔法函数

    一文读懂什么是Python魔法函数 Python的魔法函数是指Python的类中,一系列函数名由双下划线包裹的函数. 笔者最初接触到魔法函数的使用是在Pytorch中,在Pytorch中的Datase ...

  7. 一文读懂Faster RCNN

    来源:信息网络工程研究中心本文约7500字,建议阅读10+分钟 本文从四个切入点为你介绍Faster R-CNN网络. 经过R-CNN和Fast RCNN的积淀,Ross B. Girshick在20 ...

  8. ​一文读懂EfficientDet

    一文读懂EfficientDet. 今年年初Google Brain团队在 CVPR 2020 上发布了 EfficientDet目标检测模型, EfficientDet是一系列可扩展的高效的目标检测 ...

  9. 一文读懂序列建模（deeplearning.ai）之序列模型与注意力机制

    https://www.toutiao.com/a6663809864260649485/ 作者:Pulkit Sharma,2019年1月21日 翻译:陈之炎 校对:丁楠雅 本文约11000字,建议 ...

最新文章

  1. android最全面试题71道题 详解
  2. PyFlink 社区扶持计划正式上线！
  3. python输入end退出循环_4.学习python获取用户输入和while循环及if判断语句
  4. React15.6.0实现Modal弹层组件
  5. linux malloc core,Linux上使用的malloc版本
  6. 2021，新手初学写作的几个温馨建议
  7. 泰山游记：为何爬山后大腿前部很酸？
  8. 浅谈Tomcat接收到一个请求后在其内部的执行流程（源码）
  9. 中国河流（水系）数据集
  10. 基于Arduino的智能环境监测与反馈系统
  11. SO – Shipping – Move Order Staus: BackOrder – 做搬运无法移仓
  12. java swing tooltips_tooltips 提示
  13. 安装配置OOS2016
  14. python 之 前端开发（ JavaScript变量、数据类型、内置对象、运算符、流程控制、函数）...
  15. 去中心化存储项目终极指南 | Filecoin, Storj 和 PPIO 项目技术对比（上）
  16. ui sketch_如何在Sketch中设计汽车应用程序设计UI
  17. Link context for 0x01 connection handle could not be fetched.
  18. 永磁电机风力发电机原理及并网实验系统QY-TF18
  19. k8s 学习 kubeadm join 超时报错 : error uploading crisocket
  20. matlab 怎么解欠定方程 有Warning:Rank deficient,rank=2 tol=4.6151e-015 （转百度知道）

热门文章

  1. 基于深度学习的文本分类6大算法-原理、结构、论文、源码打包分享
  2. 【yum】error: unpacking of archive failed on file
  3. 【Android】Binder的理解
  4. 字符串流stringstream（头文件sstream）
  5. 如何快速查询学术会议
  6. perl与c相互调用
  7. JDBC中executeQuery、executeUpdate和execute之间的区别
  8. WDK与DDK的区别
  9. Linux安装数据库
  10. 安徽大学电气工程及自动化学院本科实验报告(MATLAB)——六、七章