如何对带int参数的模板函数执行区间迭代？

针对你遇到的编译期模板迭代问题，我们可以从几个方向优化，让代码更通用灵活，避免和特定的task模板强耦合：

1. 用模板模板参数实现通用循环 #

其实C++支持模板模板参数，刚好能解决你想传递模板作为参数的需求。我们可以定义一个完全通用的ForLoop，让它接受任意符合要求的类模板（比如你的task）：

#include <iostream>

// 通用编译期循环：支持传入任意单个int非类型参数的类模板
template<int Start, int End, template<int> class Callable>
struct ForLoop {
    ForLoop() {
        Callable<Start>(); // 执行当前迭代的任务
        ForLoop<Start + 1, End, Callable>(); // 递归进入下一次迭代
    }
};

// 终止条件特化：当起始值等于结束值时停止递归
template<int N, template<int> class Callable>
struct ForLoop<N, N, Callable> {
    ForLoop() {}
};

// 你的task模板示例
template<int i>
struct task {
    task() {
        std::cout << "Running task<" << i << ">" << std::endl;
    }
};

// 使用方式：直接传入task模板即可
int main() {
    ForLoop<0, 5, task>(); // 依次执行task<0>到task<4>
    return 0;
}

这个方案把循环逻辑和具体任务解耦了，以后换其他类似的模板（比如another_task<int>），直接替换第三个模板参数就能复用ForLoop，不用重新写循环模板。

2. C++11+：用变参模板展开实现更简洁的写法 #

如果你的项目支持C++11或更高版本，可以利用参数包展开结合整数序列来实现，代码会更简洁，不需要递归的类模板：

#include <iostream>
#include <utility> // 用于std::integer_sequence（C++14引入）

// 辅助函数：展开整数序列，依次执行每个task
template<int... Is>
void execute_tasks(std::integer_sequence<int, Is...>) {
    // 用数组初始化的方式展开参数包，确保每个task都被构造
    int dummy[] = { (task<Is>(), 0)... };
    (void)dummy; // 避免未使用变量的编译警告
}

// 对外接口：指定起始和结束值
template<int Start, int End>
void run_tasks() {
    // 生成从0到(End-Start-1)的序列，再映射到[Start, End-1]
    execute_tasks(std::make_integer_sequence<int, End - Start>{});
}

// 你的task模板不变
template<int i>
struct task {
    task() {
        std::cout << "Running task<" << i << ">" << std::endl;
    }
};

// 使用方式
int main() {
    run_tasks<0, 5>(); // 执行task<0>到task<4>
    return 0;
}

如果是C++11（没有std::integer_sequence），可以自己手写一个简易版本代替：

// C++11兼容的integer_sequence实现
template<int... Is>
struct integer_sequence {};

template<int N, int... Is>
struct make_integer_sequence : make_integer_sequence<N-1, N-1, Is...> {};

template<int... Is>
struct make_integer_sequence<0, Is...> : integer_sequence<Is...> {};

替换掉代码里的std::版本即可正常使用。

3. C++20+：用constexpr for实现最接近普通循环的写法 #

如果你的编译器支持C++20，那可以用constexpr for，写法和普通运行期for循环几乎一样，非常直观：

#include <iostream>

template<int i>
struct task {
    task() {
        std::cout << "Running task<" << i << ">" << std::endl;
    }
};

template<int Start, int End>
constexpr void run_tasks() {
    // 编译期循环，i是编译期常量
    for (int i = Start; i < End; ++i) {
        task<i>();
    }
}

// 使用方式
int main() {
    run_tasks<0, 5>(); // 执行task<0>到task<4>
    return 0;
}

这种写法完全贴合你想要的“类似普通for循环”的体验，不需要递归或参数包展开，编译器会在编译期把循环展开成一个个task<i>的调用。

对比你原来的方案 #

你之前写的ForLoop把task硬编码在了结构体里，导致这个循环模板只能用于task，复用性很差。上面的几个方案都解决了通用性问题，让循环工具可以适配任意符合要求的模板任务。

内容的提问来源于stack exchange，提问作者Yu-Hsuan Huang