漫谈 C++ 虚函数 的 实现原理

文中讲述的原理是推理和探讨 ， 和现实中的实现不必定彻底相同 。

 

C++ 的 虚函数 ， 编译器 会 生成一个 虚函数表 。 

虚函数表， 其实是 编译器 在 内存 中 划定 的 一块 区域， 用于存放 类 的 虚函数 的 override 实现 的 函数指针 。

就是说， 若是 类 对于 基类 的 虚函数 override 了， 那么 override 的 函数 的 函数指针 就会 被记录到 虚函数表 里 。

程序在运行时会 查找 虚函数表， 找到 override 的 函数， 而后 调用 override 的 函数， 这样就实现了 调用 子类 实现的函数， 实现了 “多态” 。

虚函数表 是一个 线性表， 这样能够快速的访问 。

访问线性表 的 时间复杂度 是 O(1)  。

相对于 普通的函数 调用， 虚函数 的 调用 多了一次 查找 虚函数表 的 工做， 至关于 多了 一次 寻址， 因此 效率会更低一点 。

 

C++ 编译器 会为 每一个成员（类 函数 字段） 指定一个 连续的 数字编号 做为 ID 。

用 连续的 数字编号 做为 ID 是为了能够以 线性表 的 方式 快速检索 。

 

虚函数表 由  2 个 线性表 组成 。

等， 我下面 把 线性表 称为 数组 好了 。

 

虚函数表 由 2 个 数组 组成 。

数组 1 是 类表， 保存 类 的 实现函数表 的 地址 。 实现函数 就是 override 了 虚函数 的 函数 。

数组 2 是 实现函数表， 保存 类 的 实现函数 的 函数指针 。

 

假设有 3 个类， A 、 B 、 C ， 那么 编译器 会 给 这 3 个类 分别指定 ID 为   0 、 1 、 2 。

在 数组 1 （类表） 里， 就会 3 个元素，  咱们用 伪码 来表示好了 ：

 

类表 [ 0 ] = A 类 的 实现函数表 的 地址

类表 [ 1 ] = B 类 的 实现函数表 的 地址

类表 [ 2 ] = C 类 的 实现函数表 的 地址

 

这样， 用 类 的 ID 做为 下标（index） 来 访问 类表， 就能够取得 该类 的 实现函数表 的 地址 。

 

实现函数表 咱们也能够用 伪码 来表示， 假设 A 类里有 Hello() 、 Thank() 、 Goodbye()     3 个 override 了 基类 虚函数 的 实现函数， 那么， 编译器 会给 这 3 个 实现函数 分别 指定 ID 为    0 、 1 、 2 。 这里只会给 实现函数 指定 ID ， 不会把 其它 普通函数 包括进来 。

实现函数表 会是这样 ：

 

实现函数表 [ 0 ] = Hello() 的 函数地址

实现函数表 [ 1 ] = Thank() 的 函数地址

实现函数表 [ 2 ] = Goodbye() 的 函数地址

 

这样， 用 实现函数 的 ID 做为 下标（index） 来 访问 实现函数表， 就能够取得 这个 实现函数 的 地址 。

 

编译的时候， 对于 普通函数 的调用， 会直接编译成       “函数地址 -> 调用”       这样的 目标代码， 

对于 虚函数， 则会编译成          “根据 当前对象 的 类 ID 和 函数 ID -> 查找 虚函数表 -> 找到 实现函数 地址 -> 调用”           这样的 目标代码 。

 

从上面的 原理 看到， 查找 虚函数表 自己 就须要 2 次寻址， 查找 2 个 线性表（数组） 。

同时， 也能够看到， 对于 不须要 override 的 函数， 不要 声明 为 虚函数， 由于 虚函数 会 增长 查找 虚函数表 的 时间花费， 性能 比 普通函数 调用 更低一点 。

固然， 编译器 可能会做一些 优化， 好比 对于 能在 代码中 明确判断出 对象类型 的 状况， 即便是 虚函数 调用， 也会编译成 和 普通函数 同样的 处理方式    “函数地址 -> 调用” ， 即 要调用的 函数地址 在 编译时就肯定了 。

那什么是 编译时不能肯定 对象类型 的 状况 ？   好比 工厂方法 。

 

编译时， 对于 虚函数， 编译器 会 检查 类 是否 进行了 override， 若是 override 了， 则 将 实现函数 列入 虚函数表， 若是没有 override， 就 查找 上一层 父类 是否 override 了， 若是 override 了， 则 将 实现函数 列入 虚函数表， 若是没有 override， 就 继续 查找 上一层 父类， 以此递推， 直到 声明 这个 虚函数 的 父类 。 若是在整个继承层级中都没有 override 这个 虚函数， 则 不会将这个 虚函数 列入 虚函数表， 固然 也不会给 这个 虚函数 指定 虚函数 ID 。全部 子类 对象 对 这个 虚函数 的 调用 会被编译成     “声明这个虚函数的 父类 里 这个虚函数 的 函数地址 -> 调用”     方式， 这种状况 和 普通函数 是同样的了 。

 

咱们再来谈谈 “后期绑定” 。

咱们先说说 “动态绑定” 。 在 Javascript 里， 对象 和 函数 能够 任意 的 绑定， 因此叫 “动态绑定” 。

对于 查找 虚函数表 的 作法， 是在 运行时 才决定具体要调用的 函数， 至关于 运行时 才 给 对象 绑定 函数， 因此叫 “后期绑定”   （我印象中好像是这么叫的）  。