如何利用C++模板消除类A高频调用run函数的分支以优化性能？

你的场景中，run函数因高频调用导致分支成为性能瓶颈，核心目标是将运行时分支转移到对象构造阶段，让run调用时无分支开销。以下两种方案均符合C++14标准，可在GCC7.3.1中编译运行。

方案一：函数指针预绑定（最小改动） #

直接在类构造时根据m_case值绑定对应的runImpl函数指针，后续run调用直接执行该指针，彻底消除分支。

修改后的代码：

#include <iostream>
#include <cstdlib>
#include <cassert>
using namespace std;

class A {
public:
    A(uint32_t* arr, size_t len) : m_case(0) {
        for (size_t i = 0; i < len; ++i) {
            m_case += arr[i];
        }
        // 构造阶段一次性绑定函数指针
        switch (m_case) {
            case 1:
                m_run_func = &runImpl<1>;
                break;
            case 2:
                m_run_func = &runImpl<2>;
                break;
            default:
                m_run_func = &runImpl<0>;
                break;
        }
    }

    template <size_t> void runImpl() { assert(0); };
    void run() {
        m_run_func(); // 无分支，直接调用预绑定的函数
    }

private:
    size_t m_case;
    void (*m_run_func)(); // 存储对应的runImpl函数指针
};

template <>
inline void A::runImpl<0>() {
    cout << "Default execution path." << endl;
}

template <>
inline void A::runImpl<1>() {
    cout << "Optimized execution path 1." << endl;
}

template <>
inline void A::runImpl<2>() {
    cout << "Optimized execution path 2." << endl;
}

int main() {
    uint32_t arr[] = {1, 1};
    A a(arr, 2);
    a.run();
    return 0;
}

优点：对原代码改动极小，仅需添加函数指针成员和构造时的绑定逻辑；run函数无分支，仅一次间接函数调用，性能接近直接调用。
缺点：存在微小的函数指针间接调用开销，但远低于switch分支的条件判断开销。

方案二：模板类+多态（零间接调用开销） #

将m_case转为编译期常量，通过模板类实例化不同分支的对象，利用多态统一外部接口，run函数直接调用对应特化的runImpl，完全消除分支和间接调用开销。

修改后的代码：

#include <iostream>
#include <cstdlib>
#include <cassert>
#include <memory>
using namespace std;

// 基类定义统一接口
class BaseA {
public:
    virtual ~BaseA() = default;
    virtual void run() = 0;
};

// 模板类，Case为编译期常量
template <size_t Case>
class A : public BaseA {
public:
    A(uint32_t* arr, size_t len) {
        // 验证运行时计算的case与模板参数一致（可选，用于调试）
        size_t computed_case = 0;
        for (size_t i = 0; i < len; ++i) {
            computed_case += arr[i];
        }
        assert(computed_case == Case);
    }

    void run() override {
        runImpl(); // 直接调用编译期确定的runImpl，无分支无间接调用
    }

private:
    void runImpl() { assert(0); };
};

// 特化各case的runImpl
template <>
void A<0>::runImpl() {
    cout << "Default execution path." << endl;
}

template <>
void A<1>::runImpl() {
    cout << "Optimized execution path 1." << endl;
}

template <>
void A<2>::runImpl() {
    cout << "Optimized execution path 2." << endl;
}

// 工厂函数：运行时计算case并创建对应模板类实例
unique_ptr<BaseA> createA(uint32_t* arr, size_t len) {
    size_t case_val = 0;
    for (size_t i = 0; i < len; ++i) {
        case_val += arr[i];
    }
    switch (case_val) {
        case 1:
            return make_unique<A<1>>(arr, len);
        case 2:
            return make_unique<A<2>>(arr, len);
        default:
            return make_unique<A<0>>(arr, len);
    }
}

int main() {
    uint32_t arr[] = {1, 1};
    auto a = createA(arr, 2);
    a->run();
    return 0;
}

优点：run函数直接调用编译期确定的runImpl，无分支也无间接调用开销，性能最优。
缺点：需要引入基类和工厂函数，代码结构改动较大；对象创建时需通过工厂函数，无法直接实例化模板类（除非提前知道case值）。

方案选择建议 #

• 若希望最小化代码改动，优先选择方案一，性能提升已足够显著；
• 若追求极致性能，且能接受代码结构调整，选择方案二。

内容的提问来源于stack exchange，提问作者Hovin