深入浅出C++虚函数的vptr与vtable

1.基础理论

为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。

虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的最派生函数。

其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。

因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。

2.实现与内部结构

下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！

开始看代码之前，为了方便大家理解，这里给出调用图：

base

代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！

  1. /**
  2.  * @file vptr1.cpp
  3.  * @brief C++虚函数vptr和vtable
  4.  * 编译：g++ -g -o vptr vptr1.cpp -std=c++11
  5.  * @author 光城
  6.  * @version v1
  7.  * @date 2019-07-20
  8.  */
  10. #include <iostream>
  11. #include <stdio.h>
  12. using namespace std;
  14. /**
  15.  * @brief 函数指针
  16.  */
  17. typedef void (*Fun)();
  19. /**
  20.  * @brief 基类
  21.  */
  22. class Base
  23. {
  24.     public:
  25.         Base(){};
  26.         virtual void fun1()
  27.         {
  28.             cout << "Base::fun1()" << endl;
  29.         }
  30.         virtual void fun2()
  31.         {
  32.             cout << "Base::fun2()" << endl;
  33.         }
  34.         virtual void fun3(){}
  35.         ~Base(){};
  36. };
  38. /**
  39.  * @brief 派生类
  40.  */
  41. class Derived: public Base
  42. {
  43.     public:
  44.         Derived(){};
  45.         void fun1()
  46.         {
  47.             cout << "Derived::fun1()" << endl;
  48.         }
  49.         void fun2()
  50.         {
  51.             cout << "DerivedClass::fun2()" << endl;
  52.         }
  53.         ~Derived(){};
  54. };
  55. /**
  56.  * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表
  57.  *
  58.  * @param obj
  59.  * @param offset
  60.  *
  61.  * @return 
  62.  */
  63. Fun getAddr(void* obj,unsigned int offset)
  64. {
  65.     cout<<"======================="<<endl;
  66.     void* vptr_addr = (void *)*(unsigned long *)obj;  //64位操作系统，占8字节，通过*(unsigned long *)obj取出前8字节，即vptr指针
  67.     printf("vptr_addr:%p\n",vptr_addr);
  69.     /**
  70.      * @brief 通过vptr指针访问virtual table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned long *)vptr_addr取出前8字节，
  71.      * 后面加上偏移量就是每个函数的地址！
  72.      */
  73.     void* func_addr = (void *)*((unsigned long *)vptr_addr+offset);
  74.     printf("func_addr:%p\n",func_addr);
  75.     return (Fun)func_addr;
  76. }
  77. int main(void)
  78. {
  79.     Base ptr;
  80.     Derived d;
  81.     Base *pt = new Derived(); // 基类指针指向派生类实例
  82.     Base &pp = ptr; // 基类引用指向基类实例
  83.     Base &p = d; // 基类引用指向派生类实例
  84.     cout<<"基类对象直接调用"<<endl;
  85.     ptr.fun1();
  86.     cout<<"基类引用指向派生类实例"<<endl;
  87.     pp.fun1(); 
  88.     cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
  89.     pt->fun1();
  90.     cout<<"基类引用指向基类实例并调用虚函数"<<endl;
  91.     p.fun1();
  93.     // 手动查找vptr 和 vtable
  94.     Fun f1 = getAddr(pt, 0);
  95.     (*f1)();
  96.     Fun f2 = getAddr(pt, 1);
  97.     (*f2)();
  98.     delete pt;
  99.     return 0;
  100. }

运行结果：

  1. 基类对象直接调用
  2. Base::fun1()
  3. 基类引用指向派生类实例
  4. Base::fun1()
  5. 基类指针指向派生类实例并调用虚函数
  6. Derived::fun1()
  7. 基类引用指向基类实例并调用虚函数
  8. Derived::fun1()
  9. =======================
  10. vptr_addr:0x401130
  11. func_addr:0x400ea8
  12. Derived::fun1()
  13. =======================
  14. vptr_addr:0x401130
  15. func_addr:0x400ed4
  16. DerivedClass::fun2()

我们发现C++的动态多态性是通过虚函数来实现的。简单的说，通过virtual函数，指向子类的基类指针可以调用子类的函数。例如，上述通过基类指针指向派生类实例，并调用虚函数，将上述代码简化为：

  1. Base *pt = new Derived(); // 基类指针指向派生类实例
  2. cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
  3. pt->fun1();

其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()!

除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述pt->fun1()的时候，是否一致！

这里采用gdb调试，在编译的时候记得加上-g。

通过gdb vptr进入gdb调试页面，然后输入b Derived::fun1对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过disassemable fun1可以查看当前有关fun1中的相关汇编代码，我们看到了0x0000000000400ea8，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确!

gdb调试信息如下：

  1. (gdb) b Derived::fun1
  2. Breakpoint 1 at 0x400eb4: file vptr1.cpp, line 23.
  3. (gdb) r
  4. Starting program: /home/light/Program/CPlusPlusThings/virtual/pure_virtualAndabstract_class/vptr 
  5. 基类对象直接调用
  6. Base::fun1()
  7. 基类引用指向派生类实例
  8. Base::fun1()
  9. 基类指针指向派生类实例并调用虚函数
  11. Breakpoint 1, Derived::fun1 (this=0x614c20) at vptr1.cpp:23
  12. 23              cout << "Derived::fun1()" << endl;
  13. (gdb) disassemble fun1
  14. Dump of assembler code for function Derived::fun1():
  15.    0x0000000000400ea8 <+0>: push   %rbp
  16.    0x0000000000400ea9 <+1>: mov    %rsp,%rbp
  17.    0x0000000000400eac <+4>: sub    $0x10,%rsp
  18.    0x0000000000400eb0 <+8>: mov    %rdi,-0x8(%rbp)
  19. => 0x0000000000400eb4 <+12>:    mov    $0x401013,%esi
  20.    0x0000000000400eb9 <+17>:    mov    $0x602100,%edi
  21.    0x0000000000400ebe <+22>:    callq  0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  22.    0x0000000000400ec3 <+27>:    mov    $0x400a00,%esi
  23.    0x0000000000400ec8 <+32>:    mov    %rax,%rdi
  24.    0x0000000000400ecb <+35>:    callq  0x4009f0 <_ZNSolsEPFRSoS_E@plt>
  25.    0x0000000000400ed0 <+40>:    nop
  26.    0x0000000000400ed1 <+41>:    leaveq 
  27.    0x0000000000400ed2 <+42>:    retq   
  28. End of assembler dump.
  29. (gdb) disassemble fun2
  30. Dump of assembler code for function Derived::fun2():
  31.    0x0000000000400ed4 <+0>: push   %rbp
  32.    0x0000000000400ed5 <+1>: mov    %rsp,%rbp
  33.    0x0000000000400ed8 <+4>: sub    $0x10,%rsp
  34.    0x0000000000400edc <+8>: mov    %rdi,-0x8(%rbp)
  35.    0x0000000000400ee0 <+12>:    mov    $0x401023,%esi
  36.    0x0000000000400ee5 <+17>:    mov    $0x602100,%edi
  37.    0x0000000000400eea <+22>:    callq  0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  38.    0x0000000000400eef <+27>:    mov    $0x400a00,%esi
  39.    0x0000000000400ef4 <+32>:    mov    %rax,%rdi
  40.    0x0000000000400ef7 <+35>:    callq  0x4009f0 <_ZNSolsEPFRSoS_E@plt>
  41.    0x0000000000400efc <+40>:    nop
  42.    0x0000000000400efd <+41>:    leaveq 
  43.    0x0000000000400efe <+42>:    retq   
  44. End of assembler dump.