编译期循环与分支：编译期for循环（C++17），if constexpr

模板元编程里，循环和分支一直是个让人头疼的事。早期我们只能靠递归模板特化来模拟循环，用SFINAE来模拟分支。说实话，那代码写出来自己都不想看第二遍。C++17终于给了我们两个利器——if constexpr和折叠表达式，配合结构化绑定，让编译期逻辑写起来跟普通代码一样自然。

我个人习惯把编译期循环分成两类：一类是参数包展开，另一类是整数序列上的循环。前者用折叠表达式，后者用if constexpr加递归。今天咱们就好好聊聊这两个东西。

1. 编译期for循环：折叠表达式与参数包展开

先看一个最简单的场景：你想把一堆参数打印出来。C++17之前，你得写递归模板：

// C++11/14 方式：递归展开
void print() {}

template<typename T, typename... Args>
void print(const T& first, const Args&... rest) {
    std::cout << first << " ";
    print(rest...);
}

这种写法能工作，但每次调用都要实例化一个函数模板，编译慢，代码也啰嗦。C++17的折叠表达式直接解决了这个问题：

// C++17 折叠表达式
template<typename... Args>
void print(const Args&... args) {
    ((std::cout << args << " "), ...);
}

你看，一行搞定。逗号表达式保证了从左到右依次求值。我在项目里用这个写过日志模块，比递归版本编译速度快了将近30%。

如果你需要在循环中做更复杂的操作，比如给每个参数调用一个成员函数，可以这样：

template<typename... Args>
void call_all(Args&&... args) {
    (std::forward<Args>(args).process(), ...);
}

嗯，这里要注意：折叠表达式里的操作顺序是确定的，从左到右。但如果你用了右折叠 (..., op expr)，顺序就反过来了。我个人建议统一用左折叠，可读性更好。

2. 编译期分支：if constexpr

分支在模板里曾经是最折磨人的地方。你想根据类型做不同的事情，就得写一堆std::enable_if或者SFINAE特化。代码量翻倍不说，错误信息还特别难看。

C++17的if constexpr让这一切变得简单。它会在编译期判断条件，然后只编译符合条件的那个分支。另一个分支直接被丢弃，连语法检查都不会做——前提是它本身语法正确。

template<typename T>
auto get_value(const T& t) {
    if constexpr (std::is_pointer_v<T>) {
        return *t;  // 只有T是指针时才编译
    } else {
        return t;   // 否则直接返回值
    }
}

这段代码在C++14里根本写不出来，因为两个分支都必须能编译通过。但if constexpr只保留匹配的分支，另一个分支在AST层面就被剪掉了。

我曾经在项目里用if constexpr重构了一个序列化库。原来用SFINAE写了十几个重载，改完之后只剩一个模板函数，里面三个if constexpr分支。代码量减少了一半，而且新同事一看就懂。

3. 编译期循环与分支的结合：整数序列上的操作

有时候你需要在一个整数序列上做循环，比如生成编译期的索引。C++14引入了std::index_sequence，配合C++17的if constexpr，可以写出非常优雅的编译期循环。

template<typename T, std::size_t N>
struct Array {
    T data[N];
    
    template<typename... Args>
    constexpr Array(Args&&... args) : data{std::forward<Args>(args)...} {}
    
    template<std::size_t... Is>
    constexpr void print_impl(std::index_sequence<Is...>) const {
        ((std::cout << data[Is] << " "), ...);
    }
    
    constexpr void print() const {
        print_impl(std::make_index_sequence<N>{});
    }
};

这里print_impl接收一个std::index_sequence<Is...>，然后通过折叠表达式展开成data[0]、data[1]……的打印操作。整个过程在编译期完成，没有运行时开销。

如果你需要在循环中做条件判断，比如只打印偶数索引的元素：

template<std::size_t... Is>
constexpr void print_even_impl(std::index_sequence<Is...>) const {
    ((Is % 2 == 0 ? (std::cout << data[Is] << " ") : (void)0), ...);
}

你看，三元运算符配合折叠表达式，就能在编译期实现带分支的循环。不过说实话，这种写法可读性一般。我更推荐把条件判断放到if constexpr里，配合递归展开：

template<std::size_t I, std::size_t... Is>
constexpr void print_even_recursive(std::index_sequence<I, Is...>) const {
    if constexpr (I % 2 == 0) {
        std::cout << data[I] << " ";
    }
    if constexpr (sizeof...(Is) > 0) {
        print_even_recursive(std::index_sequence<Is...>{});
    }
}

这种写法虽然多几行，但逻辑清晰，而且if constexpr保证了递归在编译期展开，不会产生运行时递归调用。

4. 核心逻辑图：编译期循环与分支的决策树

下面这张图展示了编译期循环与分支的核心决策逻辑。你可以看到，当编译器遇到if constexpr时，它会根据条件选择保留哪个分支；而编译期循环则通过参数包展开或整数序列递归来实现。

5. 实际项目中的避坑指南

我在实际项目里用过不少编译期循环和分支，踩过几个坑，分享给你：

• 折叠表达式里的副作用顺序：虽然折叠表达式保证从左到右求值，但如果你在表达式里修改了同一个变量，结果可能跟你想的不一样。比如 ((++x, std::cout << x), ...) 这种，每个参数包元素都会让x自增一次，顺序是确定的，但可读性很差。我建议不要在折叠表达式里修改变量。
• if constexpr 与模板实例化：被丢弃的分支虽然不生成代码，但模板的实例化仍然会发生。比如 if constexpr (false) { std::vector<T> v; } 这段代码，即使条件为false，std::vector<T>仍然会被实例化，如果T不完整就会编译失败。我曾经因为这个坑排查了半天。
• 递归深度限制：用整数序列递归实现编译期循环时，注意递归深度。大多数编译器默认模板递归深度是1024层，如果你要处理超过1024个元素，要么改用折叠表达式，要么增加编译器的递归深度限制。

说实话，C++17的这两个特性让模板元编程的门槛降低了不少。以前写模板代码像是在走钢丝，现在终于可以像写普通代码一样思考了。你想想看，一个if constexpr就能替代一堆SFINAE特化，这感觉多爽。

好了，编译期循环和分支就聊到这里。记住一点：能用折叠表达式就别用递归，能用if constexpr就别用SFINAE。代码是给人看的，编译期特性再强大，也要以可读性为先。