如何将有限值非constexpr函数参数映射为静态模板参数并简化代码？

你要解决的是将有限取值的非constexpr运行时参数，映射到模板的静态参数以利用constexpr优化，同时消除手动编写大量重复分支的问题。以下几种现代C++的实现方式可以更优雅地完成这个需求：

1. 编译期跳转表（C++11及以上） #

利用constexpr数组存储模板函数实例的指针，通过运行时参数直接索引调用，彻底消除if-else分支：

#include <array>

template <int A, int B>
void Func() {
    // 具体实现
}

// 定义合法参数集合
constexpr int ValA[] = {1, 4};
constexpr int ValB[] = {2, 3};
constexpr size_t CountA = sizeof(ValA)/sizeof(ValA[0]);
constexpr size_t CountB = sizeof(ValB)/sizeof(ValB[0]);

// 生成所有模板实例的函数指针表
constexpr auto funcTable = []{
    std::array<void(*)(), CountA*CountB> table{};
    size_t idx = 0;
    for(size_t i=0; i<CountA; ++i) {
        for(size_t j=0; j<CountB; ++j) {
            table[idx++] = &Func<ValA[i], ValB[j]>;
        }
    }
    return table;
}();

// 查找参数对应的索引
constexpr size_t getIndex(int a, int b) {
    for(size_t i=0; i<CountA; ++i) {
        if(ValA[i] == a) {
            for(size_t j=0; j<CountB; ++j) {
                if(ValB[j] == b) {
                    return i*CountB + j;
                }
            }
        }
    }
    // 参数非法时的处理，比如抛出异常
    throw "Invalid parameter";
}

void WrapperFunc(int A, int B) {
    funcTable[getIndex(A, B)]();
}

这种方式的优势是编译期生成跳转表，运行时直接索引调用，效率极高，且新增参数时只需修改ValA、ValB数组，无需手动修改分支逻辑。

2. 模板元编程自动生成分支（C++17及以上） #

通过递归模板展开所有参数组合，让编译器自动生成分支代码，避免手动编写重复的if-else：

#include <utility>

template <int A, int... Bs>
void dispatchB(int B) {
    ((B == Bs ? (Func<A, Bs>(), true) : false) || ...);
    // 参数非法时的处理
}

template <int... As, int... Bs>
void dispatchAB(int A, int B, std::integer_sequence<int, As...>, std::integer_sequence<int, Bs...>) {
    ((A == As ? (dispatchB<As, Bs...>(B), true) : false) || ...);
    // 参数非法时的处理
}

void WrapperFunc(int A, int B) {
    using SeqA = std::integer_sequence<int, 1, 4>; // ValA1, ValA2
    using SeqB = std::integer_sequence<int, 2, 3>; // ValB1, ValB2
    dispatchAB(A, B, SeqA{}, SeqB{});
}

这里利用折叠表达式（C++17特性）展开所有参数组合的判断逻辑，代码简洁易维护，新增参数只需修改integer_sequence的模板参数即可。

3. 模板别名的辅助作用 #

模板别名本身无法直接完成运行时到编译期的映射，但可以配合上述方法简化代码。比如给特定参数组合的模板函数起别名：

template <int A>
using FuncForA = template<int B> void Func<A, B>;

不过这种别名更多是语法糖，核心还是依靠编译期生成的跳转表或模板展开来消除重复分支。

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