C++幕后故事（四）--虚函数的故事

提出问题：

我们讨论前提都是在windows 10 vs2013 debug模式下

1.虚函数指针和虚表在哪里？
2.我们如何手动调用虚函数？
3.为什么只有在子类以父类的引用或者指针的形式才能出现多态？
4.虚函数的调用为什么效率相比普通的成员函数较低？又具体低了多少？
5.为什么构造函数和析构函数尽量不要调用虚函数？
6.纯虚函数到底是什么？为什么禁止我调用？有什么办法可以绕编译器？

7.看码说话

class MemsetObj {
public:
    MemsetObj()
{
    memset(this, 0, sizeof(MemsetObj));
        cout << "memsetobj ctor" << endl;
    }
    void test() { cout << "memset obj test" << endl; }
    virtual void virtual_func() {  cout << "virtual test" << endl; }
};
     // 1.
    MemsetObj obj;
    obj.virtual_func();
     // 2.
    MemsetObj *pobj = new MemsetObj();
    pobj->virtual_func();
// 这两种方式调用有问题？什么问题？

0.基础知识说明

1.VS 调试

1.打开内存窗口

1. 先下断点
2. 在VS中启动程序
3. VS就会你下的断点处停下
4. 在菜单栏->调试->窗口->内存，就会发现4个内存选项随便选择一个就可以

2.打开反汇编窗口

1. 同样在调试的状态下，鼠标右键菜单->转到反汇编点

2.汇编指令

这里我解释下常用的和常见的一些指令，更多的需要大家自己课后学习。

1. 汇编中有些通用的寄存器分别为eax,ebx,ecx,edx,esi,edi,esp,ebp,es,ds,ss,sp等等，类似高级语言中的变量，但是这些变量的数量和名称都是固定的。
2. mov ax,bx ; 将bx的内容移动ax中
3. lea ax,[obj] ; load effective address 将obj对象的地址移动ax中
4. pop,push 就是栈中的压栈和出栈的操作，函数中的参数就是这么传递的。
5. 在汇编的角度看C++的成员函数调用的方式叫做__thiscall，就是C++中的this指针，是通过ecx指针传递的，所以会经常看到lea ecx,[base] call FunctionName，套路都是固定的。

1.虚函数的含义

只有用virtual声明类的成员函数，称之为虚函数。

2.虚函数的作用

就是一句话：实现多态的基石
实现多态的三大步：

1. 存在继承关系
   
2. 重写父类的virtual function
   
3. 子类以父类的指针或者是引用的身份出现

3.虚函数的实现原理

相信很多人都能说出来其中实现关键原理，就是两点：虚函数表指针（vptr），虚函数表（vftable）

3.1 虚函数表指针

1. 什么是虚函数表指针，他在哪里，有什么用？

我们把对象从首地址开始的4个字节，这个位置我们称之为虚函数表指针（vptr），它里面包含一个地址指向的就是虚函数表（vftable）的地址。

3.2虚函数表

1. 什么是虚函数表，他又在哪里，有什么用？

虚函数表说白了就是里面是一组地址的数组（就是函数指针数组），他所在的位置就是虚函数表指针里面所存储的地址，它里面所包含的地址就是我们重写了父类的虚函数的地址（没有重写父类的虚函数那么默认的就是父类的函数地址）。

3.3 探索虚表位置

1. 手动探索虚表位置

class Base 
{
public:
    int m_a = 0;
    virtual void f() { cout << "Base::f()" << endl; }
    virtual void g() { cout << "Base::g()" << endl; }
virtual void h() { cout << "Base::h()" << endl; }
    // virtual ~Base() { cout << "~Base" << endl; }
 };
class BaseOne
{
public:
    int m_b = 0;
    virtual void i() { cout << "BaseOne::i()" << endl; }
    virtual void j() { cout << "BaseOne::j()" << endl; }
virtual void k() { cout << "BaseOne::k()" << endl; }
// virtual ~ BaseOne () { cout << "~ BaseOne " << endl; }
};
class Derive : public Base
{
public:
    int m_d = 0;
virtual void g() { cout << "Derive::g()" << endl; }
// virtual ~ Derive () { cout << "~ Derive " << endl; }
};
class MultiDerive: public BaseOne, public Base
{
public:
    int m_e = 0;
    virtual void h() { cout << "MultiDerive::h()" << endl; }
    virtual void k() { cout << "MultiDerive::k()" << endl; }
virtual void m() { cout << "MultiDerive::m()" << endl; }
// virtual ~ MultiDerive () { cout << "~ MultiDerive " << endl; }
};

如果代码看的累，我们直接看图（这里我没有用UML图表示）：

既然我们知道vptr的位置，我们开始尝试手动调用虚函数

typedef void (*Fun)();
void test_multi_inhert_virtual_fun()
{
    MultiDerive multiderive;
    // 从对象的首地址4个字节，获取vptr的地址，x86平台下指针都是4个字节
    long *pbaseone_tablepoint      = (long *)(&multiderive);
    // 对vptr指针解引用操作获取vftable的地址
    long *baseone_table_address    = (long *)*(pbaseone_tablepoint);
    for(int i = 0; i < 4; ++i) {
        cout << std::hex << "0x" << baseone_table_address[i] << endl;
    }
    ((Fun)(baseone_table_address[0]))();
    ((Fun)(baseone_table_address[1]))();
    ((Fun)(baseone_table_address[2]))();
    /* 打印的结果
    BaseOne::i()
    BaseOne::j()
    MultiDerive::k()
    */
    // 获取第二个虚函数表指针的位置，从基址开始的地址+第一个继承对象的大小
    long *pbase_tablepoint = 
        (long *)(reinterpret_cast<char *>(pbaseone_tablepoint)+sizeof(BaseOne));
    long *base_table_address = (long *)(*pbase_tablepoint);
    for(int i = 0; i < 4; ++i) {
        cout << std::hex << "0x" << base_table_address[i] << endl;
    }
    ((Fun)(base_table_address[0]))();
    ((Fun)(base_table_address[1]))();
    ((Fun)(base_table_address[2]))();
    /*打印的结果
    Base::f()
    Base::g()
    MultiDerive::h()
    */
}

对于不想看代码的同学，我画了一张图

对于这张图里面的一些强转我做些解释：

1. x86平台下，指针类型都是4个字节，所用你可以把long *替换为int *没有问题，只要这个指针的步长是4字节的都可以。
2. 获取第二个vftable时，强转为char*类型，因为指针类型做+/-运算有个步长概念，有的称之为比例因子。

函数	打印结果
((Fun)(baseone_table_address[0]))();	BaseOne::i()
((Fun)(baseone_table_address[1]))();	BaseOne::j()
((Fun)(baseone_table_address[2]))();	MultiDerive::k()
((Fun)(base_table_address[0]))();	Base::f()
((Fun)(base_table_address[1]))();	Base::g()
((Fun)(base_table_address[2]))();	MultiDerive::h()

从表中我们可以看出来，其实这个vptr和vftable也没啥神秘的地方，就是一个指针指向装有函数指针的数组。数组里面的内容如果子类没有override，那么默认值就是父类的虚函数地址，否则就是子类自己的函数（表中红色部分）

2.cl.exe验证虚表的位置

我们对类的声明代码稍作修改，做成独立的cpp文件

/****************************************************************************
**
** Copyright (C) 2019 [email protected]
** All rights reserved.
**
****************************************************************************/
#include 
using std::cout;
using std::endl;
class BaseOne
{
public:
    int m_b = 0;
    virtual void i() { cout << "BaseOne::i()" << endl; }
    virtual void j() { cout << "BaseOne::j()" << endl; }
    virtual void k() { cout << "BaseOne::k()" << endl; } 
};
class Base
{
public:
    int m_a = 0;
    virtual void f() { cout << "Base::f()" << endl; }
    virtual void g() { cout << "Base::g()" << endl; }
    virtual void h() { cout << "Base::h()" << endl; }
};
class MultiDerive :public BaseOne, public Base
{
public:
    int m_e = 0;
    virtual void h() { cout << "MultiDerive::h()" << endl; }
    virtual void k() { cout << "MultiDerive::k()" << endl; }
    virtual void m() { cout << "MultiDerive::m()" << endl; }
};

int main()
{   
    return 1;
}

在windows菜单中找到vs2013命令行工具

cd 到你所在cpp文件的目录中比如我：cd /d j:\code\polymorphism_virtual\source
执行命令 cl /d1 reportSingleClassLayoutMultiDerive analysis_virtual_by_tools.cpp
注意MultiDerive表示你想导出来的类布局

从导出来的数据中可以看出：

1.MultiDerive大小、内存布局、以及成员变量的偏移、vftable的寻址

2.大家可能看到红色标注的-8有点奇怪，这个就是计算第二个vptr的偏移地址，计算方式是首地址-第二个vptr的所在的地址=-8，他们之间的距离就是一个BaseOne的大小。

3.VS IDE查看虚表位置

这种方式比较简答，就是启动VS，下个断点，将鼠标移动到MultiDerive实例上，可以看到详细的信息。

从这里你可能发现一个问题，子类自己的虚函数这里没有体现出来，所以建议cl.exe工具验证虚表。

4.内存布局图

到这里我们可以画图上述代码中类的内存布局图：

从Derive和MultiDerive内存图我们发现一些规律：

1.继承的体系越复杂，子类的体积越大。

2.子类中普通成员顺序按照继承的先后顺序来的。

3.多重继承，子类中含有多个vptr，分别指向不同的vftable。

4. vftable中的虚函数地址和在类中声明的顺序一致。

5.如果子类override父类中虚函数，那么子类vftable中就会替换原来父类的虚函数。

6.如果子类自己含有额外的虚函数，则会附加到第一个vftable中。

7. vftable中的最后一个值可能为0x0，有时候并不是为0，上图中红色字部分。

8.子类有vftable，同时父类也有一份vftable，两个vftable没有关联。每个实例化子类都共享一个vftable，同样父类所有实例化对象也共享一份vftable，非常类似类的静态变量

3.4虚析构函数用函数指针间接调用会崩溃

眼尖的同学可能注意到探索虚表位置的代码，我注释掉了父类中所有的虚析构函数。我本想拿到虚表地址，就拿到了虚析构函数的地址，我用函数指针强制转换就可以调用，但是我一调用就崩溃。好，废话不说，反汇编走起来。

1.手动调用析构函数的反汇编代码

;  base.~Base();
; 传递参数0
002D99EF  push        0  
; 传递this到ecx
002D99F1  lea         ecx,[base]  
; 调用一个类似析构函数的函数
002D99F4  call        virtual_fun_table::Base::`scalar deleting destructor' (02D16C2h) 

2.动手验证猜想

看了反汇编代码，会惊讶的发现，居然push 0了，说明编译器帮我们传递一个参数，那我们就自己手动也传递一个，你同时发现了这里并不是直接调用Base的析构函数（代理析构函数）。

typedef void (*DctorFun)(int);
Base base;
base.~Base();
long *vptr      = (long *)(&base);
long *vftable   = (long *)(*vptr);
((Fun)(vftable[0]))();
((Fun)(vftable[1]))();
((Fun)(vftable[2]))();
((DctorFun)(vftable[3]))(0); ; 调用Base的虚析构函数

恩，应该没有问题了，开心的跑起来，VS F5跑起来。但还是抛出异常了…
想不出来啥原因，还是看反汇编吧，不断的跟啊跟啊，发现崩溃在~Base函数里面。

01276EFF  pop          ecx  
01276F00  mov         dword ptr [this],ecx  
01276F03  mov         eax,dword ptr [this]  
01276F06  mov         dword ptr [eax],1282BD8h

这里拿到ecx，然后又一次赋值虚表地址1282BD8h。但是我们是直接调用虚函数，没有push ecx，所以这里拿到的ecx值是个不确定的值就相当于一个野指针问题。
我们知道了为什么崩溃的原因，但是仔细想想这里为什么还需要再一次重新赋值虚表地址，在构造函数的时候不是已经初始化好虚表的地址了？
试想下这样的情形：Derive继承Base，在调用Derive析构函数时，先是调用Derive的析构函数，再Base调用的析构函数。如果在调用Base的析构函数时不重置虚表的话，那么Base中可能出现间接的调用Derive虚函数，而此时Derive的已经执行过析构函数，里面的数据已经是不可靠的，存在安全隐患。
同时得出结论析构函数和构造函数中调用虚函数并没有多态的特性。
关于间接的调用虚函数说明：
我们知道，在构造函数中直接调用虚函数的话，是没有多态的特性，但是如果我们写一个函数，这个函数再去调用虚函数，这个时候生成的汇编代码，会根据虚表找函数地址，就有了多态的特性。有兴趣的同学可以自己反汇编验证下。

4.vptr和vftable的初始化问题

4.1 vptr什么时候初始化？

1.对象初始化时

2.拷贝构造调用

我们从汇编的角度看，在对象初始化时如何设置vftable的地址。

在vs2013 在调试状态下，右键转到反汇编就可以看到汇编代码

// c++代码
MultiDerive multiderive;

这下面三个都是汇编代码

; MultiDerive multiderive;
; multiderive的地址放到ecx寄存器中
00FC9CD8  lea           ecx,[multiderive]
; 调用MultiDerive构造函数
00FC9CDB  call          virtual_fun_table::MultiDerive::MultiDerive (0FC12BCh) 

; 跳转到 virtual_fun_table::MultiDerive::MultiDerive:
00FC12BC  jmp         virtual_fun_table::MultiDerive::MultiDerive (0FC4180h) 

00FC4180  push        ebp  
00FC4181  mov        ebp,esp  
00FC4183  sub         esp,0CCh  
00FC4189  push        ebx  
00FC418A  push        esi  
00FC418B  push        edi  
00FC418C  push        ecx  
00FC418D  lea          edi,[ebp-0CCh]  
00FC4193  mov         ecx,33h  
00FC4198  mov         eax,0CCCCCCCCh  
00FC419D  rep stos    dword ptr es:[edi]  ; 从00FC4180~00FC419D都是做函数调用过程初始化准备
00FC419F  pop         ecx                       ; 拿到this指针
00FC41A0  mov        dword ptr [this],ecx  
00FC41A3  mov        ecx,dword ptr [this]  
00FC41A6  call         virtual_fun_table::BaseOne::BaseOne (0FC1235h)  ; 调用BaseOne的构造函数
00FC41AB  mov        ecx,dword ptr [this]  
00FC41AE  add         ecx,8                 ; 调整this指针偏移，并将this指针传递给调用Base构造函数
00FC41B1  call          virtual_fun_table::Base::Base (0FC15D2h)  
00FC41B6  mov         eax,dword ptr [this]  
00FC41B9  mov         dword ptr [eax],0FD1B54h  ; 将vftable的地址设置到第一个vptr中
00FC41BF  mov         eax,dword ptr [this]              
00FC41C2  mov         dword ptr [eax+8],0FD1B6Ch ;跳过8字节，设置第二个虚表地址放到第二个vptr中
00FC41C9  mov         eax,dword ptr [this]  
00FC41CC  mov         dword ptr [eax+10h],0  
00FC41D3  mov         eax,dword ptr [this]  
00FC41D6  pop         edi  
00FC41D7  pop         esi  
00FC41D8  pop         ebx  
00FC41D9  add         esp,0CCh  
00FC41DF  cmp         ebp,esp  
00FC41E1  call          __RTC_CheckEsp (0FC1488h)  
00FC41E6  mov         esp,ebp  
00FC41E8  pop          ebp  
00FC41E9  ret  

关于这里的汇编代码做下说明：

1. c++中类成员的函数调用叫做thiscall方式，就是this指针通过ecx寄存器来传递的。
2. 注意看下旁边的注释行文字
3. 代码中红色加粗的两个地址0FD1B54h，0FD1B6Ch就是关键的vftable地址
4. 这里我只带领大家看了构造函数的，那么拷贝构造原理是一样的大家可以自己尝试。
   如果大家的汇编看不懂，就看看下面的这张调用图便于大家的理解：

4.2 vftable里面的内容什么时候初始化？

这个编译器在编译期间就已经初始化好了，为每个类确定好了虚表里面对应的内容。

5.到底是怎么实现多态特性

前面，我们详细介绍了虚函数的实现细节，但是子类为什么以父类引用或指针的身份出现就会有多态的特性，总感觉还有一层窗户纸没有捅破。
上代码，我们看下面的这段代码

;  MultiDerive multiderive;  c++代码
01289FC8  lea         ecx,[multiderive]  
01289FCB  call        virtual_fun_table::MultiDerive::MultiDerive (012812BCh)  
 ;   multiderive.m(); c++代码
 ; 注意看这里以普通的身份调用虚函数，就两行汇编代码，直接调用传递this指针
01289FD0  lea         ecx,[multiderive]  
01289FD3  call        virtual_fun_table::MultiDerive::m (012812F8h)  

; MultiDerive *multiderive2 = new MultiDerive(); c++代码
; 这里从0x01289FD8~到0x0128A014主要是进行了申请堆内存
; 申请成功了调用构造函数，申请失败跳过构造函数
01289FD8  push        14h  
01289FDA  call         operator new (01281587h)  
01289FDF  add         esp,4  
01289FE2  mov         dword ptr [ebp-13Ch],eax  
01289FE8  cmp         dword ptr [ebp-13Ch],0  
01289FEF  je            virtual_fun_table::test_multi_inhert_virtual_fun+64h (0128A004h)  
01289FF1  mov         ecx,dword ptr [ebp-13Ch]  
01289FF7  call          virtual_fun_table::MultiDerive::MultiDerive (012812BCh)  
01289FFC  mov         dword ptr [ebp-144h],eax  
0128A002  jmp         virtual_fun_table::test_multi_inhert_virtual_fun+6Eh (0128A00Eh)  
0128A004  mov         dword ptr [ebp-144h],0  
0128A00E  mov         eax,dword ptr [ebp-144h]  
0128A014  mov         dword ptr [multiderive2],eax  
; multiderive2->m(); c++代码
; 这里是我们需要看的重点内容
; 将multiderive2的首地址，放到eax寄存器
0128A017  mov         eax,dword ptr [multiderive2]  
; eax就是我们之前说的vptr，对vptr解引用获取到vftable地址放到edx
0128A01A  mov         edx,dword ptr [eax]  
0128A01C  mov         esi,esp  
; thiscall方式调用，通过ecx传递this指针地址
0128A01E  mov          ecx,dword ptr [multiderive2]  
; edx里面存放了vftable的地址+偏移地址
; 还原成高级语言就是数组取值 eax = vftable[0CH]，每个函数指针是4个字节，4*3=12byte
; eax中就是存放了虚函数m的地址
0128A021  mov         eax,dword ptr [edx+0Ch]  
0128A024  call          eax  
0128A026  cmp         esi,esp  
0128A028  call          __RTC_CheckEsp (01281488h)  

我们简化下来对比下代码

multiderive.m();	01289FD0 lea ecx,[multiderive] 01289FD3 call virtual_fun_table::MultiDerive::m (012812F8h)
multiderive2->m();	0128A017 mov eax,dword ptr [multiderive2] 0128A01A mov edx,dword ptr [eax] 0128A01C mov esi,esp 0128A01E mov ecx,dword ptr [multiderive2] 0128A021 mov eax,dword ptr [edx+0Ch] 0128A024 call eax

如果不是引用或者指针，虚函数的调用则是直接寻址，2行汇编代码搞定。

如果是指针或者是引用，看出虚函数的寻址并不是那么简单的。先是找到vptr再找到vftable在加上偏移地址(偏移量是在编译器就已经确定的)最后才是真正的函数调用地址，用了6行代码。

现在你能理解为什么虚函数的调用效率比较慢了吧。

6.纯虚函数理解

6.1 含义：

如果我们在虚函数原型的后面加上=0（virtual void func()= 0），同时这个函数是没有实现的。

6.2作用

有纯虚函数的类表示这是一个抽象类，既然是抽象的，那么肯定就是不能实例化。关于抽象类不能实例化可以从逻辑上理解也是合理的，比如说：动物，老虎，狮子，人都是动物。但是你说动物没人能理解你说的动物到底指的是什么东西。

由纯虚函数的引出了抽象类，抽象类的出现是为了解决什么问题？

抽象类就是为了被继承的，它为子类实例化提供蓝图。在相关的组织继承层次中，它来提供一个公共的根。其他相关子类都是这里衍生出来。

它与接口的区别是什么？

接口是对动作的抽象，抽象类是对根源的抽象。比如说人，有五官，有其他属性。但是吃这个动作应该定义为接口更合适。因为其他动物也有吃的动作。

6.3 从汇编角度看纯虚函数特别之处

1.间接的查看AbstractBase虚表内容

// #define test_call_abstract_virtual_fun 1
class AbstractBase
{
public:
#ifdef test_call_abstract_virtual_fun
AbstractBase()      { CallAbsFunc(); }
void CallAbsFunc()  { AbsFunc(); }
#else
    AbstractBase()      { }
#endif // test_call_abstract_virtual_fun
    virtual void AbsFunc()  = 0;
    virtual void AbsFunc2() = 0;
};
class Child : public AbstractBase
{
public:
    Child()         { AbsFunc(); }
    void AbsFunc()  { cout << "" << endl; }
    void AbsFunc2() { cout << "" << endl; }
};
void test_abstract_virtual_fun()
{
    // 因为抽象类不能直接实例化，通过子类实例化，反汇编找到AbstractBase找到构造函数
    AbstractBase *child = new Child();
    child->AbsFunc();
}

在24行代码处下断点->启动vs->右键菜单->反汇编->快捷键F11单步调试。
反汇编的代码比较多，我就挑出重点的代码画图解释下：

在反汇编的时候，我们拿到了虚表的地址0x0F82D98，我们把这个地址放到vs2013中的内存窗口中。根据我们前面的学到的知识，就知道AbstractBase应该有两个虚函数，那么表中应该有两个函数指针，如下图所示。但是你会惊讶的发现表中的两个函数指针都是0x00f714ab。

2.纯虚类虚表中不仅有内容还是一样的？

现在我们很好奇，为什么虚表中的内容的是一样的。还有纯虚类的虚函数都没有任何的实现的，为什么虚表中还有内容。还有这个地址到底是个什么？干啥的？

那我就在想，如果我可以拿到这个地址直接转成函数指针，通过函数指针调用就可以了。

1. 方案一：在纯虚父类构造函数中，直接调用纯虚函数，编译失败error LNK2019: 无法解析的外部符号（因为纯虚函数没有实现，直接调用没有任何意义）。方案否决。

2. 方案二：尝试拿到纯虚父类的vftable地址，但是发现纯虚父类不能实例化。方案否决。

3. 方案三：尝试在子类构造函数，拿到this指针的，在根据this指针拿到虚表地址。反汇编的代码看编译器的代码先于我的代码执行，就是说等到了执行我的代码时候，这个this指针已经不是纯虚父类的vftable，而是子类的vftable了。
   貌似进入死胡同，没有方案了。

问题回到刚开始时候，我现在是怎么拿到纯虚父类的vftable。我是实例化了子类，然后反汇编F11一步步跟过去的。就是说我是间接的通过子类去获取纯虚父类的vftable，等等，是不是有思路了。

4. 方案四：在纯虚父类中写一个普通的函数，在构造函数->调用普通的函数->调用纯虚函数

在上面的代码将宏放开#define test_call_abstract_virtual_fun 1，编译通过ok，接下来可以愉快的玩耍了。
代码整理好，反汇编走起来。我把重要的调用过程画图表示出来，便于理解。

从纯虚函数的调用过程来看，调用纯虚函数->__purecall->call 0FE51470(19h) ->抛出异常

现在我们大概的猜一猜上面提出的疑问了：

1.纯虚函数的确是没有实现的，而虚表的内容时编译器塞进去的。

2.纯虚函数本来就是不能让我们调用的，我们现在通过某种手段绕过编译器了。如果我们直接调用纯虚函数，编译器能够检查出来，会报错error LNK2019: 无法解析的外部符号。而如果我们间接的调用了纯虚函数，编译器也无能为力，但是编译器还是道高一尺，它知道自己可能在编译期间解析不出来，所以编译器就在虚表中插入__purecall函数，你有几个虚函数我就插入几个__purecall函数，当你在运行时调用，我就让你调用__purecall抛出异常。让你不能调用你就是不能调用，强行调用我就给你shutdown。现在能够解释为什么虚表的内容是一样的。

7.虚函数的缺点

天使与魔鬼是并存的，虚函数在带来超强的多态特性，但是不可避免的带来了其他缺点。

1.间接寻址造成的效率慢，在怎么实现多态特性上汇编角度可以看出来，引入时间复杂度。

2.继承关系带来的强耦合关系，父类动子类可能地动山摇，对象关系复杂度上升。

3.体积的增加，尤其是多继承时体现的更明显，引入额外的空间复杂。

但是在软件开发的角度看大大降低软件的开发周期和维护成本，总的来说瑕不掩瑜。与带来的多态特性相比，我觉得还是值得。

8.虚函数的外延探索

1. 在多态中，我们通过对象->虚表指针->虚表->虚函数，最终找到我们想要的函数。简化的看对象->（中间操作）->虚函数，对象经过中间的一系列操作得到虚函数。这种思路称为间接思维，当我们想要某种东西的时候，可能没法直接获取或者是直接获取的成本太高，但是通过间接轻松的获取。这种思路随处可见，比如：我要吃饭要通过钱去等价交换，我去公司上班通过地铁过去，计算机中的缓存作用。

2. 关于实现多态的特性，网上还有利用模板的编译期多态的特性，有兴趣同学可以搜一下。

3. 设计模式的里面的套路，就是基于的虚函数多态的特性。

9.扩展资料

《C++深入理解对象模型》
《C++反汇编与逆向分析》

10.总结