基于模板元编程实现O(1)调用任意参数数量的函数

我有一批返回值为double、参数为任意数量double类型的函数，示例如下：

double sum1(double a, double b, double c) {
    return a + b + c;
}
double sum2(double a, double b, double c, double d) {
    return a + b + c + d;
}
double sum3(double a, double b) {
    return a + b;
}

同时用如下结构体存储这些函数的指针及参数数目元数据：

struct Function {
    void* fnptr;
    size_t numargs;
};
Function fntable[] = {{(void*)&sum1, 3}, {(void*)&sum2, 4}, {(void*)&sum3, 2}};

我希望仅通过函数索引和double*数组调用对应函数，让程序自动完成参数的正确传递（比如将double放入合适的调用寄存器）。

现有经典方案是使用switch语句，针对不同参数数目显式编写调用逻辑，最多支持固定数量的参数（示例中为4个），可借助宏减少代码量，示例代码如下：

#include <vector>
#include <limits>

template <size_t N, typename... Args>
struct FnType {
    using Call = typename FnType<N - 1, double, Args...>::Call;
};

template <typename... Args>
struct FnType<0, Args...> {
    typedef double (*Call)(Args...);
};

double callfn(void* fn, const std::vector<double>& args) {
    switch ( args.size() ) {
        case 0: { return FnType<0>::Call(fn)(); }; break;
        case 1: { return FnType<1>::Call(fn)(args[0]); }; break;
        case 2: { return FnType<2>::Call(fn)(args[0],args[1]); }; break;
        case 3: { return FnType<3>::Call(fn)(args[0],args[1],args[2]); }; break;
        case 4: { return FnType<4>::Call(fn)(args[0],args[1],args[2],args[3]); }; break;
    };
    return std::numeric_limits<double>::quiet_NaN();
}

但该方案需要修改代码才能调整支持的最大参数数目，我的需求是无需修改代码，即可在编译时任意设置最大参数数目，且调用逻辑的时间复杂度为O(1)。请问模板元编程能否提供解决方案？

可以通过模板元编程实现编译期生成调用逻辑，无需手动修改switch分支，同时保证O(1)的调用效率，核心思路如下：

1. 编译期生成参数数目对应的调用器 #

利用std::index_sequence和可变参数模板，为每个参数数目N生成对应的调用逻辑：将double*数组的前N个元素作为参数，传递给类型转换后的函数指针。兼容C++17的实现示例：

#include <array>
#include <limits>
#include <utility>

// 辅助函数：展开参数索引序列，完成函数调用
template <size_t N, size_t... Is>
double call_with_n_args_impl(void* fn, const double* args, std::index_sequence<Is...>) {
    return reinterpret_cast<double(*)(double...)>(fn)(args[Is]...);
}

// 对外暴露的N参数调用器
template <size_t N>
double call_with_n_args(void* fn, const double* args) {
    return call_with_n_args_impl<N>(fn, args, std::make_index_sequence<N>{});
}

2. 编译期生成调度表（Dispatch Table） #

通过模板递归生成一个包含0到MaxArgs的调用器数组，每个索引对应一个参数数目的调用函数。调用时直接通过numargs索引到对应的调用器，实现O(1)的调用：

// 生成调度表的辅助模板
template <size_t MaxArgs, size_t... Is>
constexpr auto make_dispatch_table(std::index_sequence<Is...>) {
    return std::array<double(*)(void*, const double*), MaxArgs + 1>{
        &call_with_n_args<Is>...
    };
}

// 编译期生成的全局调度表，模板参数指定最大支持参数数
template <size_t MaxArgs>
constexpr auto dispatch_table = make_dispatch_table<MaxArgs>(std::make_index_sequence<MaxArgs + 1>{});

3. 统一调用入口 #

提供一个模板函数，通过模板参数指定最大支持的参数数目，内部直接通过调度表完成调用：

template <size_t MaxArgs>
double call_function(const Function& func, const double* args) {
    if (func.numargs > MaxArgs) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    return dispatch_table<MaxArgs>[func.numargs](func.fnptr, args);
}

优势说明 #

• 编译期配置：只需在调用时指定模板参数MaxArgs即可调整支持的最大参数数目，无需修改核心逻辑代码。
• O(1)效率：调用时直接通过数组索引访问对应的调用器，避免了switch语句的分支判断（编译器也会将其优化为直接跳转）。
• 类型安全：模板元编程在编译期完成函数指针的类型转换和参数展开，避免运行时类型错误。

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