当前位置： 首页 > article >正文

C++代码优化(五):虚函数的开销和优化方式

article 2024/11/20 17:16:28

目录

1.虚函数的工作原理

1.1.虚函数表（vtable）的结构和作用

1.2.虚函数调用的内部过程

2.虚函数的开销

3.如何减少虚函数调用开销

3.1.使用final和override关键字

3.2.非虚接口（NVI）模式

3.3.使用 CRTP（Curiously Recurring Template Pattern）替代虚函数

3.4.使用函数指针替代虚函数

3.5.使用内联函数

3.6.考虑使用其他设计模式

3.7.微软的下一代多态库

4.总结

1.虚函数的工作原理

        C++ 中，虚函数提供了动态多态性，让程序能够在运行时通过基类指针或引用调用派生类的重载函数。尽管虚函数在设计上灵活，但它也带来了额外的性能开销。

1.1.虚函数表（vtable）的结构和作用

        虚函数表（vtable），是C++中实现多态的关键数据结构。每个多态类都拥有一个vtable指针，通常隐藏在对象内存布局的最开始处。vtable包含了类中所有虚函数的指针，当通过基类指针或引用调用派生类中的虚函数时，程序会查看vtable来确定应调用哪个函数。

        虚函数表的结构对程序的性能有重要影响。在对象实例化时，vtable会被创建，并在运行时通过它来解析虚函数调用。这涉及额外的内存访问，可能会带来缓存不命中的问题，特别是在大规模对象系统中。然而，使用vtable的好处在于，它允许在不改变代码编译的情况下动态地改变程序的行为，这为C++的多态特性提供了基础。

        虚函数表的结构

        虚函数表是一个数组，每个元素都是一个指向虚函数的指针。以下是一个简单的虚函数表结构示例：

class Base {
public:
    virtual void func1() { /* implementation */ }
    virtual void func2() { /* implementation */ }
    virtual ~Base() { /* destructor */ }
};

class Derived : public Base {
public:
    void func1() override { /* overridden implementation */ }
    void func2() override { /* overridden implementation */ }
    void func3() { /* new function */ }
};

对于上述类结构，编译器可能生成如下的虚函数表：

  • Base类的vtable:
  • Derived类的vtable:

注意：

  1. 虚函数表中的每个条目都是指向虚函数的指针。
  2. 虚析构函数也是虚函数表中的一部分，确保在删除派生类对象时能够正确调用析构函数链。
  3. 如果一个类没有显式声明虚函数，但它从有虚函数的基类继承，它仍然会有虚函数表。

1.2.虚函数调用的内部过程

当一个虚函数被调用时，程序会执行以下步骤：

  1. 查看对象的虚函数表指针。
  2. 通过虚函数表找到要调用函数的实际地址。
  3. 跳转到该地址执行函数代码。

这个过程比普通函数调用多了一层间接性，因此会有一定的性能开销。特别是在频繁的虚函数调用场景下，这些开销可能会累积成为显著的性能瓶颈。理解这一过程可以帮助开发者在设计和实现类层次结构时，更加明智地使用多态特性，优化系统性能。

2.虚函数的开销

  1. 虚函数表 (vtable) 开销：每个包含虚函数的类通常会生成一个虚函数表，用于存储指向虚函数实现的指针。每个多态对象在内存中包含一个指向虚表的指针，这个指针称为虚表指针 (vptr)。因此，每个对象会多占用一个指针大小的内存（通常为 4 或 8 字节，具体取决于系统架构）。

  2. 间接调用开销：调用虚函数需要先访问虚表，通过虚表指针找到具体函数的地址，然后进行调用。这种间接寻址比普通函数调用更慢，尤其在频繁调用虚函数的场景中，开销会显著增加。

  3. 内存布局影响：对象内的虚表指针增加了对象大小，并且在某些情况下会导致内存布局的不连续性，增加了 CPU 缓存未命中的概率，降低缓存命中率。

  4. 编译器优化受限：编译器对虚函数的优化受限。例如，普通的非虚函数调用可以内联 (inline) 优化，但虚函数由于其动态特性无法在编译期确定实际的调用目标，因此无法轻易内联。

        为了了解虚函数调用开销的实际大小，我们可以进行一些简单的性能测试。下面是一个示例程序，用于比较直接调用函数和通过虚函数指针调用函数的性能：

class Base {
    public:
        virtual void func() {
            // 虚函数的实现
        }
};

class Derived : public Base {
    public:
       void func() override {
            // 派生类中虚函数的实现
        }
};

void directCall(Base& obj) {
    obj.func();
}

void indirectCall(Base* obj) {
    obj->func();
}

int main() {
    Base b;
    Derived d;

    clock_t start, end;
    double directTime, indirectTime;

    start = clock();
    for (int i = 0; i < 10000000; i++) {
        directCall(b);
    }
    end = clock();
    directTime = (double)(end - start) / CLOCKS_PER_SEC;

    start = clock();
    for (int i = 0; i < 10000000; i++) {
        indirectCall(&b);
    }
    end = clock();
    indirectTime = (double)(end - start) / CLOCKS_PER_SEC;

    std::cout << "直接调用函数的时间：" << directTime << " 秒" << std::endl;
    std::cout << "通过虚函数指针调用函数的时间：" << indirectTime << " 秒" << std::endl;

    return 0;
}

        在这个程序中，我们定义了一个基类 Base 和一个派生类 Derived ，它们都有一个虚函数 func 。我们还定义了两个函数 directCall 和 indirectCall ，分别用于直接调用函数和通过虚函数指针调用函数。在 main 函数中，我们分别测量了直接调用函数和通过虚函数指针调用函数的时间，并输出结果。

        通过运行这个程序，我们可以得到直接调用函数和通过虚函数指针调用函数的时间。在我的测试环境中，直接调用函数的时间大约为 0.05 秒，而通过虚函数指针调用函数的时间大约为 0.15 秒。这表明，虚函数的调用开销大约是直接调用函数的三倍。

        需要注意的是，这个测试结果只是一个示例，实际的虚函数调用开销会受到很多因素的影响，如硬件平台、编译器优化、虚函数的实现复杂度等。因此，在实际应用中，我们需要根据具体情况进行性能测试，以确定虚函数的调用开销是否可以接受。

3.如何减少虚函数调用开销

3.1.使用final和override关键字

        在C++11及以后的版本中，可以使用final关键字来防止类被继承或虚函数被重写。这有助于编译器进行更彻底的优化，因为它消除了动态绑定的需要。
        override关键字用于显式指出派生类中的函数将覆盖基类中的虚函数。这不仅提高了代码的可读性，还允许编译器在编译时进行类型检查，从而减少潜在的错误。

        示例：

class Base {
public:
    virtual void process() { /* 虚函数 */ }
};

class Derived final : public Base {
public:
    void process() final override { /* 最终实现，不允许进一步派生 */ }
};

在此例中，标记 Derived 为 final 类，编译器可以针对 process 做更多的优化，因为它明确知道没有进一步的派生类会重写 process。注意：即便使用了 final，虚表仍然存在，但编译器可以在具体类型调用时优化掉虚函数的间接调用。

3.2.非虚接口（NVI）模式

        非虚接口模式是一种设计模式，它将虚函数的使用限制在基类中，并通过非虚成员函数来调用这些虚函数。这样，派生类只需要重写基类中的少数几个虚函数，而大部分逻辑则保持在基类的非虚成员函数中。
        这种模式有助于减少虚函数的调用次数，因为大部分工作都在基类的非虚成员函数中完成，而派生类只需要提供必要的重写。

3.3.使用 CRTP（Curiously Recurring Template Pattern）替代虚函数

C++惯用法之CRTP(奇异递归模板模式)_c++ crtp-CSDN博客

对于需要静态多态的情况，CRTP 是一种可以替代虚函数的高效方法。CRTP 利用模板参数在编译时实现静态多态性，避免了运行时的虚表查找。示例如下：

template <typename Derived>
class Base {
public:
    void process() {
        static_cast<Derived*>(this)->process();
    }
};

class Derived : public Base<Derived> {
public:
    void process() { /* 具体实现 */ }
};

在此例中，Base 中的 process 是一个非虚函数，通过模板参数在编译期静态分发到 Derived::process。CRTP 适用于不需要动态多态的场景，可以有效减少虚函数带来的开销。

3.4.使用函数指针替代虚函数

        当只需动态绑定单个方法的调用时，可以考虑使用函数指针代替虚函数。这样既能提供动态多态性，又能减少虚表带来的额外内存开销。

        示例如下：

class Base {
public:
    using FuncPtr = void(*)(Base*);

    Base(FuncPtr func) : func_(func) {}
    
    void process() { func_(this); }

private:
    FuncPtr func_;
};

void processImplementation(Base* obj) {
    // 实现逻辑
}

int main() {
    Base obj(processImplementation);  // 使用函数指针调用
    obj.process();
    return 0;
}

在这种情况下，通过构造函数传入的函数指针实现了类似虚函数的效果，但不需要虚表，从而减少了内存和运行时开销。

3.5.使用内联函数

        如果虚函数的实现非常简单，可以将其声明为内联函数。内联函数可以在编译时将函数体插入到调用点，避免了函数调用的开销。但是，内联函数也有一些限制，如函数体不能太大，否则会导致代码膨胀。

3.6.考虑使用其他设计模式

        在某些情况下，可以考虑使用其他设计模式来替代虚函数的使用。例如，使用策略模式、访问者模式或状态模式等，这些模式可以在不牺牲性能的情况下实现类似的多态性。但是，这些技术也有一些复杂性，需要根据具体情况进行选择。

3.7.微软的下一代多态库

C++20到来了，更好的符合零成本抽象的多态实现方式来了——微软Proxy库。

Proxy说是一个库，其实就只是一个头文件而已。

那么基于微软的的Proxy，应该如何编写上面的多态呢？

看下面的代码，特别是开头的两个struct类。 没错，C++里面struct也是类。

#include <iostream>
#include "proxy.h"
 
// 声明一个代理类，最终会通过这个代理类去调用真正的类对象的成员函数
struct Show : pro::dispatch<void()>
{
 template <class T>
 void operator()(T& self) { self.show(); }
};
struct Model : pro::facade<Show> {};
 
class Who {
public: 
  void show() {
 std::cout << "model run!\n";
 }
};
 
class Boy {
public:
 void show() {
 std::cout << "boy run!\n";
 }
};
 
class Girl {
public:
 void show() {
 std::cout << "girl run!\n";
 }
};
 
class Man {
public:
 void show() {
 std::cout << "man run!\n";
 }
};
 
void justrun(pro::proxy<Model> m) { 
 m.invoke<Show>();
}
 
int main() {
 Who who;
 Girl girl;
 Boy boy;
 Man man;
 
 justrun(&who);
 justrun(&girl);
 justrun(&boy);
 justrun(&man);
}

        重点是开头的Show和Model两个类。 按照这样的方式，定义这样子的两个类，就描述了一个类的基本行为。

        之后你只需要用proxy调用这个行为就可以了。 用proxy就完美的用零成本抽象的方式极致的解决了C++的多态问题。

        那么，很多人会说，我哪里记得住开头两个类的定义方法啊，定义方式长得那么猥琐。

        别急，微软还贴心的用宏定义了简化定义方式：

#include<iostream>
#include "proxy.h"
 
DEFINE_MEMBER_DISPATCH(Show, show, void());
DEFINE_FACADE(Model, Show);
 
class Who {
public: 
  void show() {
 std::cout << "model run!\n";
 }
};
 
class Boy {
public:
 void show() {
 std::cout << "boy run!\n";
 }
};
 
class Girl {
public:
 void show() {
 std::cout << "girl run!\n";
 }
};
 
class Man {
public:
 void show() {
 std::cout << "man run!\n";
 }
};
 
void justrun(pro::proxy<Model> m) { 
 m.invoke<Show>();
}
 
int main() {
 Who who;
 Girl girl;
 Boy boy;
 Man man;
 
 justrun(&who);
 justrun(&girl);
 justrun(&boy);
 justrun(&man);
}

现在，整个代码就变得清爽宜人了。

可见，在C++20时代了，C++长期被人诟病的性能损失问题：虚函数实现多态，这一终极短板，也终于被克服了。

4.总结

虚函数在提供动态多态性的同时，也引入了内存和性能开销。在高性能场景中，可以通过以下优化策略有效减少虚函数的开销：

  1. 使用 final 关键字优化派生链：避免进一步派生，允许编译器内联优化。

  2. 使用 CRTP 替代虚函数：在需要静态多态的场景中，CRTP 是高效的替代方案。

  3. 使用函数指针实现动态调用：可在不引入虚表的情况下实现动态多态。

通过这些优化方法，C++ 程序可以在保持多态灵活性的同时，最大化减少虚函数带来的性能开销。你在编程中，为了极致的性能，会用哪些方式来避免避免虚函数的开销？欢迎留言讨论。


http://www.kler.cn/a/401785.html

相关文章：

  • C++语言系列-STL容器和算法
  • uni-app快速入门（十）--常用内置组件（下）
  • 如何将几个音频合成一个音频？非常简单的几种合成方法
  • Acme PHP - Let‘s Encrypt
  • 使用 OpenAI 进行数据探索性分析（EDA）
  • Springboot 整合 Java DL4J 打造金融风险评估系统
  • 初始Python篇（6）—— 字符串
  • 人工智能学习——前言
  • 2024年第十四届APMCM亚太杯数学建模A题B题C题思路+代码解析汇总
  • MATLAB用到的矩阵基础知识（矩阵的乘和矩阵的逆）
  • Axure9生成的阅览页面如何自动展开左侧页面导航？
  • CSS基础也要进行模电实验
  • JSONP处理跨域请求
  • 每日一练：【动态规划算法】斐波那契数列模型之第 N 个泰波那契数（easy）
  • 【白话机器学习系列】白话 Softmax
  • 自动驾驶系统研发系列—智能驾驶新高度：解析ESS驾驶员转向辅助系统
  • C++ STL中常见的容器
  • 面向FWA市场！移远通信高性能5G-A模组RG650V-NA通过北美两大重要运营商认证
  • CSS基础选择器与div布局
  • 社群在 2+1 链动模式 S2B2C 商城小程序社交新零售运营中的价值与应用
  • 【Go实战】：使用AES和RSA加密算法保护关键信息
  • 独立资源池：虚拟化技术如何帮助企业在经济危机中降低成本？
  • 我们来学mysql -- EXPLAIN之type(原理篇)
  • Swift 数组
  • 安装 Ubuntu 桌面系统
  • [论文阅读] 异常检测 Deep Learning for Anomaly Detection: A Review（三）总结梳理-疑点记录