如何阻止Clang通过模板过度展开嵌套循环？

问题原因 #

你的代码通过模板参数控制递归深度，每个foo<i>会生成调用foo<i+1>的代码。在-O2优化下，Clang会尝试完全展开所有编译期可确定的递归调用。当N=8时，这意味着要处理10^8级别的调用展开，直接导致编译时间和内存占用急剧飙升。

可行解决方案 #

方案1：改用运行时递归（推荐）

将编译期模板参数控制的递归改为运行时参数控制，这样编译器只会生成一份通用的递归函数，不会在编译时展开所有层级，同时-O2仍能对运行时递归做优化，保持运行效率。

#include <iostream>
typedef long xint;

void foo(int current_depth, xint t, int max_depth) {
    if (current_depth == max_depth) {
        std::cout << t;
        return;
    }
    for (int j = 0; j < 10; ++j) {
        foo(current_depth + 1, t + j, max_depth);
    }
}

int main() {
    foo(0, 0, 8);
}

方案2：迭代式模拟嵌套循环

完全摒弃递归，用迭代方式手动模拟多层嵌套循环的逻辑，编译速度极快，运行时逻辑清晰，优化后的性能也能满足需求。

#include <iostream>
#include <vector>
typedef long xint;

int main() {
    const int N = 8;
    std::vector<int> levels(N, 0);
    xint t = 0;

    while (true) {
        std::cout << t;

        // 回溯找可递增的层级
        int i = N - 1;
        while (i >= 0 && levels[i] == 9) {
            t -= levels[i];
            levels[i] = 0;
            i--;
        }
        if (i < 0) break;

        // 递增当前层级的循环变量
        t -= levels[i];
        levels[i]++;
        t += levels[i];
    }
}

方案3：保留模板结构但阻止编译期展开

如果必须保留原模板结构，可以通过添加无意义的运行时判断，让编译器认为递归无法完全在编译期展开，不过这种方法依赖编译器优化策略，稳定性不如前两种。

#include <iostream>
typedef long xint;

template<int N>
struct foz {
    template<int i=0>
    static void foo(xint t) {
        for (int j=0; j<10; ++j) {
            // 加入运行时判断，阻止编译期完全展开
            if (true) {
                foo<i+1>(t + j);
            }
        }
    }
    template<>
    static void foo<N>(xint t) {
        std::cout << t;
    }
};

int main() {
    foz<8>::foo<0>(0);
}

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