如何将循环生成的索引作为C++模板参数传递？

原代码的核心问题是运行期循环变量i/j无法直接作为模板参数——模板参数要求是编译期常量。递归模板特化确实繁琐，C++14及以后有更简洁的实现方式，按版本分述如下：

C++17：编译期序列 + 折叠表达式 #

利用std::integer_sequence生成编译期索引序列，配合折叠表达式展开循环逻辑，完全替代递归模板：

#include <utility> // 用于std::integer_sequence、std::make_integer_sequence

template <typename T, int i, int j, int k>
void apply_method(T& x) {
    constexpr bool method_one_ok = function_of(i, j);
    if constexpr (method_one_ok) { // C++17 constexpr if，避免冗余分支编译
        x = method_one<T, i, j, k>(x);
    } else {
        x = method_two<T, i, j, k>(x);
    }
}

// 处理内层j循环：j从0到i-1
template <typename T, int i, int k, int... js>
void process_inner(T& x, std::integer_sequence<int, js...>) {
    (apply_method<T, i, js, k>(x), ...); // 折叠表达式展开所有j的处理逻辑
}

// 处理外层i循环：i从1到k
template <typename T, int k, int... is>
void process_outer(T& x, std::integer_sequence<int, is...>) {
    (process_inner<T, is+1, k>(x, std::make_integer_sequence<int, is+1>{}), ...);
}

template <typename T, int k>
T function(T x) {
    process_outer<T, k>(x, std::make_integer_sequence<int, k>{});
    return x;
}

关键说明： #

• std::make_integer_sequence<int, k>生成0~k-1的序列，通过is+1转换为原代码需要的1~k范围；内层std::make_integer_sequence<int, is+1>生成0~is，正好对应j从0到i-1。
• 折叠表达式是C++17的特性，能简洁展开参数包，替代递归逻辑。

C++20：constexpr 循环+编译期变量 #

C++20放宽了constexpr函数的限制，允许在constexpr函数中使用普通for循环，只要循环变量能在编译期确定。此时你可以直接用接近原代码的写法实现需求：

template <typename T, int k>
constexpr T function(T x) {
    for (int i = 1; i <= k; ++i) {
        for (int j = i - 1; j >= 0; --j) {
            constexpr bool method_one_ok = function_of(i, j);
            if constexpr (method_one_ok) {
                x = method_one<T, i, j, k>(x);
            } else {
                x = method_two<T, i, j, k>(x);
            }
        }
    }
    return x;
}

关键说明： #

• 必须将function声明为constexpr，确保编译器在编译期处理循环（当输入x为编译期常量时，整个函数会在编译期完成计算）。
• function_of必须是constexpr函数，保证method_one_ok是编译期常量。
• 此处循环变量i/j在constexpr上下文中会被编译器视为编译期常量，因此可以直接作为模板参数传入，完美匹配你最初的写法。

C++14：简化递归模板 #

如果只能用C++14，虽然仍依赖模板递归，但可以用参数包+数组初始化模拟折叠表达式，避免复杂的模板特化：

#include <utility>

template <typename T, int i, int j, int k>
void apply_method(T& x) {
    constexpr bool method_one_ok = function_of(i, j);
    if (method_one_ok) { // C++14无constexpr if，会编译两个分支但运行期仅走对应分支
        x = method_one<T, i, j, k>(x);
    } else {
        x = method_two<T, i, j, k>(x);
    }
}

template <typename T, int i, int k, int... js>
void process_inner(T& x, std::integer_sequence<int, js...>) {
    using expander = int[];
    (void)expander{0, (apply_method<T, i, js, k>(x), 0)...}; // 模拟折叠表达式展开逻辑
}

template <typename T, int k, int... is>
void process_outer(T& x, std::integer_sequence<int, is...>) {
    using expander = int[];
    (void)expander{0, (process_inner<T, is+1, k>(x, std::make_integer_sequence<int, is+1>{}), 0)...};
}

template <typename T, int k>
T function(T x) {
    process_outer<T, k>(x, std::make_integer_sequence<int, k>{});
    return x;
}

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