C++

SFINAE、类型萃取与 enable_if

理解「替换失败不是错误」原则，使用类型萃取进行编译时自省，以及使用 enable_if 约束模板。

什么是 SFINAE？

SFINAE 代表 Substitution Failure Is Not An Error（替换失败不是错误）。当编译器尝试实例化模板时，它会将推导或指定的类型替换到模板中。如果这种替换在模板声明的直接上下文中产生无效的类型或表达式，编译器不会发出错误 ── 它只是将该模板从重载集中移除，然后继续尝试其他候选。

这一机制是 C++11/14 中模板元编程的基础。它允许你编写基于类型参数的属性而条件性可用的模板。

关键短语是「直接上下文」。函数体深处的替换失败是硬错误，不是 SFINAE。只有函数签名中的失败（返回类型、参数类型、模板参数列表或 requires 子句）才会触发 SFINAE。

std::enable_if

std::enable_if 仅在 Condition 为 true 时定义一个成员类型 type，其值等于 T。如果 Condition 为 false，成员 type 不存在，导致替换失败（SFINAE）。别名 std::enable_if_t 是 typename std::enable_if::type 的简写。

enable_if.cpp
#include <iostream>
#include <type_traits>

// Only enabled for integral types
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T>
safe_divide(T a, T b) {
    if (b == 0) return 0;  // safe fallback for integers
    return a / b;
}

// Only enabled for floating-point types
template <typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>
safe_divide(T a, T b) {
    if (b == 0.0) return std::numeric_limits<T>::quiet_NaN();
    return a / b;
}

// enable_if in template parameter (alternative placement)
template <typename T,
         std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
void process(T value) {
    std::cout << "Processing arithmetic value: " << value << '\n';
}

int main() {
    std::cout << safe_divide(10, 3)    << '\n'; // 3 (integer)
    std::cout << safe_divide(10.0, 3.0) << '\n'; // 3.33333 (double)
    std::cout << safe_divide(10, 0)    << '\n'; // 0 (safe fallback)
    std::cout << safe_divide(10.0, 0.0) << '\n'; // nan

    process(42);
    // process(std::string("hello")); // ERROR: no matching function
}

<type_traits> 库

头文件提供了一套全面的编译时类型自省和转换工具库。它们构成了基于 SFINAE 编程的骨干。

查询萃取（通过 ::value 或 _v 后缀返回 bool）：
- std::is_integral_v ── T 是否为整数类型？
- std::is_floating_point_v ── T 是否为浮点类型？
- std::is_pointer_v ── T 是否为指针？
- std::is_class_v ── T 是否为类/结构体？
- std::is_const_v ── T 是否有 const 限定？
- std::is_same_v ── T 和 U 是否为同一类型？
- std::is_base_of_v ── Base 是否为 Derived 的基类？
- std::is_convertible_v ── From 是否可以隐式转换为 To？
- std::is_constructible_v ── T 是否可以从 Args 构造？

转换萃取（通过 ::type 或 _t 后缀返回修改后的类型）：
- std::remove_reference_t ── 剥离 & 或 &&
- std::remove_const_t ── 剥离 const
- std::decay_t ── 应用数组到指针、函数到指针的退化，并移除 cv/引用
- std::conditional_t ── 编译时三元：如果 Cond 则 T 否则 F
- std::common_type_t ── 所有 Ts 都可以转换到的类型

std::void_t 与检测惯用法

std::void_t<...>（C++17）将任意类型序列映射为 void。它的强大之处在于 SFINAE：如果列表中的任何类型无效，特化就会被丢弃。这使得检测惯用法成为可能 ── 检查一个类型是否具有特定的成员、方法或嵌套类型。

void_t_detection.cpp
#include <iostream>
#include <type_traits>
#include <string>
#include <vector>

// Primary template: fallback, T does NOT have .size()
template <typename T, typename = void>
struct has_size : std::false_type {};

// Specialization: matches only if T has a .size() method
template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

template <typename T>
constexpr bool has_size_v = has_size<T>::value;

// Use the trait to branch behavior
template <typename T>
void describe(const T& value) {
    if constexpr (has_size_v<T>) {
        std::cout << "Container with " << value.size() << " elements\n";
    } else {
        std::cout << "Not a container: " << value << '\n';
    }
}

int main() {
    static_assert(has_size_v<std::string>);     // true
    static_assert(has_size_v<std::vector<int>>); // true
    static_assert(!has_size_v<int>);             // false

    describe(std::vector<int>{1, 2, 3}); // Container with 3 elements
    describe(42);                        // Not a container: 42
}

decltype 与 SFINAE

你可以在尾随返回类型中使用 decltype 来基于表达式是否有效触发 SFINAE。这种技术通常与逗号运算符结合使用，以丢弃表达式结果并返回所需的类型。

decltype_sfinae.cpp
#include <iostream>
#include <type_traits>

// Only callable if a + b is valid
template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

// Only callable if t.begin() and t.end() are valid
template <typename Container>
auto element_count(const Container& c)
    -> decltype(c.begin(), c.end(), std::size_t{}) {
    std::size_t count = 0;
    for (auto it = c.begin(); it != c.end(); ++it) ++count;
    return count;
}

int main() {
    std::cout << add(1, 2.5)   << '\n'; // 3.5
    std::cout << add(std::string("a"), std::string("b")) << '\n'; // ab

    std::vector<int> v{1, 2, 3, 4};
    std::cout << element_count(v) << '\n'; // 4
    // add(std::string("a"), 5); // SFINAE: no match, a+b invalid
}
常见陷阱

当 SFINAE 移除了所有可行的重载时，编译器会产生大量错误文本，列出它尝试过的每个候选以及每个失败的原因。这些错误信息以难以阅读著称 ── 对于单次误用通常就会跨越数百行。

试想一下：你调用了 safe_divide("hello", "world")。编译器尝试两个重载，两个都因 SFINAE 失败，然后你得到一条提及 enable_if、is_integral、is_floating_point 以及类型萃取内部细节的错误信息 ── 这些都无法帮助你理解真正的问题是「字符串不是数字」。

这是推动 C++20 概念的最强动力之一，概念能产生清晰、易读的错误信息，例如：「约束 std::integral 对于 T = const char* 未被满足」。

最佳实践

如果你在编写 C++20 代码，在几乎所有情况下都应优先使用概念而非 SFINAE。概念更易读，自然组合，并且产生更好的错误信息。将 SFINAE 保留给以下场景：

- 必须在 C++11/14/17 下编译的代码
- 没有标准概念等价物的复杂检测惯用法
- 必须支持多个 C++ 标准版本的库代码

即使在 C++17 代码中，当你可以在单个函数中表达逻辑时，也应优先使用 if constexpr 搭配类型萃取，而非 enable_if。

关键要点
  • SFINAE：如果替换模板参数在直接上下文中创建了无效类型，模板会被静默地从重载决议中移除
  • std::enable_if_t 是经典的 SFINAE 工具 ── 仅在 Condition 为 true 时存在
  • 提供编译时查询萃取（is_integral_v）和转换萃取（remove_reference_t）
  • std::void_t 支持检测惯用法 ── 检查类型是否具有特定的成员或操作
  • SFINAE 的错误信息以难以阅读著称 ── C++20 概念是现代的替代方案

测验 — 检验你的知识

(20 经验值)

1. SFINAE 代表什么，它的含义是什么？

2. 在模板特化中 `std::void_t<decltype(std::declval<T>().size())>` 实现了什么？

3. `std::decay_t<T>` 做了什么？

上一课
变参模板与折叠表达式
下一课
C++20 概念与约束