类型特征与SFINAE

1. 学习目标

本章节遵循 Bloom 认知分类法组织学习目标，使读者能够循序渐进地掌握 C++ 类型特征（Type Traits）与 SFINAE（Substitution Failure Is Not An Error）机制，并具备在生产环境中应用、评估、设计的能力。

1.1 Remember（记忆）

• R1：复述 <type_traits> 头文件中至少 20 个常用类型特征的名称、语义与返回值类型。
• R2：背出 SFINAE 缩写展开（Substitution Failure Is Not An Error）及其在 ISO/IEC 14882:2020 中的原始定义位置（§13.9.2 [temp.deduct]）。
• R3：列出 C++11/14/17/20/23 五代标准对类型特征库的主要增补项（如 _t/_v 后缀、void_t、concepts、is_constant_evaluated 等）。
• R4：记住”即时上下文（immediate context）“与”非即时上下文”的边界，理解为何函数体内的错误不属于 SFINAE。

1.2 Understand（理解）

• U1：解释模板参数替换（substitution）的完整流程：模板实参推导 → 替换 → SFINAE → 重载决议。
• U2：阐明 std::enable_if、std::void_t、std::conditional 三者的设计动机、运行机制与适用场景差异。
• U3：描述重载决议（overload resolution）中 SFINAE 如何”剔除”不合格候选的过程，给出形式化伪代码。
• U4：解释”成员检测器习语（member detector idiom）“的工作原理，阐明 void_t 如何检测类型成员是否存在。

1.3 Apply（应用）

• A1：使用 std::enable_if_t 为模板函数添加条件启用，使整数族与浮点族走不同重载。
• A2：使用 std::void_t 实现成员检测器，自动检测 T::iterator、T::size()、T::value_type 等成员是否存在。
• A3：使用 if constexpr（C++17）将运行期分支提升为编译期分支，消除模板实例化中的二义性。
• A4：使用 std::conditional_t 实现编译期类型选择，例如根据指针大小选择 int32_t 或 int64_t。

1.4 Analyze（分析）

• An1：分析 std::enable_if 三种典型书写位置（默认模板参数 / 返回类型 / 尾随实参）在重载歧义场景中的差异，给出每种写法的优劣对比。
• An2：分析 void_t 在 CWG 1558 提案之前的非标准地位及其对编译器实现的依赖性。
• An3：对比 SFINAE 与 C++20 concepts 在错误信息可读性、约束传播、子集化等维度上的优劣。
• An4：分析模板实例化深度对编译时间与二进制体积的影响，对比 SFINAE 与 concepts 的编译期开销。

1.5 Evaluate（评价）

• E1：评价一段给定的 SFINAE 代码在可维护性、可读性、编译期开销上的表现，给出 1-10 分的工程化评分。
• E2：判断在生产环境中应选用 SFINAE 还是 concepts，给出基于团队、编译器、C++ 标准版本、ABI 兼容性的决策树。
• E3：评估”过度使用 SFINAE”导致的代码可读性灾难，识别何时应该重构成普通函数重载或运行期分支。

1.6 Create（创造）

• C1：设计一个完整的 type-erased 容器（基于 std::any + 类型特征），支持任意可比较类型的有序存储。
• C2：实现一个自定义的 is_printable 类型特征，覆盖所有满足 std::ostream& << T 约束的类型，并给出概念等价的 C++20 版本。
• C3：设计一个基于 SFINAE 的”协议检测器”，自动检测类是否满足 Serializable、Iterable、Comparable 等协议。

2. 历史动机与发展脉络

2.1 史前时代：C++ 时代的类型查询困境（pre-1998）

C 语言时代不存在编译期类型查询这一概念，宏（macro）是唯一的”泛型”工具。C++ 早期模板的引入让泛型编程成为可能，但缺乏类型自省（introspection）能力——一个函数模板 template<typename T> void f(T) 无法在编译期回答”T 是整数吗？”、“T 有 size() 方法吗？“等问题。

1990 年代早期，标准模板库（STL）的设计者 Alexander Stepanov 在 HP 实验室工作期间，深刻感受到类型信息缺失对泛型库设计的阻碍。STL 的迭代器分类（input iterator、forward iterator、bidirectional iterator、random access iterator）需要编译期区分，但 C++ 缺乏统一机制。最初的解决方法是”特征类（traits class）“习语：

// 早期 iterator_traits 习语（STL 原始版本，1994 年前后）
template<typename Iterator>
struct iterator_traits {
    typedef typename Iterator::value_type value_type;
    typedef typename Iterator::difference_type difference_type;
    // ...
};

// 针对原生指针的偏特化
template<typename T>
struct iterator_traits<T*> {
    typedef T value_type;
    typedef std::ptrdiff_t difference_type;
    // ...
};

这种”用模板结构体包装类型信息”的模式是类型特征的雏形。

2.2 C++98：TR1 与 type_traits 的诞生

C++98 标准本身不含 <type_traits>，但 Boost.TypeTraits 库（由 John Maddock、Steve Cleary 等人于 2002 年开发）填补了这一空白。Boost.TypeTraits 提供了 is_integral、is_pointer、is_class、is_base_of 等数十个类型查询工具，并通过复杂的宏与模板特化技巧实现。

C++ 技术报告 1（TR1，ISO/IEC TR 19768:2007）正式将 Boost.TypeTraits 标准化为 <tr1/type_traits>，作为对 C++98 标准库的扩展。

2.3 C++11：type_traits 与 SFINAE 标准化

C++11（ISO/IEC 14882:2011）将 TR1 内容纳入正式标准，引入 <type_traits> 头文件，包含：

1. 类型分类（Primary type categories）：is_void、is_integral、is_floating_point、is_array、is_pointer、is_lvalue_reference、is_rvalue_reference、is_member_object_pointer、is_member_function_pointer、is_enum、is_union、is_class、is_function。
2. 复合类型分类（Composite type categories）：is_reference、is_arithmetic、is_fundamental、is_object、is_scalar、is_compound、is_member_pointer。
3. 类型属性（Type properties）：is_const、is_volatile、is_trivial、is_trivially_copyable、is_standard_layout、is_pod（C++20 弃用）、is_empty、is_polymorphic、is_abstract、is_final（C++14）、is_signed、is_unsigned。
4. 类型特性查询（Type feature queries）：alignment_of、rank、extent。
5. 类型关系（Type relationships）：is_same、is_base_of、is_convertible。
6. 类型变换（Type transformations）：remove_const、remove_volatile、remove_cv、add_const、add_volatile、add_cv、remove_reference、add_lvalue_reference、add_rvalue_reference、remove_pointer、add_pointer、make_signed、make_unsigned、remove_extent、remove_all_extents、decay、decay_t（C++14）。
7. 类型构造性查询（Property queries）：is_constructible、is_trivially_constructible、is_nothrow_constructible、is_default_constructible、is_copy_constructible、is_move_constructible、is_assignable、is_trivially_assignable、is_nothrow_assignable、is_destructible、is_trivially_destructible、is_nothrow_destructible、has_virtual_destructor。
8. 类型关系查询：is_trivially_assignable、is_nothrow_assignable。

同时，C++11 标准化了 std::enable_if、std::conditional、std::common_type、std::declval 等核心元编程工具。SFINAE 规则也在 C++11 中得到更严格的规范（§14.8.2 [temp.deduct]）。

2.4 C++14：_t 与 _v 后缀变量模板

C++14 引入变量模板（variable template），使类型特征可以用更简洁的语法访问：

// C++11 写法
template<typename T>
constexpr bool is_integral_v = std::is_integral<T>::value;

// 等价于
static_assert(std::is_integral<T>::value, "...");  // C++11
static_assert(std::is_integral_v<T>, "...");       // C++14

C++14 同时为所有类型变换添加 _t 后缀（如 std::remove_const_t），简化 typename std::remove_const<T>::type 的繁琐写法。

C++14 还引入了 std::enable_if_t、std::conditional_t、std::decay_t、std::add_pointer_t 等简化版本。

2.5 C++17：void_t 与 if constexpr

C++17 的两个关键改进：

2.5.1 std::void_t（CWG 1558）

std::void_t 看似无用：

template<typename...>
using void_t = void;

但其真正的威力在于让成员检测器习语变得简洁。在 C++17 之前，检测 T::iterator 是否存在需要复杂的 SFINAE 技巧；C++17 后：

template<typename T, typename = void>
struct has_iterator : std::false_type {};

template<typename T>
struct has_iterator<T, std::void_t<typename T::iterator>>
    : std::true_type {};

CWG 1558 提案（2015 年）明确了 SFINAE 对”无效类型或表达式”的处理规则，使 void_t 在所有主流编译器上行为一致。

2.5.2 if constexpr（P0128）

if constexpr 是 SFINAE 的语法糖替代，让编译期分支变得直观：

template<typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << value << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点: " << value << std::endl;
    } else {
        static_assert(sizeof(T) == 0, "不支持的类型");
    }
}

if constexpr 仅编译被选中的分支，避免了对未选中分支的实例化错误。

2.6 C++20：Concepts 革命

C++20（ISO/IEC 14882:2020）引入概念（Concepts），是类型特征与 SFINAE 的革命性升级。Concepts 提供：

1. 声明式语法：template<std::integral T> 比 template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>> 更清晰。
2. 错误信息友好：违反约束时，编译器报告”不满足 std::integral 约束”而非”模板替换失败”。
3. 约束传播：约束可以组合（&&、||）、原子化、子集化。
4. 重载排序：满足更严格约束的候选优先（subsumption）。

// C++20 concepts
template<std::integral T>
T abs_value(T value) {
    return value < 0 ? -value : value;
}

// requires 子句
template<typename T>
    requires std::is_arithmetic_v<T>
T compute(T value) { return value + 1; }

// 简写形式
auto add(std::integral auto a, std::integral auto b) {
    return a + b;
}

C++20 同时引入 std::is_constant_evaluated()（P0588），允许在运行期检测是否处于常量求值上下文。

2.7 C++23：完善与扩展

C++23 的主要增补：

1. std::is_implicit_lifetime：检测类型是否为隐式生命周期类型。
2. std::is_scoped_enum：检测是否为 C++11 作用域枚举。
3. if consteval：替代 if constexpr (std::is_constant_evaluated())。
4. static operator()：与类型特征结合创建无状态调用对象。
5. std::expected：与类型特征结合实现错误处理。

2.8 C++26：反射与静态分析

C++26 反射提案（P2996）将引入 ^T 反射运算符，允许在编译期枚举类型的成员、查询属性、生成代码。这将从根本上改变类型特征的使用方式：

// C++26 反射（提案中）
template<typename T>
void print_members() {
    template for (constexpr auto member : std::meta::members_of(^T)) {
        std::cout << std::meta::name_of(member) << std::endl;
    }
}

2.9 时间线总结表

3. 形式化定义

3.1 ISO/IEC 14882 中的类型特征定义

ISO/IEC 14882:2020 §20.15 [meta] 给出类型特征的形式化定义：

A type trait is a class template that takes one or more type arguments and provides a compile-time query or transformation on those types.

（类型特征是接受一个或多个类型实参的类模板，对这些类型提供编译期查询或变换。）

类型特征的所有查询结果都是 std::integral_constant 的派生类，继承 value（静态常量）、type（自身）、operator bool()（隐式转换）。

3.2 SFINAE 规则的形式化定义

ISO/IEC 14882:2020 §13.9.2 [temp.deduct] 第 8 段：

If substitution results in an invalid type or expression, type deduction fails. An invalid type or expression is one that would be ill-formed, with a diagnostic required, if written using the substituted arguments. Only invalid types and expressions in the immediate context of the function type and its template-parameter-lists or its explicit-specifier result in deduction failure. All other invalid types or expressions are hard errors.

（如果替换导致无效类型或表达式，类型推导失败。无效类型或表达式是使用替换实参后写出来会出错（需要诊断）的类型或表达式。仅当无效类型或表达式出现在函数类型及其模板参数列表或显式说明符的即时上下文中，才导致推导失败；其他位置的无效类型或表达式是硬错误。）

关键概念：“即时上下文（immediate context）“——即函数签名本身及其模板参数列表。函数体内的错误不属于即时上下文，是硬错误。

3.3 类型特征的语义分类

ISO/IEC 14882:2020 §20.15.2 [meta.rqmts] 将类型特征分为三大类：

3.3.1 Unary Type Traits（一元类型特征）

形式：template<typename T> struct Trait;

接受一个类型实参，返回布尔值或类型信息。例如 is_integral、remove_const。

3.3.2 Binary Type Traits（二元类型特征）

形式：template<typename T, typename U> struct Trait;

接受两个类型实参，返回布尔值。例如 is_same、is_base_of、is_convertible。

3.3.3 Transformation Traits（变换类型特征）

形式：template<typename T> struct Trait { using type = ...; };

接受一个类型实参，产生一个新类型。例如 remove_const、add_pointer、decay。

3.4 std::enable_if 的形式化定义

ISO/IEC 14882:2020 §20.15.3 [meta.help]：

template<bool Cond, typename T = void>
struct enable_if {};

template<typename T>
struct enable_if<true, T> {
    using type = T;
};

template<bool Cond, typename T = void>
using enable_if_t = typename enable_if<Cond, T>::type;

当 Cond 为 true 时，enable_if<true, T>::type 存在且为 T；当 Cond 为 false 时，enable_if<false, T> 无 type 成员，导致 SFINAE。

3.5 std::void_t 的形式化定义

ISO/IEC 14882:2020 §20.15.3.7 [meta.trans.other]：

template<typename...>
using void_t = void;

void_t 看似无用——它总是别名 void。但其真正价值在于”包内表达式替换失败”时，整个 void_t 实例化失败，触发 SFINAE。

3.6 std::conditional 的形式化定义

ISO/IEC 14882:2020 §20.15.3.6 [meta.trans.other]：

template<bool B, typename T, typename F>
struct conditional {
    using type = T;  // B 为 true 时
};

template<typename T, typename F>
struct conditional<false, T, F> {
    using type = F;  // B 为 false 时
};

template<bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;

conditional 是编译期三元运算符，根据 B 选择 T 或 F。

3.7 std::declval 的形式化定义

ISO/IEC 14882:2020 §20.15.7.3 [declval]：

template<typename T>
add_rvalue_reference_t<T> declval() noexcept;

declval 仅用于非求值上下文（如 decltype、sizeof、noexcept），用于在不调用构造函数的情况下获得 T 的右值引用。它没有定义，仅声明——任何实际调用都是未定义行为（UB）。

典型用法：

template<typename T>
using difference_type_t = decltype(std::declval<T>() - std::declval<T>());

// 检测 T 是否支持 operator-
template<typename T, typename = void>
struct has_minus : std::false_type {};

template<typename T>
struct has_minus<T, std::void_t<decltype(std::declval<T>() - std::declval<T>())>>
    : std::true_type {};

3.8 std::integral_constant 的形式化定义

ISO/IEC 14882:2020 §20.15.3 [meta.help]：

template<typename T, T v>
struct integral_constant {
    static constexpr T value = v;
    using value_type = T;
    using type = integral_constant;
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
};

template<bool B>
using bool_constant = integral_constant<bool, B>;

using true_type = bool_constant<true>;
using false_type = bool_constant<false>;

所有类型特征都继承自 true_type 或 false_type，因此可以：

• 使用 ::value 访问布尔值。
• 使用 ::type 获取类型自身（用于元函数组合）。
• 隐式转换为 bool。

3.9 Concepts 的形式化定义

ISO/IEC 14882:2020 §17 [concepts]：

template<typename T>
concept integral = std::is_integral_v<T>;

template<typename T, typename U>
concept same_as = std::is_same_v<T, U>;

Concepts 的核心优势：

1. 子集化（subsumption）：约束 A ∧ B 子集化 A 与 B，重载决议时更严格的约束优先。
2. 原子性：每个 concept 是原子约束，不会被分解为子表达式。
3. 错误信息友好：违反约束时报告 concept 名称而非模板替换失败。

4. 理论推导与原理解析

4.1 模板实参推导与替换流程

C++ 模板实例化的完整流程：

1. 模板实参推导（Template Argument Deduction）：根据函数参数类型推导模板参数。
2. 替换（Substitution）：将推导出的实参替换到模板签名中。
3. SFINAE：替换过程中若产生无效类型或表达式（在即时上下文中），推导失败。
4. 重载决议（Overload Resolution）：在所有未被 SFINAE 剔除的候选中选择最优。
5. 实例化（Instantiation）：实例化选中的模板。

形式化伪代码：

function overload_resolution(candidates, args):
    viable = []
    for c in candidates:
        try:
            args_deduced = deduce(c.template_params, c.function_params, args)
            substituted = substitute(c, args_deduced)
            # SFINAE: 仅即时上下文中的失败导致剔除
            if not is_ill_formed(substituted.immediate_context):
                viable.append((c, substituted))
            # 非即时上下文失败 → 硬错误（编译失败）
        except SFINAEFailure:
            continue
    return select_best(viable)

4.2 即时上下文（Immediate Context）的边界

“即时上下文”是 SFINAE 最微妙的概念。ISO/IEC 14882:2020 §13.9.2 [temp.deduct] 第 8 段明确：

即时上下文内（SFINAE 友好）：

• 函数签名本身（参数类型、返回类型、noexcept）。
• 模板参数列表。
• 显式说明符（explicit-specifier）。
• 模板参数的默认实参。

非即时上下文（硬错误）：

• 函数体内部。
• 类模板的成员定义。
• 类模板的成员函数体。
• 类模板的静态数据成员初始化。

示例：

// SFINAE 友好：替换失败在签名中
template<typename T>
auto f(T t) -> decltype(t.method()) {  // 若 T 无 method()，替换失败 → SFINAE
    return t.method();
}

// 硬错误：函数体内部的错误不属于即时上下文
template<typename T>
void g(T t) {
    t.nonexistent_method();  // 硬错误，编译失败
}

4.3 SFINAE 在重载决议中的作用

SFINAE 的核心作用是从重载候选集中”剔除”不合格的模板。考虑：

template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>  // 重载 A：整数版
abs_value(T value) { return value < 0 ? -value : value; }

template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>  // 重载 B：浮点版
abs_value(T value) { return value < 0 ? -value : value; }

abs_value(42);     // 调用 A：is_integral<int> = true，is_floating_point<int> = false → B 被 SFINAE 剔除
abs_value(3.14);    // 调用 B：is_floating_point<double> = true，is_integral<double> = false → A 被 SFINAE 剔除
abs_value("hi");    // 错误：两个重载都被剔除

执行流程：

1. 调用 abs_value(42)，候选集 {A, B}。
2. 对 A：替换 T=int，enable_if<is_integral<int>::value, int>::type = int，存在 → A 可行。
3. 对 B：替换 T=int，enable_if<is_floating_point<int>::value, int>::type——is_floating_point<int>::value = false，enable_if<false, int> 无 type 成员 → SFINAE 剔除 B。
4. 重载决议：可行集 {A}，唯一候选，调用 A。

4.4 enable_if 三种书写位置的语义差异

enable_if 有三种典型书写位置，每种有不同的语义与重载歧义特性：

4.4.1 作为默认模板参数

template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void f(T value) { /* 整数版 */ }

template<typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
void f(T value) { /* 浮点版 */ }  // 编译错误：重定义

问题：两个 f 的签名相同（都是 f<T, void>），导致重定义错误。

修正：使用不同的默认参数类型，或用 std::enable_if_t<Cond, int> = 0 模式：

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void f(T value) { /* 整数版 */ }

template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void f(T value) { /* 浮点版 */ }

4.4.2 作为返回类型

template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>  // 返回类型参与 SFINAE
f(T value) { return value; }

template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>
f(T value) { return value; }

优势：两个 f 的签名不同（返回类型不同），不会重定义。但返回类型不能用于 C++14 的 auto 推导。

4.4.3 作为尾随模板参数

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void f(T value) { /* 整数版 */ }

template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void f(T value) { /* 浮点版 */ }

优势：函数返回类型可以是 auto，且模板参数列表中不同条件的存在使签名不同。

最佳实践：优先使用尾随模板参数方式（4.4.3），避免重定义歧义，且兼容 auto 返回类型。

4.5 void_t 的工作原理

void_t 的核心是 CWG 1558 提案，明确了”别名模板实例化失败”应被 SFINAE 处理。

考虑成员检测器：

template<typename T, typename = void>
struct has_size : std::false_type {};

template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

工作流程：

1. 主模板 has_size<T, void> 永远匹配，value = false。
2. 偏特化 has_size<T, std::void_t<decltype(std::declval<T>().size())>>：
   • 替换 T = std::vector<int>：declval<vector<int>>().size() 有效 → void_t<...> = void → 偏特化 has_size<vector<int>, void> 匹配 → value = true。
   • 替换 T = int：declval<int>().size() 无效 → void_t 实例化失败 → SFINAE → 偏特化不匹配 → 回退主模板 → value = false。

CWG 1558 之前的行为：某些编译器（如 GCC 4.9）不会将别名模板失败视为 SFINAE，导致 void_t 不可移植。

4.6 if constexpr 的语义

if constexpr（C++17）是 SFINAE 的语法糖替代，但语义不同：

template<typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << value << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点: " << value << std::endl;
    } else {
        std::cout << "其他: " << value << std::endl;
    }
}

执行流程：

1. 实例化 process<int>：仅编译 if constexpr (is_integral<int>) 为 true 的分支，其他分支不实例化。
2. 实例化 process<double>：仅编译 if constexpr (is_floating_point<double>) 为 true 的分支。

if constexpr 的优势：

• 单个函数处理多种类型，无需重载。
• 错误信息友好：未选中分支的语法错误不会报错。
• 编译时间短：仅实例化选中的分支。

if constexpr 的局限：

• 无法用于模板签名（不能用于”剔除”重载候选）。
• 不能用于需要不同返回类型的场景（返回类型必须一致）。
• 不能完全替代 SFINAE（如需在签名层剔除候选时仍需 SFINAE）。

4.7 Concepts 的子集化（Subsumption）

Concepts 的核心优势是”子集化”——更严格的约束优先：

template<typename T>
concept Integral = std::is_integral_v<T>;

template<typename T>
concept SignedIntegral = Integral<T> && std::is_signed_v<T>;

template<typename T>
concept UnsignedIntegral = Integral<T> && std::is_unsigned_v<T>;

template<Integral T>      // 重载 A
void f(T) { std::cout << "任意整数" << std::endl; }

template<SignedIntegral T>  // 重载 B：子集化 A
void f(T) { std::cout << "有符号整数" << std::endl; }

f(42);    // int 是 SignedIntegral → B 更严格 → 调用 B
f(42u);   // unsigned int 是 UnsignedIntegral（非 SignedIntegral）→ 仅 A 匹配 → 调用 A

子集化规则：约束 C1 子集化 C2（即 C1 比 C2 更严格），当且仅当 C1 的原子约束集是 C2 的子集。

SFINAE 无法表达子集化，因此 SFINAE 的重载歧义需要手动避免。

4.8 std::decay 的语义

std::decay 是最重要的类型变换之一，模拟”按值传递”时的类型变换：

template<typename T>
struct decay {
    using U = remove_reference_t<T>;
    using type = conditional_t<
        is_array_v<U>,
        remove_extent_t<U>*,
        conditional_t<
            is_function_v<U>,
            add_pointer_t<U>,
            remove_cv_t<U>
        >
    >;
};

变换规则：

1. 移除引用：T&、T&& → T。
2. 若是数组：T[N] → T*。
3. 若是函数：T(Args...) → T(*)(Args...)。
4. 移除 cv 限定：const T、volatile T → T。

典型场景：

template<typename T>
void f(T x) {  // T 是 decay 后的类型
    // x 是按值传递的副本
}

int arr[10];
f(arr);  // T = int*（数组衰变为指针）
f(42);   // T = int
f(3.14); // T = double

4.9 类型特征的编译期开销

类型特征的实现通常基于编译器内建（intrinsic）或模板特化：

// is_integral 的典型实现
template<typename T> struct is_integral : false_type {};
template<> struct is_integral<bool> : true_type {};
template<> struct is_integral<char> : true_type {};
template<> struct is_integral<signed char> : true_type {};
template<> struct is_integral<unsigned char> : true_type {};
template<> struct is_integral<short> : true_type {};
// ... 共 30+ 个特化

复杂类型特征（如 is_constructible、is_convertible）依赖编译器内建：

template<typename T, typename... Args>
struct is_constructible : bool_constant<__is_constructible(T, Args...)> {};

__is_constructible 是编译器内建，由前端（clang、gcc、msvc）实现，避免复杂的 SFINAE 模拟。

4.10 类型特征的 ABI 兼容性

类型特征在不同编译器上的实现可能不同，但标准保证语义一致。然而：

1. is_trivially_copyable：早期 GCC 与 Clang 对”trivially copyable”的实现略有差异，导致跨编译器的 ABI 不兼容。
2. is_empty：MSVC 的早期版本对”空类”的定义与其他编译器不同。
3. has_virtual_destructor：跨编译器一致。

生产环境建议：在跨平台库中，避免依赖编译器实现细节，仅使用标准保证一致的类型特征。

5. 代码示例与实践

5.1 基础：常用类型特征

#include <type_traits>
#include <string>
#include <vector>

// 类型查询
static_assert(std::is_integral_v<int>);           // true
static_assert(std::is_integral_v<bool>);          // true
static_assert(std::is_integral_v<char>);          // true
static_assert(!std::is_integral_v<float>);        // false
static_assert(std::is_pointer_v<int*>);          // true
static_assert(std::is_reference_v<int&>);         // true
static_assert(std::is_const_v<const int>);       // true
static_assert(std::is_class_v<std::string>);     // true
static_assert(std::is_enum_v<std::byte>);         // true（C++17）

// 类型比较
static_assert(std::is_same_v<int, int32_t>);       // true（在大多数平台）
static_assert(!std::is_same_v<int, long>);         // 通常 true
static_assert(std::is_base_of_v<std::exception, std::runtime_error>);  // true
static_assert(std::is_convertible_v<int, double>); // true
static_assert(!std::is_convertible_v<double, int>); // false（窄化转换）

// 类型构造性
static_assert(std::is_constructible_v<std::string, const char*>);     // true
static_assert(std::is_default_constructible_v<int>);                   // true
static_assert(!std::is_copy_constructible_v<std::unique_ptr<int>>);   // false
static_assert(std::is_move_constructible_v<std::unique_ptr<int>>);     // true

// 条件类型选择
using IntPtr = std::conditional_t<true, int*, int>;  // int*
using SafeSize = std::conditional_t<sizeof(void*) == 8, int64_t, int32_t>;  // 64 位平台为 int64_t

5.2 enable_if 实战

#include <type_traits>
#include <iostream>
#include <string>

// 方式一：作为尾随模板参数（推荐）
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
T abs_value(T value) {
    return value < 0 ? -value : value;
}

template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
T abs_value(T value) {
    return value < 0 ? -value : value;
}

// 方式二：作为返回类型
template<typename T>
std::enable_if_t<std::is_arithmetic_v<T>, std::string>
to_string(T value) {
    return std::to_string(value);
}

// 方式三：作为默认模板参数（注意重定义歧义）
template<typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
T negate(T value) {
    return -value;
}

int main() {
    std::cout << abs_value(-42) << std::endl;     // 42
    std::cout << abs_value(-3.14) << std::endl;   // 3.14
    std::cout << to_string(42) << std::endl;     // "42"
    std::cout << negate(5) << std::endl;          // -5
    return 0;
}

5.3 类型变换

#include <type_traits>
#include <vector>

// 移除修饰
using T1 = std::remove_const_t<const int>;        // int
using T2 = std::remove_reference_t<int&>;         // int
using T3 = std::remove_pointer_t<int*>;           // int
using T4 = std::remove_cv_t<const volatile int>;  // int
using T5 = std::remove_extent_t<int[10]>;         // int

// 添加修饰
using T6 = std::add_const_t<int>;                 // const int
using T7 = std::add_pointer_t<int>;               // int*
using T8 = std::add_lvalue_reference_t<int>;      // int&

// 衰变（decay）：模拟按值传递
using T9 = std::decay_t<const int&>;              // int
using T10 = std::decay_t<int[10]>;                // int*
using T11 = std::decay_t<void(int)>;              // void(*)(int)
using T12 = std::decay_t<std::vector<int>&>;      // std::vector<int>

// make_signed / make_unsigned
using T13 = std::make_signed_t<unsigned int>;     // int
using T14 = std::make_unsigned_t<int>;            // unsigned int

// 条件类型
using PointerSafe = std::conditional_t<sizeof(void*) == 8, int64_t, int32_t>;

static_assert(std::is_same_v<T1, int>);
static_assert(std::is_same_v<T9, int>);
static_assert(std::is_same_v<T10, int*>);

5.4 成员检测器习语

#include <type_traits>
#include <vector>
#include <string>

// 检测 T 是否有 size() 成员函数
template<typename T, typename = void>
struct has_size : std::false_type {};

template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

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

// 检测 T 是否有 iterator 类型别名
template<typename T, typename = void>
struct has_iterator : std::false_type {};

template<typename T>
struct has_iterator<T, std::void_t<typename T::iterator>>
    : std::true_type {};

template<typename T>
inline constexpr bool has_iterator_v = has_iterator<T>::value;

// 检测 T 是否有 value_type
template<typename T, typename = void>
struct has_value_type : std::false_type {};

template<typename T>
struct has_value_type<T, std::void_t<typename T::value_type>>
    : std::true_type {};

// 检测 T 是否支持 operator<<
template<typename T, typename = void>
struct is_ostreamable : std::false_type {};

template<typename T>
struct is_ostreamable<T, std::void_t<decltype(
    std::declval<std::ostream&>() << std::declval<T>()
)>> : std::true_type {};

// 检测 T 是否有 serialize 方法
template<typename T, typename = void>
struct has_serialize : std::false_type {};

template<typename T>
struct has_serialize<T, std::void_t<decltype(
    std::declval<const T&>().serialize(std::declval<std::ostream&>())
)>> : std::true_type {};

// 测试
static_assert(has_size_v<std::vector<int>>);      // true
static_assert(!has_size_v<int>);                  // false
static_assert(has_iterator_v<std::vector<int>>); // true
static_assert(has_value_type_v<std::vector<int>>); // true
static_assert(is_ostreamable_v<int>);             // true
static_assert(is_ostreamable_v<std::string>);     // true

5.5 SFINAE 与重载决议

#include <type_traits>
#include <iostream>
#include <string>
#include <cstring>

// 根据类型选择不同的序列化方式
template<typename T>
std::enable_if_t<std::is_arithmetic_v<T>, std::string>
serialize(const T& value) {
    return std::to_string(value);
}

template<typename T>
std::enable_if_t<std::is_same_v<T, std::string>, std::string>
serialize(const T& value) {
    return "\"" + value + "\"";
}

template<typename T>
std::enable_if_t<std::is_enum_v<T>, std::string>
serialize(const T& value) {
    return std::to_string(static_cast<int>(value));
}

// 测试
enum class Color { Red, Green, Blue };

int main() {
    std::cout << serialize(42) << std::endl;                    // "42"
    std::cout << serialize(3.14) << std::endl;                  // "3.140000"
    std::cout << serialize(std::string("hello")) << std::endl;  // "\"hello\""
    std::cout << serialize(Color::Red) << std::endl;            // "0"
    return 0;
}

5.6 if constexpr 替代 SFINAE

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

template<typename T>
void inspect(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << value << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点: " << value << std::endl;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "字符串: " << value << std::endl;
    } else if constexpr (std::is_pointer_v<T>) {
        std::cout << "指针: " << value << std::endl;
    } else {
        std::cout << "其他类型" << std::endl;
    }
}

// 通用容器打印
template<typename Container>
void printContainer(const Container& c) {
    if constexpr (has_size_v<Container>) {
        std::cout << "size: " << c.size() << std::endl;
    }
    if constexpr (has_iterator_v<Container>) {
        for (const auto& item : c) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    inspect(42);
    inspect(3.14);
    inspect(std::string("hello"));
    inspect(static_cast<int*>(nullptr));

    std::vector<int> v = {1, 2, 3, 4, 5};
    printContainer(v);
    return 0;
}

5.7 自定义类型特征

#include <type_traits>
#include <iterator>
#include <vector>
#include <string>

// 检测类型是否可迭代
template<typename T, typename = void>
struct is_iterable : std::false_type {};

template<typename T>
struct is_iterable<T, std::void_t<
    decltype(std::begin(std::declval<T&>())),
    decltype(std::end(std::declval<T&>()))
>> : std::true_type {};

template<typename T>
inline constexpr bool is_iterable_v = is_iterable<T>::value;

// 检测类型是否是容器
template<typename T, typename = void>
struct is_container : std::false_type {};

template<typename T>
struct is_container<T, std::void_t<
    typename T::value_type,
    typename T::iterator,
    typename T::size_type,
    decltype(std::declval<T>().begin()),
    decltype(std::declval<T>().end()),
    decltype(std::declval<T>().size())
>> : std::true_type {};

template<typename T>
inline constexpr bool is_container_v = is_container<T>::value;

// 检测类型是否可序列化
template<typename T, typename = void>
struct is_serializable : std::false_type {};

template<typename T>
struct is_serializable<T, std::void_t<
    decltype(std::declval<const T&>().serialize(std::declval<std::ostream&>()))
>> : std::true_type {};

// 测试
static_assert(is_iterable_v<std::vector<int>>);   // true
static_assert(is_iterable_v<std::string>);        // true
static_assert(!is_iterable_v<int>);               // false

static_assert(is_container_v<std::vector<int>>);   // true
static_assert(!is_container_v<std::string>);      // 通常为 false（无 size_type 在某些实现中）

class Serializable {
public:
    void serialize(std::ostream& os) const {}
};
static_assert(is_serializable_v<Serializable>);    // true

5.8 编译期类型分发

#include <type_traits>
#include <cstring>
#include <iostream>
#include <vector>

// 根据类型是否可平凡拷贝选择不同的复制策略
template<typename T>
std::enable_if_t<std::is_trivially_copyable_v<T>>
fastCopy(T* dst, const T* src, size_t count) {
    std::cout << "使用 memcpy（平凡拷贝）" << std::endl;
    std::memcpy(dst, src, count * sizeof(T));
}

template<typename T>
std::enable_if_t<!std::is_trivially_copyable_v<T>>
fastCopy(T* dst, const T* src, size_t count) {
    std::cout << "使用逐元素拷贝（非平凡）" << std::endl;
    for (size_t i = 0; i < count; ++i) {
        dst[i] = src[i];
    }
}

int main() {
    int ints[10] = {1, 2, 3};
    int int_dst[10];
    fastCopy(int_dst, ints, 10);  // 使用 memcpy

    std::string strs[3] = {"a", "b", "c"};
    std::string str_dst[3];
    fastCopy(str_dst, strs, 3);   // 使用逐元素拷贝
    return 0;
}

5.9 C++20 Concepts 替代 SFINAE

#include <concepts>
#include <iostream>
#include <string>
#include <vector>

// 使用概念替代 enable_if，语法更简洁
template<std::integral T>
T process(T value) { return value * 2; }

// requires 子句
template<typename T>
    requires std::is_arithmetic_v<T>
T compute(T value) { return value + 1; }

// 简写形式
auto add(std::integral auto a, std::integral auto b) {
    return a + b;
}

// 自定义概念
template<typename T>
concept Printable = requires(const T& t, std::ostream& os) {
    os << t;
};

template<typename T>
concept Container = requires(const T& c) {
    typename T::value_type;
    typename T::iterator;
    c.begin();
    c.end();
    c.size();
};

template<Container C>
void print(const C& c) {
    for (const auto& item : c) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

template<Printable T>
void printValue(const T& value) {
    std::cout << value << std::endl;
}

int main() {
    std::cout << process(42) << std::endl;       // 84
    std::cout << compute(3.14) << std::endl;     // 4.14
    std::cout << add(3, 4) << std::endl;         // 7

    std::vector<int> v = {1, 2, 3, 4, 5};
    print(v);                                    // 1 2 3 4 5

    printValue(42);                              // 42
    printValue(std::string("hello"));            // hello
    return 0;
}

5.10 is_constant_evaluated 与 if consteval

#include <type_traits>
#include <cmath>
#include <iostream>

// C++20：检测是否处于常量求值上下文
constexpr double sqrt_constexpr(double x) {
    if (std::is_constant_evaluated()) {
        // 编译期：使用牛顿迭代法
        if (x <= 0) return 0.0;
        double guess = x / 2;
        for (int i = 0; i < 20; ++i) {
            guess = (guess + x / guess) / 2;
        }
        return guess;
    } else {
        // 运行期：使用硬件 sqrt
        return std::sqrt(x);
    }
}

// C++23：if consteval 替代 is_constant_evaluated
constexpr double sqrt_cpp23(double x) {
    if consteval {
        // 编译期路径
        if (x <= 0) return 0.0;
        double guess = x / 2;
        for (int i = 0; i < 20; ++i) {
            guess = (guess + x / guess) / 2;
        }
        return guess;
    } else {
        return std::sqrt(x);
    }
}

int main() {
    constexpr double r1 = sqrt_constexpr(2.0);   // 编译期计算
    double r2 = sqrt_constexpr(2.0);             // 运行期计算
    std::cout << r1 << " " << r2 << std::endl;
    return 0;
}

6. 跨语言对比

6.1 C++ vs Rust：Trait 与 Concept

Rust 的 trait 系统与 C++ 的 concepts 有相似之处，但实现机制不同：

// Rust trait
trait Printable {
    fn print(&self);
}

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

fn print_all<T: Printable>(items: &[T]) {
    for item in items {
        item.print();
    }
}

对比：

6.2 C++ vs Java：泛型与类型擦除

Java 的泛型使用类型擦除，编译期不保留类型信息：

// Java 泛型
public class Box<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 限制：T 必须是 Number 的子类
public class NumberBox<T extends Number> {
    private T value;
    public double doubleValue() { return value.doubleValue(); }
}

对比：

6.3 C++ vs Go：接口与隐式实现

Go 的接口采用隐式实现（duck typing）：

// Go 接口
type Printable interface {
    String() string
}

func printAll[T Printable](items []T) {
    for _, item := range items {
        fmt.Println(item.String())
    }
}

// 任何实现了 String() string 的类型自动满足 Printable
type MyInt int
func (m MyInt) String() string { return fmt.Sprintf("%d", int(m)) }

对比：

6.4 C++ vs C#：泛型与约束

C# 的泛型使用约束（constraints）：

// C# 泛型约束
public class Container<T> where T : IComparable<T>, new() {
    private List<T> items = new List<T>();

    public void Add(T item) { items.Add(item); }

    public T Max() {
        T max = default;
        foreach (var item in items) {
            if (max == null || item.CompareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }
}

对比：

6.5 总结对比表

7. 常见陷阱与避坑指南

7.1 陷阱一：SFINAE 条件依赖非模板参数

// 错误：SFINAE 条件不能依赖非模板参数
template<typename T>
void f(T value, std::enable_if_t<sizeof(int) == 4>* = nullptr) {
    // sizeof(int) 是编译期常量，但与 T 无关
    // 这个 enable_if 永远启用或永远禁用，无意义
}

// 正确：条件必须依赖模板参数 T
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void f(T value) { /* ... */ }

7.2 陷阱二：两个 enable_if 重载条件重叠

// 错误：is_arithmetic 包含 is_integral，导致歧义
template<typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
void g(T value) { /* 算术版 */ }

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void g(T value) { /* 整数版 */ }

g(42);  // 歧义错误：两个重载都匹配

修正：使用互斥条件：

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void g(T value) { /* 整数版 */ }

template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void g(T value) { /* 浮点版 */ }

g(42);   // 调用整数版
g(3.14); // 调用浮点版

7.3 陷阱三：函数体内的错误不属于 SFINAE

// 错误：函数体内的错误是硬错误
template<typename T>
void h(T value) {
    value.nonexistent_method();  // 硬错误，编译失败
}

// 正确：使用 if constexpr 或将检测移到签名
template<typename T>
auto h(T value) -> decltype(value.method(), void()) {
    value.method();  // 安全：已通过 decltype 检测
}

// 或使用 if constexpr
template<typename T>
void h_safe(T value) {
    if constexpr (has_method_v<T>) {
        value.method();
    }
}

7.4 陷阱四：_v 后缀在 C++14 之前不可用

// C++11：必须使用 ::value
static_assert(std::is_integral<int>::value, "...");

// C++14+：可使用 _v 后缀
static_assert(std::is_integral_v<int>, "...");

如果项目必须支持 C++11，需要使用 ::value 形式。

7.5 陷阱五：void_t 在 C++17 之前不可移植

// C++17 之前：手动定义 void_t
template<typename...>
using void_t = void;

// 或使用更兼容的技巧
template<typename T, typename = void>
struct has_size : std::false_type {};

template<typename T>
struct has_size<T, decltype(std::declval<T>().size(), void())>
    : std::true_type {};

7.6 陷阱六：enable_if 作为默认模板参数时的重定义

// 错误：两个重载签名相同，导致重定义
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void f(T) {}

template<typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
void f(T) {}  // 重定义错误

修正：使用 enable_if_t<Cond, int> = 0 模式：

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void f(T) {}

template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void f(T) {}

7.7 陷阱七：std::declval 不能在求值上下文使用

// 错误：declval 仅用于非求值上下文
auto x = std::declval<int>();  // UB：declval 无定义

// 正确：用于 decltype、sizeof、noexcept
using T = decltype(std::declval<int>() + std::declval<double>());  // double
static_assert(sizeof(std::declval<int>()) == sizeof(int));

7.8 陷阱八：is_convertible 的双向语义

static_assert(std::is_convertible_v<int, double>);   // true
static_assert(!std::is_convertible_v<double, int>);  // false（窄化转换）
static_assert(std::is_convertible_v<const char*, std::string>);  // true
static_assert(!std::is_convertible_v<std::string, const char*>); // false

注意 is_convertible 对窄化转换的处理：double → int 是 false，因为隐式转换会窄化。

7.9 陷阱九：decay 与 remove_cvref 的差异

using T1 = std::decay_t<int[10]>;        // int*
using T2 = std::remove_cvref_t<int[10]>; // int[10]（C++20）

using T3 = std::decay_t<int(int)>;        // int(*)(int)
using T4 = std::remove_cvref_t<int(int)>; // int(int)

decay 模拟按值传递的完整变换（衰变数组、函数），remove_cvref 仅移除 cv 与引用。

7.10 陷阱十：Concepts 与 SFINAE 混用时的歧义

// C++20：同时使用 concepts 和 SFINAE 可能产生歧义
template<std::integral T>
void f(T value) { /* concept 版 */ }

template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void f(T value) { /* SFINAE 版 */ }

f(42);  // 歧义错误：两个重载都匹配

修正：统一使用 concepts 或 SFINAE，不要混用。

8. 工程实践与最佳实践

8.1 何时使用 SFINAE，何时使用 Concepts

使用 Concepts（C++20+）的场景：

• 项目可以使用 C++20 标准。
• 需要友好的错误信息。
• 需要约束的组合与子集化。
• 需要约束的原子化传播。

使用 SFINAE 的场景：

• 项目必须支持 C++17 或更早版本。
• 需要在模板签名中剔除候选（concepts 也可以，但 SFINAE 更灵活）。
• 需要复杂的类型变换与查询组合。

使用 if constexpr 的场景：

• 单个函数内根据类型选择不同实现。
• 不需要剔除重载候选。
• 不同分支的返回类型相同。

8.2 SFINAE 代码风格规范

// 推荐：尾随模板参数方式
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void process(T value);

// 推荐：返回类型方式（适用于不同返回类型）
template<typename T>
std::enable_if_t<std::is_integral_v<T>, T> compute(T value);

// 避免：默认模板参数方式（易重定义）
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void process(T value);

8.3 类型特征命名规范

// 查询类：has_ 前缀
template<typename T> struct has_size : ... {};
template<typename T> inline constexpr bool has_size_v = has_size<T>::value;

// 检测类：is_ 前缀
template<typename T> struct is_iterable : ... {};
template<typename T> inline constexpr bool is_iterable_v = is_iterable<T>::value;

// 变换类：remove_ / add_ / make_ 前缀
template<typename T> struct remove_const { using type = ...; };
template<typename T> using remove_const_t = typename remove_const<T>::type;

8.4 成员检测器模板

// 通用成员检测器模板
#define DEFINE_MEMBER_DETECTOR(Member) \
    template<typename T, typename = void> \
    struct has_##Member : std::false_type {}; \
    template<typename T> \
    struct has_##Member<T, std::void_t<decltype(std::declval<T>().Member)>> \
        : std::true_type {}; \
    template<typename T> \
    inline constexpr bool has_##Member##_v = has_##Member<T>::value;

DEFINE_MEMBER_DETECTOR(size)
DEFINE_MEMBER_DETECTOR(begin)
DEFINE_MEMBER_DETECTOR(end)
DEFINE_MEMBER_DETECTOR(c_str)

8.5 类型特征的单元测试

#include <type_traits>
#include <vector>
#include <string>

// 类型特征应有单元测试
static_assert(std::is_integral_v<int>);
static_assert(std::is_integral_v<bool>);
static_assert(std::is_integral_v<char>);
static_assert(!std::is_integral_v<float>);
static_assert(!std::is_integral_v<std::string>);

// 自定义类型特征的测试
struct WithSize {
    size_t size() const { return 0; }
};
struct WithoutSize {};

static_assert(has_size_v<WithSize>);
static_assert(!has_size_v<WithoutSize>);
static_assert(has_size_v<std::vector<int>>);
static_assert(has_size_v<std::string>);

8.6 SFINAE 的可读性优化

复杂的 SFINAE 代码可以通过别名模板提升可读性：

// 原始：难以阅读
template<typename T, std::enable_if_t<
    std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
void process(T value) { /* ... */ }

// 优化：使用别名模板
template<typename T>
using is_non_bool_integral = std::bool_constant<
    std::is_integral_v<T> && !std::is_same_v<T, bool>
>;

template<typename T>
inline constexpr bool is_non_bool_integral_v = is_non_bool_integral<T>::value;

template<typename T, std::enable_if_t<is_non_bool_integral_v<T>, int> = 0>
void process(T value) { /* ... */ }

// 进一步优化：使用 concept（C++20）
template<typename T>
concept NonBoolIntegral = std::integral<T> && !std::same_as<T, bool>;

template<NonBoolIntegral T>
void process(T value) { /* ... */ }

8.7 编译时间优化

SFINAE 会增加模板实例化深度，影响编译时间。优化策略：

1. 优先使用 if constexpr：单次实例化，避免重载歧义。
2. 使用概念（C++20）：约束传播更高效。
3. 减少不必要的 SFINAE：能用普通函数重载解决的，不要用 SFINAE。
4. 使用前置声明：减少重复实例化。

8.8 跨编译器兼容性

// 跨编译器兼容的 void_t
#if __cplusplus >= 201703L
    using std::void_t;
#else
    template<typename...> using void_t = void;
#endif

// 跨编译器兼容的 enable_if_t
#if __cplusplus >= 201402L
    using std::enable_if_t;
#else
    template<bool C, typename T = void>
    using enable_if_t = typename std::enable_if<C, T>::type;
#endif

9. 案例研究

9.1 案例一：类型安全的序列化系统

#include <type_traits>
#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>

// 序列化接口：根据类型特征选择不同实现
template<typename T>
std::enable_if_t<std::is_arithmetic_v<T>, std::string>
serialize(const T& value) {
    return std::to_string(value);
}

template<typename T>
std::enable_if_t<std::is_same_v<T, std::string>, std::string>
serialize(const T& value) {
    return "\"" + value + "\"";
}

template<typename T>
std::enable_if_t<std::is_enum_v<T>, std::string>
serialize(const T& value) {
    return std::to_string(static_cast<std::underlying_type_t<T>>(value));
}

template<typename T>
std::enable_if_t<std::is_pointer_v<T>, std::string>
serialize(const T& value) {
    if (value == nullptr) return "null";
    return "ptr:" + std::to_string(reinterpret_cast<uintptr_t>(value));
}

// 容器序列化（递归）
template<typename Container>
std::enable_if_t<
    !std::is_arithmetic_v<Container> &&
    !std::is_same_v<Container, std::string> &&
    !std::is_pointer_v<Container> &&
    !std::is_enum_v<Container> &&
    has_begin_v<Container> && has_end_v<Container>,
    std::string>
serialize(const Container& c) {
    std::string result = "[";
    bool first = true;
    for (const auto& item : c) {
        if (!first) result += ", ";
        result += serialize(item);
        first = false;
    }
    result += "]";
    return result;
}

// 测试
enum class Status { Active = 0, Inactive = 1, Pending = 2 };

int main() {
    std::cout << serialize(42) << std::endl;                  // "42"
    std::cout << serialize(3.14) << std::endl;                 // "3.140000"
    std::cout << serialize(std::string("hello")) << std::endl; // "\"hello\""
    std::cout << serialize(Status::Active) << std::endl;       // "0"

    int x = 42;
    std::cout << serialize(&x) << std::endl;                   // "ptr:..."

    std::vector<int> v = {1, 2, 3};
    std::cout << serialize(v) << std::endl;                     // "[1, 2, 3]"

    std::vector<std::vector<int>> vv = {{1, 2}, {3, 4}};
    std::cout << serialize(vv) << std::endl;                    // "[[1, 2], [3, 4]]"
    return 0;
}

9.2 案例二：编译期类型分发系统

#include <type_traits>
#include <iostream>
#include <vector>
#include <string>
#include <cstring>

// 编译期分发：根据类型特征选择最优实现
template<typename T>
class TypeHandler {
public:
    static void copy(T* dst, const T* src, size_t count) {
        if constexpr (std::is_trivially_copyable_v<T>) {
            std::memcpy(dst, src, count * sizeof(T));
            std::cout << "memcpy: " << count * sizeof(T) << " bytes" << std::endl;
        } else {
            for (size_t i = 0; i < count; ++i) {
                dst[i] = src[i];
            }
            std::cout << "element-wise copy: " << count << " elements" << std::endl;
        }
    }

    static bool equals(const T& a, const T& b) {
        if constexpr (std::has_unique_object_representations_v<T>) {
            return std::memcmp(&a, &b, sizeof(T)) == 0;
        } else {
            return a == b;
        }
    }

    static size_t hash(const T& value) {
        if constexpr (std::has_unique_object_representations_v<T>) {
            const char* bytes = reinterpret_cast<const char*>(&value);
            size_t h = 0;
            for (size_t i = 0; i < sizeof(T); ++i) {
                h = h * 31 + bytes[i];
            }
            return h;
        } else {
            return std::hash<T>{}(value);
        }
    }
};

// 测试
struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

int main() {
    // 平凡可拷贝类型
    int ints_src[5] = {1, 2, 3, 4, 5};
    int ints_dst[5];
    TypeHandler<int>::copy(ints_dst, ints_src, 5);

    // 非平凡可拷贝类型
    std::string strs_src[3] = {"a", "b", "c"};
    std::string strs_dst[3];
    TypeHandler<std::string>::copy(strs_dst, strs_src, 3);

    // 平凡比较
    Point p1{1, 2}, p2{1, 2};
    std::cout << TypeHandler<Point>::equals(p1, p2) << std::endl;  // 1（has_unique_object_representations）
    return 0;
}

9.3 案例三：协议检测器

#include <type_traits>
#include <iostream>
#include <string>
#include <vector>
#include <forward_list>

// 协议检测器：检测类是否满足特定协议

// Serializable 协议
template<typename T, typename = void>
struct is_serializable : std::false_type {};

template<typename T>
struct is_serializable<T, std::void_t<
    decltype(std::declval<const T&>().serialize(std::declval<std::ostream&>()))
>> : std::true_type {};

// Iterable 协议
template<typename T, typename = void>
struct is_iterable : std::false_type {};

template<typename T>
struct is_iterable<T, std::void_t<
    decltype(std::begin(std::declval<T&>())),
    decltype(std::end(std::declval<T&>()))
>> : std::true_type {};

// Comparable 协议
template<typename T, typename = void>
struct is_comparable : std::false_type {};

template<typename T>
struct is_comparable<T, std::void_t<
    decltype(std::declval<const T&>() < std::declval<const T&>()),
    decltype(std::declval<const T&>() == std::declval<const T&>())
>> : std::true_type {};

// Hashable 协议
template<typename T, typename = void>
struct is_hashable : std::false_type {};

template<typename T>
struct is_hashable<T, std::void_t<
    decltype(std::hash<T>{}(std::declval<const T&>()))
>> : std::true_type {};

// 协议报告器
template<typename T>
void report_protocols() {
    std::cout << "Type: " << typeid(T).name() << std::endl;
    std::cout << "  Serializable: " << is_serializable_v<T> << std::endl;
    std::cout << "  Iterable: " << is_iterable_v<T> << std::endl;
    std::cout << "  Comparable: " << is_comparable_v<T> << std::endl;
    std::cout << "  Hashable: " << is_hashable_v<T> << std::endl;
}

// 测试类型
class SerializableItem {
public:
    void serialize(std::ostream& os) const {
        os << "SerializableItem";
    }
};

int main() {
    report_protocols<int>();                  // 可比较、可哈希
    report_protocols<std::string>();           // 可序列化、可迭代、可比较、可哈希
    report_protocols<std::vector<int>>();      // 可迭代、可比较
    report_protocols<SerializableItem>();      // 可序列化
    return 0;
}