能否利用元编程为所有参数值组合生成对应专用函数？

需求说明 #

现有寄存器结构体与通用加法函数：

struct S {
    std::array<int,5> reg;
};

void add(S& s, int a, int b){
    s.reg[b] += s.reg[a];
}

需要自动生成所有a、b（取值0-4）对应的专用函数，例如add_0_0(S& s)、add_0_1(S& s)直至add_4_4(S& s)，替代脚本或宏的实现方式。

C++17简洁实现 #

利用std::integer_sequence和折叠表达式，可在编译期高效生成所有组合：

#include <array>
#include <utility>

struct S {
    std::array<int,5> reg;
};

// 辅助模板：为单个A生成所有B对应的加法函数
template<int A>
struct GenerateAddForA {
    template<int... Bs>
    static void generate(std::integer_sequence<int, Bs...>) {
        // 折叠表达式展开所有B，生成对应的add_A_B函数
        (void([] (S& s) { s.reg[Bs] += s.reg[A]; }), ...);
    }
};

// 顶层模板：遍历所有A的取值
template<int... As>
void generate_all_add_functions(std::integer_sequence<int, As...>) {
    (GenerateAddForA<As>::generate(std::make_integer_sequence<int,5>{}), ...);
}

// 触发代码生成：全局作用域调用，生成全部25个函数
auto generate_all = generate_all_add_functions(std::make_integer_sequence<int,5>{});

实现细节 #

• std::make_integer_sequence<int,5>生成0到4的编译期整数序列，用于遍历寄存器索引。
• 外层遍历所有A值，内层遍历所有B值，通过折叠表达式一次性展开所有组合。
• 每个组合对应的函数通过lambda表达式实现，编译期会将其实例化为独立的全局函数。

C++14兼容实现 #

若需兼容C++14，可通过递归模板展开序列：

#include <array>
#include <utility>

struct S {
    std::array<int,5> reg;
};

// 递归终止条件：B序列为空时停止
template<int A, int... Bs>
typename std::enable_if<sizeof...(Bs) == 0>::type
generate_add_for_a() {}

// 递归展开B序列，生成单个add_A_B函数
template<int A, int FirstB, int... RestBs>
void generate_add_for_a() {
    // 拼接函数名并定义专用加法函数
    #define CONCAT(a, b) add_##a##_##b
    void CONCAT(A, FirstB)(S& s) {
        s.reg[FirstB] += s.reg[A];
    }
    #undef CONCAT

    // 递归处理剩余B值
    generate_add_for_a<A, RestBs...>();
}

// 递归终止条件：A序列为空时停止
template<int... As>
typename std::enable_if<sizeof...(As) == 0>::type
generate_all_add_functions() {}

// 递归展开A序列，为每个A生成所有B的函数
template<int FirstA, int... RestAs>
void generate_all_add_functions() {
    generate_add_for_a<FirstA, 0,1,2,3,4>();
    generate_all_add_functions<RestAs...>();
}

// 触发代码生成
auto generate_all = generate_all_add_functions<0,1,2,3,4>();

实现细节 #

• 通过递归模板逐个处理A和B的组合，每次递归生成一个专用函数。
• 使用宏CONCAT拼接函数名，确保预处理器正确生成add_A_B格式的函数名。

优势对比 #

相较于脚本/宏实现，元编程方案的优势：

• 编译期生成代码，无需额外构建工具，代码维护更集中。
• 索引为编译期常量，避免运行时越界风险，类型安全性更高。
• 可直接集成在C++代码中，无需外部脚本依赖。

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