if constexpr 与模板元编程 ​

面试考点 ​

if constexpr 是 C++17 引入的编译期分支语句。面试官通过这道题考察你是否理解它和普通 if 的本质区别:被丢弃的分支不会被实例化,因此可以包含对当前类型不合法的代码。这让模板元编程变得简单很多,替代了大量 SFINAE 和标签分发的复杂写法。

核心概念 ​

if constexpr 的条件必须是编译期常量表达式。条件为 false 的分支被称为"丢弃语句"(discarded statement),在模板实例化时不会被编译。这意味着你可以在一个函数模板里处理多种类型,不满足条件的分支中的代码即使对当前类型不合法也不会报错。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <type_traits>
#include <vector>
#include <memory>

// ============================
// 示例1:if constexpr vs 普通 if
// ============================

// 普通 if:两个分支都必须对所有类型合法
// 下面这个用普通 if 会编译失败
/*
template<typename T>
std::string to_string_bad(T value) {
    if (std::is_arithmetic_v<T>) {
        return std::to_string(value);  // string 没有 to_string
    } else {
        return value;  // int 不能直接 return 为 string
    }
}
*/

// if constexpr:丢弃分支不实例化,可以包含对当前类型不合法的代码
template<typename T>
std::string to_string_good(T value) {
    if constexpr (std::is_arithmetic_v<T>) {
        // 只有 T 是算术类型时才编译这个分支
        return std::to_string(value);
    } else if constexpr (std::is_same_v<T, std::string>) {
        // 只有 T 是 string 时才编译这个分支
        return value;
    } else if constexpr (std::is_same_v<T, const char*>) {
        return std::string(value);
    } else {
        // 编译期断言:不支持的类型
        static_assert(!sizeof(T*), "不支持的类型");
    }
}

void basic_demo() {
    std::cout << to_string_good(42) << std::endl;
    std::cout << to_string_good(3.14) << std::endl;
    std::cout << to_string_good(std::string("hello")) << std::endl;
    std::cout << to_string_good("world") << std::endl;
}

// ============================
// 示例2:替代 SFINAE
// ============================

// C++11/14 的 SFINAE 写法(晦涩)
template<typename T>
std::enable_if_t<std::is_integral_v<T>, void>
process_sfinae(T value) {
    std::cout << "整数: " << value * 2 << std::endl;
}

template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, void>
process_sfinae(T value) {
    std::cout << "浮点: " << value / 2.0 << std::endl;
}

template<typename T>
std::enable_if_t<!std::is_arithmetic_v<T>, void>
process_sfinae(T value) {
    std::cout << "其他: " << value << std::endl;
}

// C++17 的 if constexpr 写法(清晰)
template<typename T>
void process_constexpr(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << value * 2 << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点: " << value / 2.0 << std::endl;
    } else {
        std::cout << "其他: " << value << std::endl;
    }
}

// ============================
// 示例3:替代标签分发
// ============================

// C++11 标签分发
namespace old_style {
    template<typename Iter>
    void advance_impl(Iter& it, int n, std::random_access_iterator_tag) {
        it += n;  // 随机访问迭代器:直接跳
    }

    template<typename Iter>
    void advance_impl(Iter& it, int n, std::input_iterator_tag) {
        for (int i = 0; i < n; ++i) ++it;  // 输入迭代器:逐步走
    }

    template<typename Iter>
    void advance(Iter& it, int n) {
        advance_impl(it, n,
            typename std::iterator_traits<Iter>::iterator_category{});
    }
}

// C++17 if constexpr 替代标签分发
template<typename Iter>
void my_advance(Iter& it, int n) {
    using category = typename std::iterator_traits<Iter>::iterator_category;
    if constexpr (std::is_base_of_v<std::random_access_iterator_tag, category>) {
        it += n;  // 随机访问
    } else {
        for (int i = 0; i < n; ++i) ++it;  // 逐步走
    }
}

// ============================
// 示例4:编译期递归(变参模板)
// ============================

// SFINAE 递归终止(旧写法)
template<typename T>
void print_old(T&& x) {
    std::cout << x << std::endl;
}

template<typename T0, typename... Ts>
std::enable_if_t<(sizeof...(Ts) > 0)>
print_old(T0&& x, Ts&&... rest) {
    std::cout << x << ", ";
    print_old(std::forward<Ts>(rest)...);
}

// if constexpr 递归终止(新写法)
template<typename T0, typename... Ts>
void print_new(T0&& x, Ts&&... rest) {
    std::cout << x;
    if constexpr (sizeof...(Ts) > 0) {
        std::cout << ", ";
        print_new(std::forward<Ts>(rest)...);
    } else {
        std::cout << std::endl;
    }
}

// ============================
// 示例5:编译期工厂
// ============================

struct Widget {
    Widget() { std::cout << "Widget()" << std::endl; }
    Widget(int x) { std::cout << "Widget(" << x << ")" << std::endl; }
    Widget(int x, double y) {
        std::cout << "Widget(" << x << ", " << y << ")" << std::endl;
    }
};

template<typename T, typename... Args>
std::unique_ptr<T> create(Args&&... args) {
    if constexpr (std::is_constructible_v<T, Args...>) {
        return std::make_unique<T>(std::forward<Args>(args)...);
    } else {
        // 参数不匹配时返回 nullptr 而不是编译错误
        std::cout << "无法用这些参数构造" << std::endl;
        return nullptr;
    }
}

void factory_demo() {
    auto w1 = create<Widget>();         // Widget()
    auto w2 = create<Widget>(42);       // Widget(42)
    auto w3 = create<Widget>(1, 2.0);   // Widget(1, 2.0)
    auto w4 = create<Widget>("bad");    // 无法用这些参数构造
}

// ============================
// 示例6:编译期类型转换
// ============================

template<typename To, typename From>
To safe_cast(From value) {
    if constexpr (std::is_same_v<To, From>) {
        // 类型相同,直接返回
        return value;
    } else if constexpr (std::is_convertible_v<From, To>) {
        // 可以隐式转换
        return static_cast<To>(value);
    } else {
        static_assert(!sizeof(From*), "不支持的类型转换");
    }
}

int main() {
    std::cout << "=== 基本用法 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 替代 SFINAE ===" << std::endl;
    process_constexpr(42);
    process_constexpr(3.14);
    process_constexpr(std::string("hi"));

    std::cout << "\n=== 变参打印 ===" << std::endl;
    print_new(1, "hello", 3.14, 'A');

    std::cout << "\n=== 编译期工厂 ===" << std::endl;
    factory_demo();

    return 0;
}

if constexpr vs 普通 if vs SFINAE ​

特性普通 ifif constexprSFINAE
求值时机运行时编译时编译时
丢弃分支不丢弃,两个分支都编译丢弃,不实例化通过替换失败移除
可读性好好差
错误信息运行时错误static_assert模板错误堆栈
适用场景运行时条件编译期类型分发C++11/14 类型分发

常见问题 ​

if constexpr 的条件必须是什么?

必须是能在编译期确定的常量表达式(constexpr)。不能用运行时变量。常见的条件包括 type_traits(如 is_integral_v)、sizeof...(参数包大小)、constexpr 函数的返回值等。

丢弃分支真的完全不编译吗?

不是完全不编译。丢弃分支仍然要经过第一阶段的语法检查(名字查找),只是不进行第二阶段的模板实例化。这意味着丢弃分支中的代码语法必须正确,但可以包含对当前类型不合法的操作。

什么时候仍然需要 SFINAE?

if constexpr 只能在函数体内使用,不能用于重载决议。如果你需要根据类型选择不同的函数重载(而不是在同一个函数内分支),仍然需要 SFINAE 或 C++20 Concepts。

适用场景 ​

  • 模板函数中根据类型执行不同逻辑
  • 变参模板的递归终止
  • 编译期工厂(根据参数可构造性选择策略)
  • 替代标签分发和 SFINAE

注意事项 ​

  • 条件必须是编译期常量,不能用运行时变量
  • 丢弃分支仍需语法正确(第一阶段检查)
  • 不能用在非模板函数中期望跳过不合法代码
  • static_assert 在丢弃分支中需要依赖模板参数才能延迟检查
  • if constexpr 不参与重载决议

总结 ​

if constexpr 是 C++17 中大幅简化模板元编程的利器。它在编译期求值条件,丢弃不满足条件的分支(不实例化),使得一个函数模板可以处理多种类型而不需要 SFINAE 或标签分发。面试中要能对比 if constexpr 和普通 if 的区别(丢弃 vs 不丢弃)、解释"丢弃分支不实例化"的含义、以及知道它不能替代 SFINAE 用于重载决议。