C++虚函数的底层实现原理详解

最新推荐文章于 2024-05-16 20:30:29 发布
最新推荐文章于 2024-05-16 20:30:29 发布
阅读量4.1k 收藏 42
点赞数 23
分类专栏： C\C++杂记 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lewele001/article/details/120198316
版权

虚函数的底层实现原理详解

C/C++杂记：虚函数的底层实现原理

虚函数的实现的基本原理

1. 概述

简单地说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针。例：
在这里插入图片描述
其中：

B的虚函数表中存放着B::foo和B::bar两个函数指针。
D的虚函数表中存放的既有继承自B的虚函数B::foo，又有重写（override）了基类虚函数B::bar的D::bar，还有新增的虚函数D::quz。
提示：为了描述方便，本文在探讨对象内存布局时，将忽略内存对齐对布局的影响。

2. 虚函数表构造过程

从编译器的角度来说，B的虚函数表很好构造，D的虚函数表构造过程相对复杂。下面给出了构造D的虚函数表的一种方式（仅供参考）：
在这里插入图片描述

提示：该过程是由编译器完成的，因此也可以说：虚函数替换过程发生在编译时。

3. 虚函数调用过程

以下面的程序为例：
在这里插入图片描述

编译器只知道pb是B*类型的指针，并不知道它指向的具体对象类型 ：pb可能指向的是B的对象，也可能指向的是D的对象。

但对于“pb->bar()”，编译时能够确定的是：此处operator->的另一个参数是B::bar（因为pb是B*类型的，编译器认为bar是B::bar），而B::bar和D::bar在各自虚函数表中的偏移位置是相等的。

无论pb指向哪种类型的对象，只要能够确定被调函数在虚函数中的偏移值，待运行时，能够确定具体类型，并能找到相应vptr了，就能找出真正应该调用的函数。

提示：本人曾在“C/C++杂记：深入理解数据成员指针、函数成员指针”一文中提到：虚函数指针中的ptr部分为虚函数表中的偏移值（以字节为单位）加1。

B::bar是一个虚函数指针， 它的ptr部分内容为9，它在B的虚函数表中的偏移值为8（8+1=9）。

当程序执行到“pb->bar()”时，已经能够判断pb指向的具体类型了：

如果pb指向B的对象，可以获取到B对象的vptr，加上偏移值8（(char*)vptr + 8），可以找到B::bar。
如果pb指向D的对象，可以获取到D对象的vptr，加上偏移值8（(char*)vptr + 8） ，可以找到D::bar。
如果pb指向其它类型对象…同理…

4. 多重继承

当一个类继承多个类，且多个基类都有虚函数时，子类对象中将包含多个虚函数表的指针（即多个vptr），例：
在这里插入图片描述

其中：D自身的虚函数与B基类共用了同一个虚函数表，因此也称B为D的主基类（primary base class）。

虚函数替换过程与前面描述类似，只是多了一个虚函数表，多了一次拷贝和替换的过程。

虚函数的调用过程，与前面描述基本类似，区别在于基类指针指向的位置可能不是派生类对象的起始位置，以如下面的程序为例：
在这里插入图片描述

5. 菱形继承

本文不讨论菱形继承的情形，个人觉得：菱形继承的复杂度远大于它的使用价值，这也是C++让人又爱又恨的原因之一。

如果想要深入研究，可以参考：Itanium C++ ABI。

深入虚表结构

1. 虚表与“虚函数表”

在“C/C++杂记：虚函数的实现的基本原理”一文中曾提到“虚函数表”的概念，只是为了便于理解，事实是：虚函数表并不真的独立存在，它只是虚表（virtual table）中的一部分内容。例：
在这里插入图片描述

从图中可已看出，虚表除了包含虚函数指针，还包含其它一些信息（如：RTTI信息、偏移值等）。

顺便介绍一下gcc的-fdump-class-hierarchy选项，它可以用于输出C++程序的虚表结构（在当前目录下生成一个.class文件），例：
在这里插入图片描述
2. 虚表结构

一个虚表包含以下几个部分：
在这里插入图片描述

其中：

橙色线框中的内容仅限于虚拟继承的情形（若无虚拟继承，则无此内容），虚拟继承的讨论已超过了本文的范围，暂且忽略。
“offset to top”是指到对象起始地址的偏移值，只有多重继承的情形才有可能不为0，单继承或无继承的情形都为0。
“RTTI information”是一个对象指针，它用于唯一地标识该类型。（注：本系列博文后续会有详细讨论。）
“virtual function pointers”也就是我们之前理解的虚函数表，其中存放着虚函数指针列表。
前一节的示例是单继承的示例，下面列出了一个多继承的示例：
在这里插入图片描述

从中可以看到：D的虚表中包含两个虚表结构，第一个也称之为“主虚表”（primary virtual table），另一个虚表又称之为“次虚表”（secondary virtual table）。

简单地概括一下：一个含有虚函数（无论是其本身的，还是继承而来的）的类，可以有一个主虚表和多个次虚表，主虚表和次虚表构成一个虚表组（virtual table group）。

3. 参考

Itanium C++ ABI

运行时类型识别（RTTI）与动态类型转换原理

运行时类型识别（RTTI）的引入有三个作用：

  1. 配合typeid操作符的实现；

  2. 实现异常处理中catch的匹配过程；

  3. 实现动态类型转换dynamic_cast。

typeid操作符的实现

1.1. 静态类型的情形

C++中支持使用typeid关键字获取对象类型信息，它的返回值类型是const std::type_info&，例：

#include <typeinfo>
#include <cassert>
struct B {} b, c;
struct D : B {} d;
void test() {
    const std::type_info& tb = typeid(b); 
    const std::type_info& tc = typeid(c); 
    const std::type_info& td = typeid(d);
    assert(tb == tc);   // b和c具有相同的类型
    assert(&tb == &tc); // tb和tc引用的是相同的对象
    assert(tb != td);   // 虽然D是B的子类，但是b和d的类型却不同
    assert(&tb != &td); // tb和td引用的是不同的对象
}

理论上讲，编译器会为每一种类型生成一个能唯一标识该类型的类型信息对象，typeid返回的就是该对象的引用。

通过查看clang编译器生成的LLVM汇编程序（LLVM汇编程序比本地汇编程序可读性较强），可以证明这一点。
使用clang编译上述源码：“clang -S -emit-llvm test.cpp -o -”，生成LLVM汇编程序包含以下信息（为了方便阅读，省略了部分无关内容）：

@_ZTI1B = linkonce_odr constant { i8*, i8* } { ... }
@_ZTI1D = linkonce_odr constant { i8*, i8*, i8* } { ... }

define void @_Z4testv() #0 {
  %tb = alloca %"class.std::type_info"*, align 8
  %tc = alloca %"class.std::type_info"*, align 8
  %td = alloca %"class.std::type_info"*, align 8
  store bitcast ({ i8*, i8* }* @_ZTI1B to %"class.std::type_info"*), %tb, align 8
  store bitcast ({ i8*, i8* }* @_ZTI1B to %"class.std::type_info"*), %tc, align 8
  store bitcast ({ i8*, i8*, i8* }* @_ZTI1D to %"class.std::type_info"*), %td, align 8
  ...

其中：

@_ZTI1B 和@_ZTI1D 是两个全局变量，用以存储std::type_info（或者其子类）对象。
上述LLVM汇编程序中还列出了test()函数的起始部分内容，其中将@_ZTI1B 存储于%tb和%tc，将@_ZTI1D 存储于%td，正好对应原程序中的引用初始化语句。
附加说明：

LLVM汇编语言也称之为LLVM中间表示（IR, Intermediate Representation），其中全局变量以“@”开头。详细请参见：LLVM Language Reference Manual。
_ZTI1B和_ZTI1D是经过名字修饰（name mangling）修饰之后的变量名，linux下可以使用c++filt命令还原成可读形式（例如：c++filt _ZTI1B输出“typeinfo for B”，说明_ZTI1B是标识B类型的全局变量）。

1.2. 动态类型的情形

当typeid的操作数引用的是一个动态类（含有虚函数的类） 类型时，它的返回值是被引用对象对应类型的类型信息对象，例：

#include <typeinfo>
#include <cassert>
struct B { virtual void foo() {} };
struct C { virtual void bar() {} };
struct D : B, C {};
void test() {
    D d;
    B& rb = d;
    C& rc = d;
    assert(typeid(rb) == typeid(d));  // rb引用的类型与d相同
    assert(typeid(rb) == typeid(rc)); // rb引用的类型与rc引用的类型相同
}

编译时可能还不知道rb或rc引用的类型，运行时怎么能判断该返回基类还是派生类对应的类型信息对象呢？

还记得“C/C++杂记：深入虚表结构”一文中讲过的-fdump-class-hierarchy选项吧，用它将D的虚表打印出来如下：
在这里插入图片描述

可见，无论是“主虚表”还是“次虚表”，其中的RTTI信息位置都是&_ZTI1D（即D类型对应的类型信息对象）。

正是利用了这一点，运行时便可以通过vptr找到“虚函数表”，而“虚函数表”之前的一个位置存放了需要的类型信息对象，typeid可以直接返回这里的类型信息对象引用即可。
下面的图示描述了这一过程：
在这里插入图片描述

2. 实现异常处理中catch的匹配过程
catch的匹配过程也可利用与typeid相似的原理进行类型匹配判断，此不再赘述。

3. 动态类型转换（dynamic_cast）

说明：本节不考虑虚拟继承的情形。

先上一个例子：
在这里插入图片描述

转换过程：
(1) 对#2来说最为简单，首先获取RTTI对象，RTTI对象与目标类型信息对象一致，而偏移值也为0，所以只用返回源地址（pb）即可。
(2) 对#1和#3来说，RTTI对象与目标类型信息对象一致，但是有偏移值-8，所以返回值为“(char*)pa + (-8)”或“(char*)pc + (-8)”。
(3) 对#4来说，RTTI对象与目标类型信息对象不一致，但是目标类型C 是RTTI对象表示类型（D）是基类（后面会讨论如何判断继承关系），因此转换也是可行的。
用clang编译上述源码，生成LLVM汇编程序如下（已作简化）：

@_ZTI1A= linkonce_odr constant { i8*, i8* } { ... }
@_ZTI1B= linkonce_odr constant { i8*, i8* } { ... }
@_ZTI1C= linkonce_odr constant { i8*, i8*, i8* } {..., i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*) }
@_ZTI1D= linkonce_odr constant { i8*, i8*, i32, i32, i8*, i64, i8*, i64 } { ...,
        i8* bitcast ({ i8*, i8* }* @_ZTI1B to i8*), i64 2,
        i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1C to i8*), i64 2050
    }
    ```
从中可以看出，RTTI对象中存放的内容还包括基类的RTTI对象指针，成树状结构：

![在这里插入图片描述](https://img-blog.csdnimg.cn/dc02c427114d484199897db0d7e11792.png)

因此继承关系可以通过此树状结构判断，有了继承关系，再递归从虚表中查找基类子对象在派生类中的偏移值，便可以确定最终返回地址。

**4. 参考**

(1) [Itanium C++ ABI](http://mentorembedded.github.io/cxx-abi/abi.html)
(2) [LLVM Language Reference Manual](http://llvm.org/docs/LangRef.html)
(3) [libc++abi源码](http://libcxxabi.llvm.org/)（[private_typeinfo.h](http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/private_typeinfo.h)文件）
武魂殿007
关注
  • 23
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
虚函数底层实现机制
心之所向，身之所往
12-16 4404
1、多态的实现机制      C++在基类中声明一个带关键之Virtual的函数，这个函数叫虚函数；它可以在该基类的派生类中被重新定义并被赋予另外一种处理功能。通过指向指向派生类的基类指针或引用调用虚函数，编译器可以根据指向对象的类型在运行时决定调用的目标函数。这就实现了多态。 2、实例 #include using namespace std; class Base { pu
c 语言的虚函数,C 中的虚函数(virtual function)
weixin_30578673的博客
05-22 4388
一.简介虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次：class Father{public:virtual void foo() { cout << "Father::foo() is called"<< endl;}};class Sun: public Father{public:vi...
12、虚函数的应用、虚析构函数
Salted fish in hand, I have the world.
12-10 369
一个类中，除了构造函数和静态成员函数外，任何函数都可以被声明为虚函数。
C++虚函数的底层实现原理详解_虚函数底层实现原理
最新发布
2401_85011960的博客
05-16 562
简单地说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针。例：其中：B的虚函数表中存放着B::foo和B::bar两个函数指针。D的虚函数表中存放的既有继承自B的虚函数B::foo，又有重写（override）了基类虚函数B::bar的D::bar，还有新增的虚函数D::quz。提示：为了描述方便，本文在探讨对象内存布局时，将忽略内存对齐对布局的影响。
C++：多态的底层实现原理 -- 虚函数表
weixin_43908419的博客
04-14 1252
本文结合内存监视窗口和虚表打印函数，分析了多态实现的底层原理，并给出了单继承和多继承体系中的内存模型。
C语言面向对象编程（三）：虚函数与多态
安晓辉生涯——聚焦程序员的职业规划与成长
01-18 1万+
提供了一个非常逼真的虚函数实现，高仿 C++ 中的虚函数表（VTABLE）
一文搞懂C++虚函数的实现原理
garbage_man的博客
06-01 3129
虚函数是实现C++中面向对象的三大特性之一——多态的一种技术手段。什么是多态呢？ 在基类的成员函数前，使用修饰得到的就是虚函数。在派生类中，对继承得到的虚函数，进行重写，使得派生类对继承的方法有了自己的具体实现。在外部函数中，通过基类指针调用类的接口，在程序运行时，会根据指针绑定的对象选择对应的接口，这便是多态。多态简单来说，是让同一种事物有了多种不同的表现。基类指针绑定了类对象后，程序运行时，是怎么知道该运行哪个类的接口函数呢？这便是本篇文章要探究的问题。C++为了实现虚函数的动态绑定，在每一个类（当然是
易语言写易支持库原理详解源码
06-06
2. 实现底层逻辑：接口函数背后是用C++或其他低级语言实现的真正功能代码。这部分代码负责执行实际操作，如操作系统级别的调用、硬件交互等。 3. 编译与封装：将底层逻辑编译成动态链接库（DLL）文件，然后使用...
hexin.rar_网络编程_Visual_C++_
08-12
3. 在OnAccept()虚函数中处理新的连接请求，为每个连接创建新的CSocket实例。 然后是`MyClient`项目，它代表了客户端角色。客户端通常需要主动连接服务器，发送数据并接收响应。`MyClient`的主要流程包括： 1. ...
Demangler:用 java 编写的 C++ Symbol demangler
06-11
2. **C++类型系统**：C++的类型系统复杂，包括基本类型、指针、引用、模板、成员函数、虚函数等。demangler需要能够识别并还原这些类型的修饰形式。 3. **编译器兼容性**：不同的编译器如GCC、MSVC会有不同的名字...
visual c++
10-22
**Visual C++ 知识点详解** Visual C++（简称VC++）是微软公司开发的一款集成...虽然现代软件开发可能更多地转向了跨平台和Web应用，但Visual C++的基础知识对于理解计算机科学原理和底层操作系统交互依然至关重要。
C++中虚函数的原理和作用
08-11
本文档详细介绍了C++中虚函数的原理以及在何场景下要用到虚函数。
C语言虚函数与多态性
09-04
C语言虚函数与多态性
tolua++ tool test
10-18
例如，你可以用tolua++实现 Lua 脚本对C++多态类的动态绑定，使得在Lua中可以调用C++的虚函数，实现动态多态性。 五、tolua++实战案例 假设我们有一个C++类`GameObject`，它有一个虚拟函数`Move`，在tolua++.def中...
使用c语言实现c++中虚函数机制
hqm178933的博客
04-20 1869
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、虚函数机制二、C++实现虚函数三、C实现虚函数总结 前言 提示：这里可以添加本文要记录的大概内容： 众所周知C++是门面向对象的语言，其中三大特性是继承、封装和多态。多态又分为动态和静态多态两种，其中静态多态指重载和隐藏，而动态多态指虚函数机制。本篇主要介绍动态多态的虚函数机制。 提示：以下是本篇文章正文内容，下面案例可供参考 一、虚函数机制   虚函数是指基类中使用virtual关键字修饰的成员函数，如果基类未实现该.
c语言tips-c语言的虚函数实现
留下虚度光阴的一些证据。
09-03 885
学过面对对象的同学都知道虚函数是面向对象编程中的一个重要概念，它允许在基类和派生类之间实现多态性（polymorphism）。我们可以在基类去定义一个成员函数，然后再派生类再去覆盖写它，这样在不同派生类使用相同函数名就可以实现不同的功能。下面可以看一下c++和python是如何做的虽然c语言是个面向过程的语言，但是使用属性依旧能够实现面向对象的虚函数的概念，在某些场合中对于整体代码的维护和开发有着重大作用。全网好像也没有比较详细的对__attribute__((weak))属性。
C++虚函数详解
热门推荐
qq_42048450的博客
05-26 10万+
1.虚函数的使用？ 1.1虚函数的定义 在实现c++多态时会用到虚函数。虚函数使用的其核心目的是通过基类访问派生类定义的函数。所谓虚函数就是在基类定义一个未实现的函数名，为了提高程序的可读性，建议后代中虚函数都加上virtual关键字。一般格式： class base { public: base(); virtual void test(); //定义的一个虚函数 private: char *basePStr; }; 上述代码在基类中定义了一个test的虚函数，所有可以在其子类重新定义父
c语言虚函数的作用,虚函数 - C++教程 - C语言网
weixin_34792402的博客
05-16 458
首先引出，我们的新知识点—虚函数(virtual function)这是一种什么函数呢？ 简单讲，就是一个函数前面用virtual声明的函数，一般形式如下：virtual 函数返回值 函数名(形参){函数体}那它有什么用呢？ 虚函数的出现，允许函数在调用时与函数体的联系在运行的时候才建立，即所谓的动态联编。那么在虚函数的派生类的运行时候，就可以在运行的时候根据动态联编实现都是执行一个方法，却出现...
c学习47-虚函数（多态）
吃不饱、力不足的博客
04-27 330
1. 多态 1. C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。 2. 所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 2. 多态特点 1.多态是在不同继承关系的类对象，去调同一函数，产生了不同的行为。 2. 就是说，有一对继承..
Cplusplus获取对象类型动态生成对应对象
05-09
在 C++ 中，可以使用 RTTI（Run-Time Type Information）机制来获取对象的类型信息。具体步骤如下： 1. 在基类中声明虚函数：在基类中声明一个虚函数，可以使得子类通过重写该函数来实现不同的行为。例如： ``` class Base { public: virtual void showType() { std::cout << "This is a Base object." << std::endl; } }; ``` 2. 创建子类：创建一个或多个子类，重写基类的虚函数，并实现不同的行为。例如： ``` class DerivedA : public Base { public: void showType() override { std::cout << "This is a DerivedA object." << std::endl; } }; class DerivedB : public Base { public: void showType() override { std::cout << "This is a DerivedB object." << std::endl; } }; ``` 3. 动态生成对象：使用 new 运算符动态生成一个对象，并将其指针保存到基类指针中。例如： ``` Base* objPtr = new DerivedA(); ``` 4. 获取对象类型：使用 dynamic_cast 运算符将基类指针转换为子类指针，然后使用 typeid 运算符获取对象的类型信息。例如： ``` if (DerivedA* aPtr = dynamic_cast<DerivedA*>(objPtr)) { std::cout << "Object type: " << typeid(*aPtr).name() << std::endl; } else if (DerivedB* bPtr = dynamic_cast<DerivedB*>(objPtr)) { std::cout << "Object type: " << typeid(*bPtr).name() << std::endl; } else { std::cout << "Unknown object type." << std::endl; } ``` 这里使用 dynamic_cast 运算符将基类指针 objPtr 转换为 DerivedA 指针 aPtr，如果转换成功，则说明 objPtr 指向的是 DerivedA 对象，输出对应的类型信息；否则继续使用 dynamic_cast 运算符将 objPtr 转换为 DerivedB 指针 bPtr，如果转换成功，则说明 objPtr 指向的是 DerivedB 对象，输出对应的类型信息；否则输出未知类型信息。注意：必须使用虚函数来实现多态性，否则 dynamic_cast 运算符将无法正确转换对象类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值