ToB企服应用市场:ToB评测及商务社交产业平台

标题: 深度解读《深度探索C++对象模型》之C++虚函数实现分析（一） [打印本页]
作者: 立山    时间: 2024-5-18 03:16
标题: 深度解读《深度探索C++对象模型》之C++虚函数实现分析（一）
接下来我将连续更新“深度解读《深度探索C++对象模型》”系列，敬请期待，欢迎关注！也可以关注公众号：iShare爱分享，主动获得推文和全部的文章列表。
假如有这样的一段代码，代码中定义了一个Object类，类中有一个成员函数print，通过以下的两种调用方式调用：
  1. Object b;
  2. Object* p = new Object;
  3. b.print();
  4. p->print();
复制代码
请问这两种方式有什么区别吗？在效率上一样吗？答案是不确定。因为得看成员函数print的声明方式，它大概是静态的，大概是非静态的，也大概是一个虚函数。还得看Object类的具体定义，它大概是独立的类，也有大概是经过多重继承来的类，或者继承的父类中有一个虚基类。
静态成员函数和非虚成员函数比较简单，我们在下一小节简单介绍一下即可，本文重点讲解虚函数的实现及其效率。
成员函数种类

非静态成员函数和普通的非成员函数是一样的，它也是被编译器放置在代码段中，且可以像普通函数那样可以获取到它的地址。和普通非成员函数的区别是它的调用必须得经由一个对象或者对象的指针来调用，而且可以直接访问类中非公开的数据成员。下面的代码打印出函数的地址：
  1. #include <cstdio>
  3. class Object {
  4. public:
  5.     void print() {
  6.         printf("a=%d, b=%d\n", a, b);
  7.     }
  8.     int a = 1;
  9.     int b = 2;
  10. };
  12. void printObject(Object* obj) {
  13.     printf("a=%d, b=%d\n", obj->a, obj->b);
  14. }
  16. int main() {
  17.     printf("Object::print = %p\n", &Object::print);
  18.     printf("printObject = %p\n", &printObject);
  20.     return 0;
  21. }
复制代码
程序的输出效果如下，从打印效果来看，两者的地址比较相近，说明它们都是一起放在代码段中的，从天生的汇编代码也可以看出来。
  1. Object::print = 0x1007b3f30
  2. printObject = 0x1007b3e70
复制代码
非静态成员函数和普通非成员函数的运行效率上也是一样的，普通非成员函数的实现上，对类中成员的访问看起来像是要经过指针的间接访问，如obj->a，非静态成员函数的访问看起来更直接一点，直接可以对类中的成员进行存取，好像是非静态成员函数的效率更高一些，其实否则，非静态成员函数的调用，编译器会隐式的把它转换成另一种形式：
  1. Object obj;
  2. obj.print();
  3. // 转换成：
  4. print(&obj);
  5. // print的定义转换成：
  6. print(Object* const this) {
  7.     printf("a=%d, b=%d\n", this->a, this->b);
  8. }
复制代码
两者在本质上是一样的，查看天生的汇编代码也是一样的。另外也说明了为什么非静态成员函数要经由一个对象或对象的指针来调用。
上面提到的非静态成员函数的调用，必须要经由类的对象来调用，是因为需要将对象的地址作为函数的参数，也就是隐式的this指针，这样在函数中访问类的非静态数据成员时将绑定到此地址上，也就是将此地址作为基地址，经过偏移得到数据成员的地址。但是如果函数中不需要访问非静态数据成员的话，是不需要this指针的，但现在的编译器并不区分这种环境。静态成员函数不能访问类中的非静态数据成员，所以是不需要this指针的，如Object类中定义了静态成员函数static int static_func()，通过对象调用：
Object obj;
obj.static_func();
或者通过对象的指针调用：
Object* pobj = new Object;
pobj->static_func();
最终都会转换成员如下的形式：
Object::static_func();
通过对象或者对象的指针来调用只是语法上的便利而已，它并不需要对象的地址作为参数（this指针）。
那么静态成员函数存在的意义是什么？静态成员函数在C++诞生之初是不支持的，是在后面的版本中增加进去的。假设不支持静态成员函数时，类中有一个非公开的静态数据成员，如果外面的代码需要访问这个静态数据，那么就需要写一个非静态成员函数来存取它，而非静态成员函数需要经由对象来调用，但有时间在这个时间点没有创建一个对象或者没有须要创建一个对象，那么就有了以下的变通做法：
  1. // 假设定义了get_static_var函数用于返回静态数据成员
  2. ((Object*) 0))->get_static_var();
  3. // 编译器会转换成：
  4. get_static_var((Object*) 0));
复制代码
上面的代码把0强制转换为Object范例的指针，然后经由它来调用非静态成员函数，编译器会把0作为对象的地址传递给函数，但函数中不会使用这个0，所以不会出现问题。由于有这些需求的存在，C++标准委员会增加了支持静态成员函数，静态成员函数可以访问类中的非公开的静态数据成员，且不需要经由类的对象来调用。
静态成员函数和非静态成员函数、普通函数一样都是存储在代码段中的，也可以获取到它的地址，它是一个实际的内存的地址，是一个数据，如上面定义的static_func函数，它的范例为int (*)()，就是一个普通的函数范例。而非静态成员函数，返回的是一个“指向类成员函数的指针”，如上面定义的print函数，返回的范例是:
void (Object::*) ();
静态成员函数基本上等同于普通函数，所以和C语言结合编程时，可以作为回调函数传递给C语言写的函数。
总结一下，静态成员函数具有以下的特性：

虚函数是否也可以像非虚函数那样获取到它的地址呢？我们写个程序来测试一下。
  1. #include <cstdio>
  3. class Object {
  4. public:
  5.     virtual void virtual_func1() {
  6.         printf("this is virtual function 1\n");
  7.     }
  8.     virtual void virtual_func2() {
  9.         printf("this is virtual function 2\n");
  10.     }
  11. };
  13. int main() {
  14.     printf("Object::virtual_func1 = %p\n", &Object::virtual_func1);
  15.     printf("Object::virtual_func2 = %p\n", &Object::virtual_func2);
  16.     return 0;
  17. }
复制代码
上面程序的输出：
  1. Object::virtual_func1 = 0x0
  2. Object::virtual_func2 = 0x8
复制代码
程序的输出效果并不是一个内存地址，而是一个数字，其实这是一个偏移值，对应的是这个虚函数在虚函数表中的位置，一个位置占用8字节大小，第一个是0，第二个是8，以此类推，每多一个虚函数，就在这个表中占用一个位置。看起来像是无法获取到虚函数的地址，其实否则，虚函数的地址就存放在虚函数表中，只是我们无法直接获取到它，但是我们记得，如果有虚函数时，对象的前面会被编译器插入一个虚函数表指针，这个指针就是指向类的虚函数表，我们可以通过它来获取到虚函数的地址，下面演示一下通过非常规手段来调用虚函数的做法：
  1. #include <cstdio>
  3. class Object {
  4. public:
  5.     virtual void virtual_func1() {
  6.         printf("this is virtual function 1\n");
  7.     }
  8.     virtual void virtual_func2() {
  9.         printf("this is virtual function 2\n");
  10.     }
  11. };
  13. int main() {
  14.     Object* pobj = new Object;
  15.     using Fun = void (*)(void);
  16.     Fun** ptr = (Fun**)pobj;
  17.     printf("vptr = %p\n", *ptr);
  18.     for (auto i = 0; i < 2; ++i) {
  19.         Fun fp = *(*ptr + i);        //取得虚函数的内存地址
  20.         printf("vptr[%d] = %p\n", i, fp);
  21.         fp();        //此行调用虚函数
  22.     }
  23.     delete pobj;
  25.     return 0;
  26. }
复制代码
程序的输出效果：
  1. vptr = 0x100264030
  2. vptr[0] = 0x100263ea4
  3. this is virtual function 1
  4. vptr[1] = 0x100263ecc
  5. this is virtual function 2
复制代码
可以看到，虚函数的地址不光可以获取得到，而且还可以直接调用它，调用它的前提是函数中没有访问类的非静态数据成员，否则就会出现运行错误。vptr就是写入到对象前面的虚函数表指针，它的值就是虚函数表在内存中的地址，虚函数表中记录了两项内容，对应了两个虚函数的地址，即vptr[0]是虚函数virtual_func1的地址，vptr[1]是虚函数virtual_func2的地址。把他们强制转换成普通函数的范例指针，然后可以直接调用他们，所以这里是没有对象的this指针的，也就不能访问类中的非静态数据成员了。
虚函数的实现

从上一小节中我们已经窥探到虚函数的一般实现模型，每一个类有一个虚函数表，虚函数表中包含类中每个虚函数的地址，然后每个对象的前面会被编译器插入一个指向虚函数表的指针，同一个类的所有对象都共享同一个虚函数表。接下来的内容中将详细分析虚函数的实现细节，包罗单一继承、多重继承和虚继承的环境。
多态是C++中最重要的特性之一，也是组成面向对象编程范式的基石，虚函数则是为多态而生。那么作甚多态？多态是在基类中定义一组接口，根据不同的业务场景派生出不同的子类，在子类中实现接口，上层代码根据业务逻辑调用接口，不关心接口的具体实现。在代码中，一般是声明一个基类的指针，此指针在运行期间大概指向不同的派生类，然后通过基类的指针调用一个接口，这个接口在不同的派生类中有不同的实现，所以根据基类的指针指向哪个具体的派生类，调用的就是这个派生类的实例。假设有一个名称为print的接口，p是基类范例的指针，那么下面的调用：
p->print();
是如何识别出要实施多态的行为？以及如何调用到具体哪个派生类中的print？如果是在指针范例上增加信息，以指明具体所指对象的范例，那么会改变指针原有的语义，造成和C语言的不兼容，而且也不是每个范例都需要这个信息，这会造成不须要的空间浪费。如果是在每个类对象中增加信息，那么在不需要多态的对象中也需要存放这些信息，也会造成空间上的浪费。因此增加了一个关键字virtual，用于修饰那些需要多态的函数，这样的函数就叫做虚函数，所以识别一个类是否支持多态，就看这个类中是否声明了虚函数。只要类中有虚函数，就说明需要在类对象中存储运行期的信息。
那么在对象中要存储哪些信息才可以或许包管包管上面代码中print的调用是调用到正确的派生类中的实例呢？要调用到正确的print实例，我们需要知道：
要如何实现它，不同的编译器大概有不同的实现方法，通常是使用虚函数表的做法。编译器在编译的过程中，收集到哪些是虚函数，然后将这些虚函数的地址存放一个表格中，这些虚函数的地址在编译期间确定的，运行期间是不会改变的，虚函数的个数也是固定的，在程序的执行期间不能删除或者增加，所以表格的大小也是固定的，这个过程由编译器在编译期间完成。表格中虚函数的位置按照类中声明的顺序，位置是固定不变的，我们在上节中通过虚函数名称打印出来的值就是虚函数在虚函数表中的位置，即相对于表格首地址的偏移值。
有了这个表格，那么如何寻址到这个表格呢？方法就是编译器根据类中是否有虚函数，如果有虚函数，就在类的构造函数里插入一些汇编代码，在构造对象时，在对象的前面插入一个指针，这个指针指向这个虚函数表，所以这个指针也叫做虚函数表指针。下面以具体的代码来看看虚函数是怎么调用的，把上面的例子main函数修改如下，别的地方不变：
  1. int main() {
  2.     Object* pobj = new Object;
  3.     pobj->virtual_func1();
  4.     pobj->virtual_func2();
  5.     delete pobj;
  7.     return 0;
  8. }
复制代码
我们来看下天生的汇编代码，首先来看看虚函数表长什么样：
  1. vtable for Object:
  2.     .quad   0
  3.     .quad   typeinfo for Object
  4.     .quad   Object::virtual_func1()
  5.     .quad   Object::virtual_func2()
复制代码
它是汇编中定义在数据段的一组数据，“vtable for Object”是它的标签，代表了这个数据区的起始地址，每一行定义一条数据，第一列.quad表示数据的大小，占用8字节，第二列表示数据的值，可以是数字，也可以是标签，标签是地址的引用。其实这个完整的表叫做虚表，它包含了虚函数表、RTTI信息和虚继承相关的信息，Clang和Gcc编译器是把它们合在一起了，别的编译器大概是分开的。第一行是虚继承中用到，之前已经讲过了，第二行是RTTI信息，这个以后再讲。第三、四行是两个虚函数的地址。
接着看看Object类的默认构造函数的代码：
  1. Object::Object() [base object constructor]:         # @Object::Object() [base object constructor]
  2.     # 略...
  3.     lea     rcx, [rip + vtable for Object]
  4.     add     rcx, 16
  5.     mov     qword ptr [rax], rcx
  6.     # 略...
复制代码
之前已经讲过，有虚函数时编译器会为类天生默认构造函数，在默认构造函数里在类对象的前面设置了虚函数表指针。在这个默认构造函数里，主要的代码就是上面这三行，首先获取虚表（将上面）的起始地址存放在rcx寄存器，然后加上16的偏移值跳过第一、二行，这时指向第三行数据，也就是第一个虚函数的位置，然后将这个地址赋值给[rax]，rax是存放的对象的首地址，这就完成了给对象设置虚函数表指针。
接着看main函数中对虚函数的调用：
  1. main:                                                                # @main
  2.     # 略...
  3.           # 调用构造函数
  4.     mov     rdi, rax
  5.     mov     qword ptr [rbp - 32], rdi       # 8-byte Spill
  6.     call    Object::Object() [base object constructor]
  7.     mov     rax, qword ptr [rbp - 32]       # 8-byte Reload
  8.     mov     qword ptr [rbp - 16], rax
  9.                 # 调用第一个虚函数
  10.     mov     rdi, qword ptr [rbp - 16]
  11.     mov     rax, qword ptr [rdi]
  12.     call    qword ptr [rax]
  13.           # 调用第二个虚函数
  14.     mov     rdi, qword ptr [rbp - 16]
  15.     mov     rax, qword ptr [rdi]
  16.     call    qword ptr [rax + 8]
  17.     # 略...
复制代码
上面汇编代码中的第4行rax是调用new函数后返返来的地址，也就是pobj指针，把它存放到rdi寄存器中作为参数，同时也生存到栈空间rbp - 32中，然后调用构造函数，构造完成之后再拷贝这个地址到栈空间rbp - 16中。接下来的第10到12行是第一个虚函数的调用，将对象的首地址加载到rdi寄存器中，然后对其取内容，也就是是相当于指针的解引用，即 (*pobj)，取得的内容即是构造函数中设置的虚函数表的地址，它是一个指向第一个虚函数的地址，然后第12行对其取内容，也即是对这个地址解引用，取得第一个虚函数的地址，然后以rdi寄存器（即对象的首地址）为第一个参数调用它，相当于：virtual_func1(pobj)。第14到16行是对第二个虚函数的调用，流程和第一个基本一样，区别在于将虚函数表的地址加上8的偏移量以指向第二个虚函数。
如果在一个虚函数中调用另一个虚函数又会怎样？第一个虚函数已经决议出是调用哪个对象的实例了，那么在此中调用别的虚函数还需要再动态决议吗？把main函数中对第二个虚函数的调用去掉，在第一个虚函数中增加以下代码：
  1. virtual_func2();
  2. Object::virtual_func2();
复制代码
来看下对应天生的汇编代码，别的代码都差不多，主要看virtual_func1函数的代码：
  1. Object::virtual_func1():            # @Object::virtual_func1()
  2.     # 略...
  3.     mov     rdi, qword ptr [rbp - 16]       # 8-byte Reload
  4.     mov     rax, qword ptr [rdi]
  5.     call    qword ptr [rax + 8]
  6.     mov     rdi, qword ptr [rbp - 16]       # 8-byte Reload
  7.     call    Object::virtual_func2()
  8.     # 略...
复制代码
rbp - 16生存的是对象的首地址，第3到5行对应的是上面C++代码中第一句的调用，看起来在虚函数中调用另一个虚函数，用的还是动态决议的方法，这里编译器没有识别出已经决议出具体的对象了。从汇编代码的第6、7行看到，通过前面加类名的限定符，是直接调用到这个函数，如果你明确调用的是哪个函数的话，可以直接在函数的前面加上类名，这样就不需要用多态的方式去调用了。
如果不是通过指针范例来调用虚函数，而是通过对象来调用，效果是什么环境？把main函数改成如下：
  1. int main() {
  2.     Object obj;
  3.     obj.virtual_func1();
  4.     obj.virtual_func2();
  6.     return 0;
  7. }
复制代码
查看main函数对应的汇编代码：
  1. main:                           # @main
  2.     # 略...
  3.     lea     rdi, [rbp - 16]
  4.     call    Object::virtual_func1()
  5.     lea     rdi, [rbp - 16]
  6.     call    Object::virtual_func2()
  7.     # 略...
复制代码
可以看到通过对象来调用虚函数，是直接调用到这个对象的函数实例的，没有使用多态的方式，所以通过对象的方式调用是没有多态的行为的，只有通过类的指针或者引用范例来调用虚函数，才会有多态的行为。
单一继承下的虚函数

假设有以下的类定义及继承关系：
  1. class Point {
  2. public:
  3.     Point(int x = 0) { _x = x; }
  4.     virtual ~Point() = default;
  5.     virtual void drawLine() = 0;
  6.     int x() { return _x; }
  7.     virtual int y() { return 0; }
  8.     virtual int z() { return 0; }
  9. private:
  10.     int _x;
  11. };
  12. class Point2d: public Point {
  13. public:
  14.     Point2d(int x = 0, int y = 0): Point(x) { _y = y; }
  15.     virtual ~Point2d() = default;
  16.     void drawLine() override { }
  17.     virtual void rotate() { }
  18.     int y() override { return _y; }
  19. private:
  20.     int _y;
  21. };
  22. class Point3d: public Point2d {
  23. public:
  24.     Point3d(int x = 0, int y = 0, int z = 0): Point2d(x, y) { _z = z; }
  25.     virtual ~Point3d() = default;
  26.     void drawLine() override { }
  27.     void rotate() override { }
  28.     int z() override { return _z; }
  29. private:
  30.     int _z;
  31. };
  33. int main() {
  34.     Point* p = new Point3d(1, 1, 1);
  35.     printf("z = %d\n", p->z());
  36.     delete p;
  37.     return 0;
  38. }
复制代码
先来看看天生的汇编代码中的虚函数表：
  1. vtable for Point:
  2.     .quad   0
  3.     .quad   typeinfo for Point
  4.     .quad   Point::~Point() [base object destructor]
  5.     .quad   Point::~Point() [deleting destructor]
  6.     .quad   __cxa_pure_virtual
  7.     .quad   Point::y()
  8.     .quad   Point::z()
  10. vtable for Point2d:
  11.     .quad   0
  12.     .quad   typeinfo for Point2d
  13.     .quad   Point2d::~Point2d() [base object destructor]
  14.     .quad   Point2d::~Point2d() [deleting destructor]
  15.     .quad   Point2d::drawLine()
  16.     .quad   Point2d::y()
  17.     .quad   Point::z()
  18.     .quad   Point2d::rotate()
  20. vtable for Point3d:
  21.     .quad   0
  22.     .quad   typeinfo for Point3d
  23.     .quad   Point3d::~Point3d() [base object destructor]
  24.     .quad   Point3d::~Point3d() [deleting destructor]
  25.     .quad   Point3d::drawLine()
  26.     .quad   Point2d::y()
  27.     .quad   Point3d::z()
  28.     .quad   Point3d::rotate()
复制代码
每个类都有一个对应的虚函数表，虚函数表中的内容主要来自于三方面：
基类和子类使用各自的虚函数表，互不干扰，即使子类中没有改写基类的虚函数，也没有新增虚函数，编译器也会为子类新建一个虚函数表，内容从基类中拷贝过来，内容和基类完全一样。
虚函数表中的虚函数的分列顺序是固定的，一般是按照在类中的声明顺序，如C++代码中的这行代码：
p->z();
要寻址到正确的z函数实例的地址，我们首先需要知道p指针所指向的具体对象，然后需要知道z函数在表格中的位置，如上例中，z函数在第5个条目，也就是说虚函数表的起始地址加上32的偏移量就可以寻址到它，这个位置保持不变，无论p指针指向哪个对象，都能找到正确的z函数。如果子类中有新增的虚函数，新增的虚函数声明的位置插在从基类中继承来的虚函数中间，编译器会做调整，把它安排在后面，在原有的顺序上再递增，如上例中的rotate函数。
如果您感爱好这方面的内容，请在微信上搜索公众号iShare爱分享并关注，以便在内容更新时直接向您推送。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4