模板元编程

第 1 章 学习目标与导论

本章节阐述读者在完成本模块学习后应具备的认知与工程能力，目标按 Bloom 分类法（修订版）组织，由低阶（记忆、理解）到高阶（应用、分析、评估、创造）递进。

1.1 模块定位

模板元编程（Template Metaprogramming, TMP）是 C++ 区别于其他主流工业语言的标志性能力之一。它使得开发者能够：

• 在编译期执行任意图灵完备计算，将运行时开销前移至编译期；
• 通过参数化类型与代码生成实现零开销抽象（zero-overhead abstraction）；
• 表达精细的类型约束，在编译期捕获接口误用；
• 通过策略注入与表达式模板等高级范式构建可扩展的高性能库。

模板元编程并非孤立的语法特性，而是与 C++ 的类型系统、值类别、异常机制、模块系统深度耦合。本模块假定读者已掌握 C++ 基础语法、指针与引用、面向对象基础，并建议在学习前先阅读「右值引用与移动语义」「RAII 资源管理」「智能指针详解」模块以建立现代 C++ 心智模型。

1.2 学习路径

graph LR
    A[基础语法] --> B[模板参数化]
    B --> C[特化与偏特化]
    C --> D[SFINAE 与 enable_if]
    D --> E[void_t 与 constexpr if]
    E --> F[C++20 Concepts]
    F --> G[可变参数模板]
    G --> H[折叠表达式]
    H --> I[CRTP 静态多态]
    I --> J[Expression Templates]
    J --> K[Policy-Based Design]
    K --> L[Type Erasure + Bridge]
    L --> M[现代库设计实践]
    style A fill:#e1f5fe
    style M fill:#c8e6c9

1.3 关键术语速览

第 2 章 历史动机与演进

模板元编程的演进是 C++ 语言史上最具戏剧性的篇章之一：本为「参数化类型与代码」而设计的模板系统，被发现具备图灵完备性，进而催生了整整一代编译期计算技术。本章梳理从 1989 年 Cfront 到 2023 年 C++23 的关键里程碑。

2.1 Cfront 时代：模板的诞生（1989–1995）

C++ 的模板由 Bjarne Stroustrup 在 1989 年前后构想，首份完整实现出现在 1991 年的 Cfront 3.0 中。其设计动机源于对「类型安全的容器与算法」的需求——彼时 C 程序员靠 void* 与宏实现泛型容器，丧失类型安全与效率。Stroustrup 在《The Design and Evolution of C++》（1994）中写道：

「模板旨在提供一种既能保持类型安全又能避免宏的预处理局限的参数化机制。」

早期模板的能力相当有限：

• 仅支持类型参数（非类型参数与模板模板参数后续才引入）；
• 不支持偏特化（Cfront 3.0.x 后才补全）；
• 编译器对实例化深度有严格限制（Cfront 通常为 8 层）；
• 错误诊断极为原始，常出现「模板递归过深」之类的笼统错误。

然而即便在如此受限的环境中，模板的图灵完备性已被 Erwin Unruh 于 1994 年偶然发现。当时身为 Siemens 工程师的 Unruh 编写了一段计算素数列表的程序，该程序不产生运行时输出，但编译器错误信息中包含一个素数序列。这是 C++ 模板元编程的开端。

// Erwin Unruh 1994 年原始程序的现代简化重构（保留原意）
// 该程序在编译期通过模板递归计算素数，并在错误信息中输出
#include <cstdio>

template<int p, int i>
struct is_prime {
    enum { value = (p % i != 0) && is_prime<p, i - 1>::value };
};

template<int p>
struct is_prime<p, 1> {
    enum { value = 1 };
};

template<int i>
struct Prime_print {
    Prime_print<i - 1> a;
    // 强制编译器在错误信息中输出 i，前提是 i 为素数
    static_assert(is_prime<i, i - 1>::value, "i is prime");
    enum { value = i };
    void f() { printf("%d\n", value); }  // 仅为占位，实际从不调用
};

template<>
struct Prime_print<1> {
    enum { value = 1 };
};

// 实例化将触发编译期素数计算
// Prime_print<18> b;  // 取消注释后编译错误信息中可见素数列表

2.2 C++98：模板标准化与 STL

C++98 标准正式将模板纳入语言规范，关键能力包括：

• 类模板、函数模板、成员模板；
• 全特化与偏特化（partial specialization）；
• 模板模板参数（template template parameters）；
• 非类型参数（non-type template parameters，仅限整型常量与指针）；
• 隐式实例化与显式实例化；
• 两阶段名字查找（two-phase name lookup）雏形。

同时期，Alexander Stepanov 与 Meng Lee 完成 STL（Standard Template Library），1994 年被吸纳进 C++ 标准库。STL 的核心思想——「算法与容器通过迭代器解耦」——成为泛型编程（generic programming）的范式原型，并催生了 traits 技术：Nathan Myers 在 1995 年提出 std::iterator_traits，将「与类型相关但又不属于类型本身」的属性（如 value_type、iterator_category）集中描述。

// C++98 风格的元函数与 traits 示例
#include <iterator>
#include <vector>
#include <list>

// C++98 风格的元函数：通过嵌套 ::type 实现
template<typename T>
struct remove_const {
    typedef T type;
};

template<typename T>
struct remove_const<const T> {
    typedef T type;
};

// C++98 风格的迭代器分类分发
template<typename Iter, typename Distance>
void advance_impl(Iter& it, Distance n, std::input_iterator_tag) {
    while (n--) ++it;
}

template<typename Iter, typename Distance>
void advance_impl(Iter& it, Distance n, std::random_access_iterator_tag) {
    it += n;
}

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

// 使用
int main() {
    std::vector<int>::iterator vit;
    std::list<int>::iterator lit;
    advance(vit, 5);   // 调用 random_access 版本
    advance(lit, 5);   // 调用 input_iterator 版本（list 是双向迭代器）
    return 0;
}

2.3 C++11：可变参数模板与 type_traits

C++11 是模板元编程的「大爆炸」时期。关键特性包括：

// C++11 可变参数模板与 type_traits
#include <type_traits>

// 可变参数模板：编译期求和
template<typename... Args>
struct Sum;

template<typename T>
struct Sum<T> {
    static constexpr T value = T{};
};

template<typename T, typename... Rest>
struct Sum<T, Rest...> {
    static constexpr T value = T{} + Sum<Rest...>::value;
};

// 别名模板简化元函数
template<typename T>
using RemoveConst = typename std::remove_const<T>::type;

// SFINAE 配合 trailing return type
template<typename T>
auto get_size(const T& c) -> decltype(c.size()) {
    return c.size();
}

// static_assert 编译期断言
static_assert(Sum<int, 1, 2, 3, 4>::value == 10, "Sum failed");
static_assert(std::is_same<RemoveConst<const int>, int>::value, "RemoveConst failed");

2.4 C++14：变量模板与 constexpr 增强

C++14 是相对小但关键的演进：

• 变量模板（variable template）：N3651 提案，使「元函数返回值」从 ::value 简化为 _v 后缀；
• constexpr 函数放宽：允许循环、变量声明、条件分支；
• std::integer_sequence：编译期整数序列；
• 泛型 lambda：[](auto x){}，本质是模板的简写。

// C++14 变量模板与 constexpr
#include <type_traits>

// 变量模板：替代传统元函数的 ::value
template<typename T>
constexpr bool is_pointer_v = false;

template<typename T>
constexpr bool is_pointer_v<T*> = true;

// constexpr 函数支持循环
constexpr int factorial(int n) {
    int r = 1;
    for (int i = 2; i <= n; ++i) r *= i;
    return r;
}

static_assert(factorial(5) == 120, "factorial failed");
static_assert(is_pointer_v<int*>, "is_pointer failed");
static_assert(!is_pointer_v<int>, "is_not_pointer failed");

2.5 C++17：折叠表达式、constexpr if、void_t

C++17 引入三大 TMP 关键特性：

// C++17 折叠表达式
#include <iostream>

// 一元右折叠：(args + ...)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 等价于 ((arg1 + arg2) + arg3) + ...
}

// 一元左折叠：(... + args)
template<typename... Args>
auto left_sum(Args... args) {
    return (... + args);  // 等价于 arg1 + (arg2 + arg3) + ...
}

// 二元右折叠：(args + ... + init)
template<typename... Args>
auto sum_with_init(Args... args) {
    return (args + ... + 0);  // 空包时返回 0
}

// 折叠与逻辑运算
template<typename... Args>
bool all_positive(Args... args) {
    return (... && (args > 0));  // 全部为正
}

// constexpr if 简化 SFINAE
template<typename T>
void process(T x) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "integral: " << x << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "float: " << x << std::endl;
    } else {
        std::cout << "other" << std::endl;
    }
}

2.6 C++20：Concepts 与约束

C++20 是 TMP 自 C++11 以来最大的一次范式跃迁。Concepts（概念）由 Sutton 与 Stroustrup 历经 20 年提案（N2914 2009 → P0644R1 2017 → P1084R0 2018 → P1452 2019 → C++20 入标）最终入标。其核心价值：

• 可读性：约束以命名概念形式声明，告别冗长的 enable_if 表达式；
• 错误诊断：编译器能精确指出哪个原子约束未满足；
• subsumption：约束之间的蕴含关系实现部分排序，支持精细重载；
• 简化语法：template<Addable T> 替代 template<typename T, typename = enable_if_t<...>>；
• 缩写形式：void f(std::integral auto x) 直接约束 auto。

// C++20 Concepts 全景
#include <concepts>
#include <iostream>

// 命名概念
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
    { a - b } -> std::convertible_to<T>;
};

// 多参数概念
template<typename From, typename To>
concept ConvertibleTo = std::convertible_to<From, To>;

// 复合概念
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<typename T>
concept Arithmetic = Numeric<T> && requires(T a, T b) {
    { a + b } -> std::same_as<T>;
    { a * b } -> std::same_as<T>;
};

// 三种使用形式

// 形式 1：constrained type parameter
template<Arithmetic T>
T dot_product(const std::vector<T>& a, const std::vector<T>& b) {
    T result = T{};
    for (size_t i = 0; i < a.size(); ++i) result += a[i] * b[i];
    return result;
}

// 形式 2：requires 子句
template<typename T>
    requires Arithmetic<T>
T square(T x) { return x * x; }

// 形式 3：缩写形式
auto cube(Arithmetic auto x) { return x * x * x; }

// subsumption 实现重载排序
template<typename T>
    requires std::integral<T>
void describe(T) { std::cout << "integral\n"; }

template<typename T>
    requires std::signed_integral<T>
void describe(T) { std::cout << "signed integral\n"; }  // 更受约束，优先匹配

2.7 C++23：Deducing this 与进一步演进

C++23 通过 Deducing this（P0847R7）提案，使成员函数能显式接收 this 参数，开启了模板元编程的新维度：

• 允许成员函数根据对象的值类别（lvalue/rvalue）进行重载；
• 简化 CRTP 模式，基类访问派生类不再需要 static_cast；
• 支持递归 lambda；
• 与 Concepts 配合，使「按值类别分发」编译期决策更自然。

// C++23 Deducing this 简化 CRTP
#include <iostream>

// 传统 CRTP：需要 static_cast<Derived*>(this)
template<typename Derived>
struct OldCRTPBase {
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

// C++23 Deducing this：显式接收 self 参数
struct NewBase {
    // self 是推导出的 this，类型根据调用对象决定
    template<typename Self>
    void interface(this Self&& self) {
        std::forward<Self>(self).implementation();
    }
};

struct Derived : NewBase {
    void implementation() { std::cout << "Derived::impl\n"; }
};

// 按值类别重载
struct Logger {
    template<typename Self>
    void log(this Self&& self, const char* msg) {
        if constexpr (std::is_lvalue_reference_v<Self>) {
            std::cout << "[lvalue] " << msg << "\n";
        } else {
            std::cout << "[rvalue] " << msg << "\n";
        }
    }
};

int main() {
    Derived d;
    d.interface();  // 输出 "Derived::impl"

    Logger l;
    l.log("hello");          // [lvalue]
    std::move(l).log("bye"); // [rvalue]
    return 0;
}

2.8 演进时间线总览

timeline
    title C++ 模板元编程演进时间线
    1989 : Stroustrup 构想模板
    1991 : Cfront 3.0 首次实现
    1994 : Erwin Unruh 发现图灵完备性
    1995 : Coplien 命名 CRTP
         : Veldhuizen 提出 Expression Templates
         : Myers 提出 traits 技术
    1998 : C++98 标准确立模板与 STL
    2001 : Alexandrescu《Modern C++ Design》
    2003 : Veldhuizen 证明模板图灵完备
    2011 : C++11 可变参数模板与 type_traits
    2014 : C++14 变量模板与 constexpr 增强
    2017 : C++17 折叠表达式与 constexpr if
         : void_t 标准化
    2020 : C++20 Concepts 入标
    2023 : C++23 Deducing this 入标

第 3 章 形式化定义

本章从数学与形式语言的角度定义模板元编程的核心概念，建立后续章节的严密基础。

3.1 模板的图灵完备性

定理（Veldhuizen, 2003）：C++ 模板系统是图灵完备的，即对任意部分递归函数 $f: \mathbb{N} \to \mathbb{N}$，存在 C++ 模板元程序 $M_f$ 在编译期计算 $f$。

证明思路：通过将无界 λ 演算编码到模板系统中：

1. 自然数编码：用 template<int N> struct Nat {}; 表示丘奇数；
2. 后继函数：template<int N> struct Succ { static constexpr int value = N + 1; };；
3. 条件分支：通过特化 template<bool B, typename T, typename F> struct If; 实现；
4. 递归：通过模板递归实例化实现，递归终止通过特化定义；
5. 最小化算子（μ 算子）：通过深度递归搜索实现。

由于无界 λ 演算图灵完备，且上述编码可在 C++ 模板中完整表达，故 C++ 模板图灵完备。

注意：图灵完备是「理论上」的结论，实际编译器对递归深度（如 -ftemplate-depth=900）、编译时间、内存使用有硬性限制。模板元编程的「实际计算能力」是受限的。

3.2 类型代数（Type Algebra）

将 C++ 类型集合 $\mathcal{T}$ 视为代数结构，可定义如下运算：

模板可视为类型上的「函数」：给定类型参数返回新类型。这种视角使 TMP 等同于「类型级别的函数式编程」。

// 类型代数的实现
#include <variant>
#include <utility>
#include <type_traits>

// Sum Type: A + B
template<typename A, typename B>
using Sum = std::variant<A, B>;

// Product Type: A × B
template<typename A, typename B>
using Product = std::pair<A, B>;

// 类型函数：将类型 T 映射到类型 List<T>
template<typename T>
struct List {
    struct Node {
        T value;
        Node* next;
    };
    Node* head = nullptr;
};

// 类型函数的「复合」：List<List<T>>
template<typename T>
using ListList = List<List<T>>;

// 类型上的「恒等函数」
template<typename T>
struct Identity { using type = T; };

// 类型上的「常量函数」
template<typename T, typename Ignored>
struct Constant { using type = T; };

// 编译期类型等价性证明
static_assert(std::is_same_v<Identity<int>::type, int>);
static_assert(std::is_same_v<Constant<double, int>::type, double>);

3.3 Type Functions

定义：Type Function 是从类型集合 $\mathcal{T}$ 到 $\mathcal{T}$ 的映射 $F: \mathcal{T} \to \mathcal{T}$，在 C++ 中以类模板形式实现，并通过嵌套 ::type 暴露结果。

// Type Function 示例
#include <type_traits>

// 一元类型函数：移除引用
template<typename T>
struct RemoveReference {
    using type = T;
};

template<typename T>
struct RemoveReference<T&> {
    using type = T;
};

template<typename T>
struct RemoveReference<T&&> {
    using type = T;
};

// 二元类型函数：条件选择
template<bool Cond, typename IfTrue, typename IfFalse>
struct Conditional {
    using type = IfFalse;
};

template<typename IfTrue, typename IfFalse>
struct Conditional<true, IfTrue, IfFalse> {
    using type = IfTrue;
};

// 高阶类型函数：接收类型函数作为参数
template<template<typename> class F, typename T>
struct Apply {
    using type = typename F<T>::type;
};

// 使用
static_assert(std::is_same_v<RemoveReference<int&>::type, int>);
static_assert(std::is_same_v<RemoveReference<int&&>::type, int>);
static_assert(std::is_same_v<Conditional<true, int, double>::type, int>);
static_assert(std::is_same_v<Apply<RemoveReference, int&>::type, int>);

3.4 SFINAE 的形式化语义

设 $\Gamma$ 为模板参数替换上下文，$T$ 为待替换的模板参数，$P(T)$ 为模板参数替换后形成的候选声明。SFINAE 规则可形式化为：

立即上下文（immediate context） 是关键限定：仅当替换失败发生在「函数模板签名本身的构成」中（如返回类型、参数类型、模板参数列表）时，才被 SFINAE 容错。函数体内的错误是硬错误。

// SFINAE 立即上下文示例
#include <type_traits>

// 立即上下文：返回类型中的 SFINAE
template<typename T>
auto f(T x) -> decltype(x.foo(), int{}) {  // 若 x.foo() 不合法，SFINAE 剔除
    return 0;
}

template<typename T>
auto f(T x) -> decltype(x.bar(), int{}) {  // 备选重载
    return 1;
}

// 非立即上下文：函数体内的错误是硬错误
// template<typename T>
// void g(T x) {
//     x.nonexistent();  // 硬错误，不会被 SFINAE 容错
// }

// void_t 的魔法：将类型表达式纳入立即上下文
template<typename, typename = void>
struct has_foo : std::false_type {};

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

struct WithFoo { void foo() {} };
struct WithoutFoo {};

static_assert(has_foo<WithFoo>::value);
static_assert(!has_foo<WithoutFoo>::value);

3.5 Concepts 的形式化语义

C++20 Concept $C$ 可形式化定义为类型上的谓词 $C: \mathcal{T} \to \{true, false\}$，由 requires 表达式的合取范式（CNF）构成：

其中 $R_i$ 是原子约束（atomic constraint），包括：

• 简单概念（如 std::integral<T>）；
• 表达式要求（{ expr } -> Concept;）；
• 类型要求（typename T::value_type;）；
• 嵌套要求（requires Concept<T>;）。

Subsumption（包含）规则：概念 $C_1$ 包含 $C_2$（记作 $C_1 \vdash C_2$），当且仅当 $C_1$ 的原子约束集合在 CNF 上蕴含 $C_2$ 的原子约束集合：

// Concepts subsumption 形式化演示
#include <concepts>

// 原子约束
template<typename T>
concept HasPlus = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

// 合取：C1 = HasPlus && std::copyable<T>
template<typename T>
concept AddableCopyable = HasPlus<T> && std::copyable<T>;

// C1 ⊢ HasPlus（C1 蕴含 HasPlus），故 C1 比 HasPlus 更受约束
// 重载时若两者均匹配，选择 C1 版本

template<typename T>
    requires HasPlus<T>
int priority(T) { return 1; }

template<typename T>
    requires AddableCopyable<T>
int priority(T) { return 2; }  // 优先匹配

// std::signed_integral ⊢ std::integral
template<typename T>
    requires std::integral<T>
void sort_tag(T) {}

template<typename T>
    requires std::signed_integral<T>
void sort_tag(T) {}  // 对 signed_integral 优先匹配

graph TD
    A[Concept C1: A && B && C] --> E[C1 蕴含 C2?]
    B[Concept C2: A && B] --> E
    E -->|原子约束集合包含关系| F{C1 原子约束集 ⊇ C2 原子约束集?}
    F -->|是| G[C1 ⊢ C2<br/>C1 more constrained]
    F -->|否| H[无包含关系<br/>ambiguity if both match]
    G --> I[重载优先选 C1]
    H --> J[编译错误: ambiguous]
    style G fill:#c8e6c9
    style H fill:#ffcdd2

第 4 章 理论推导与复杂度分析

本章从算法复杂度角度分析模板元编程的开销，为工程实践提供决策依据。

4.1 模板实例化复杂度

设模板 $M$ 有 $k$ 个类型参数，每个参数有 $n_i$ 种可能取值，则实例化空间为：

最坏情况下，模板实例化数量随参数数量指数增长。例如，对一个二元运算 template<typename A, typename B> auto op(A, B);，若类型集大小为 $n$，则实例化数为 $n^2$。

实际编译器通过 去重（deduplication） 与 惰性实例化（lazy instantiation） 限制实例化数：仅实例化被实际调用的模板特化。但即便如此，深度组合的模板库（如 Boost.MPL、Eigen）仍可能产生数百 MB 的编译产物。

// 实例化空间演示
#include <type_traits>

// 二元 op：n^2 实例化空间
template<typename A, typename B>
struct BinaryOp {
    using result_type = decltype(std::declval<A>() + std::declval<B>());
};

// 三元 op：n^3 实例化空间
template<typename A, typename B, typename C>
struct TernaryOp {
    using result_type = decltype(
        std::declval<A>() + std::declval<B>() + std::declval<C>()
    );
};

// 用 type_traits 限制实例化爆炸
template<typename A, typename B>
    requires std::is_arithmetic_v<A> && std::is_arithmetic_v<B>
struct SafeBinaryOp {
    using result_type = decltype(std::declval<A>() + std::declval<B>());
};

4.2 编译期递归深度分析

模板元编程的递归通过递归实例化实现，其深度受编译器限制。GCC/Clang 默认 -ftemplate-depth=900，MSVC 默认更浅。

定理：对深度为 $d$ 的递归模板实例化，编译时间 $T(d)$ 满足：

这是因为每一层实例化需要解析、类型推导、模板参数替换，且编译器内部维护的符号表随深度增长。

// 递归深度测量
#include <cstdio>

template<int N>
struct Depth {
    static constexpr int value = Depth<N - 1>::value + 1;
};

template<>
struct Depth<0> {
    static constexpr int value = 0;
};

// 编译期计算：受 -ftemplate-depth 限制
constexpr int result = Depth<500>::value;
// Depth<900>::value 可能触发 "template recursion depth exceeded"

int main() {
    printf("Depth<500>::value = %d\n", result);
    return 0;
}
// 输出：Depth<500>::value = 500

4.3 实例化复杂度的工程边界

工程实践中，控制模板实例化开销的常用策略：

1. extern template：显式实例化声明，避免重复实例化；
2. type erasure：在边界处将模板类型擦除为统一接口；
3. concept 约束：限制实例化空间；
4. 延迟实例化：用 constexpr if 或 SFINAE 避免不必要分支的实例化；
5. 模块化：C++20 模块减少头文件重复解析。

// extern template 演示
// 头文件 myvec.h
template<typename T>
class MyVec {
    // 完整实现
};

// 显式实例化声明：告诉编译器「别处已实例化，不要重复」
extern template class MyVec<int>;
extern template class MyVec<double>;

// 源文件 myvec.cpp
#include "myvec.h"
// 显式实例化定义：在此处生成代码
template class MyVec<int>;
template class MyVec<double>;

4.4 Pattern Matching 与类型计算

模板特化本质是「类型级别的模式匹配」。Hindley-Milner 类型系统的模式匹配在 C++ 中通过以下机制实现：

• 全特化：精确匹配特定类型，等价于模式 pattern -> result；
• 偏特化：匹配类型结构，等价于 pattern<T> -> result<T>；
• 可变参数特化：匹配参数包头部，等价于 head:tail -> ...。

// 类型级别的模式匹配
#include <type_traits>

// 模式：空列表
template<typename List>
struct IsEmpty {
    static constexpr bool value = false;
};

template<>
struct IsEmpty<TypeList<>> {  // 需先定义 TypeList（见后续章节）
    static constexpr bool value = true;
};

// 类型级别的 if-else
template<bool Cond, typename Then, typename Else>
struct TypeIf {
    using type = Then;
};

template<typename Then, typename Else>
struct TypeIf<false, Then, Else> {
    using type = Else;
};

// 类型列表（前向声明）
template<typename... Ts>
struct TypeList {};

// 使用 TypeIf
static_assert(std::is_same_v<
    TypeIf<true, int, double>::type, int>);
static_assert(std::is_same_v<
    TypeIf<false, int, double>::type, double>);

第 5 章 模板基础：参数化与实例化

本章回顾模板的基础语法与实例化机制，奠定后续高级主题的基础。

5.1 函数模板

#include <iostream>
#include <vector>

// 基础函数模板
template<typename T>
T max_of(T a, T b) {
    return a > b ? a : b;
}

// 模板参数推导
void test_deduction() {
    max_of(1, 2);          // T = int
    max_of(1.0, 2.0);      // T = double
    max_of<int>(1, 2);     // 显式指定
    // max_of(1, 2.0);     // 错误：T 推导冲突
    max_of<double>(1, 2.0);  // 显式指定解决冲突
}

// 多参数模板
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

// 非类型参数
template<int N, typename T>
T scale(T x) {
    return x * N;
}

// 模板模板参数
template<template<typename> class Container, typename T>
Container<T> make_container(T value) {
    Container<T> c;
    c.push_back(value);
    return c;
}

void test_template_template() {
    auto v = make_container<std::vector>(42);  // Container = vector, T = int
    std::cout << v[0] << std::endl;  // 输出 42
}

5.2 类模板

#include <array>
#include <cstddef>

// 类模板
template<typename T, size_t N>
class StaticArray {
    T data_[N]{};
public:
    T& operator[](size_t i) { return data_[i]; }
    const T& operator[](size_t i) const { return data_[i]; }
    constexpr size_t size() const { return N; }

    // 成员函数模板
    template<typename U>
    void fill(const U& value) {
        for (size_t i = 0; i < N; ++i) data_[i] = static_cast<T>(value);
    }
};

// 别名模板
template<typename T>
using Array4 = StaticArray<T, 4>;

// 变量模板
template<typename T>
constexpr size_t bits_per = sizeof(T) * 8;

// 使用
void test_class_template() {
    StaticArray<int, 4> arr;
    arr.fill(42);
    Array4<double> darr;  // 别名
    static_assert(bits_per<int> == 32 || bits_per<int> == 64);
}

5.3 实例化机制

graph TD
    A[模板定义] --> B{使用点}
    B -->|隐式实例化| C[编译器自动推导参数]
    B -->|显式实例化| D[用户提供参数]
    C --> E[替换模板参数]
    D --> E
    E --> F{检查语法合法性}
    F -->|合法| G[生成特化代码]
    F -->|非法| H{是否在立即上下文?}
    H -->|是 SFINAE| I[从重载集移除]
    H -->|否| J[硬错误: 编译失败]
    G --> K[加入待编译队列]
    K --> L[代码生成与链接]
    style G fill:#c8e6c9
    style J fill:#ffcdd2
    style I fill:#fff9c4

// 隐式实例化
template<typename T>
struct Point {
    T x, y;
    T dot(const Point& p) const { return x * p.x + y * p.y; }
};

void test_implicit() {
    Point<int> p1{1, 2};  // 隐式实例化 Point<int>
    p1.dot(Point<int>{3, 4});  // 隐式实例化 dot 成员
    // 注意：未使用的成员函数不会被实例化
}

// 显式实例化定义
template class Point<double>;  // 强制实例化所有成员

// 显式实例化声明
extern template class Point<float>;  // 阻止本翻译单元实例化

int main() {
    Point<float> pf;  // 使用 extern 实例化
    return 0;
}

5.4 两阶段名字查找

C++ 模板的名字查找分两阶段：

1. 第一阶段（定义时）：查找不依赖模板参数的名字（non-dependent names）；
2. 第二阶段（实例化时）：查找依赖模板参数的名字（dependent names）。

#include <iostream>

void f(int) { std::cout << "global f(int)\n"; }

template<typename T>
void g(T x) {
    f(1);           // non-dependent: 第一阶段查找，找到 ::f(int)
    // h(x);        // dependent: 第二阶段查找，需通过 ADL
    f(x);           // dependent: 第二阶段查找 + ADL
}

void f(double) { std::cout << "global f(double)\n"; }  // 在 g 定义后，不会被 g 看到

namespace N {
    struct X {};
    void h(X) { std::cout << "N::h(X)\n"; }
}

void test_two_phase() {
    N::X x;
    g(x);  // h(x) 通过 ADL 找到 N::h
}

5.5 依赖名称与 typename / template 关键字

#include <vector>

template<typename T>
void dependent_example() {
    // typename 必需：告诉编译器 T::value_type 是类型
    typename T::value_type v{};

    // template 必需：告诉编译器 T::begin() 是模板
    T::template begin<int>();
}

// 经典陷阱：依赖类型用作基类
template<typename T>
struct Derived : T::Base {  // 此处 T::Base 被认为是类型，无需 typename
    typename T::Type member;  // 此处需要 typename
};

// 依赖模板用作成员初始化
template<typename T>
struct Holder {
    // T::template Factory<U>() 而非 T::Factory<U>()
    template<typename U>
    static auto make() -> decltype(T::template Factory<U>()) {
        return T::template Factory<U>();
    }
};

第 6 章 模板特化与偏特化

6.1 全特化

#include <string>
#include <iostream>

// 主模板
template<typename T>
struct TypeName {
    static std::string get() { return "unknown"; }
};

// 全特化：int
template<>
struct TypeName<int> {
    static std::string get() { return "int"; }
};

// 全特化：double
template<>
struct TypeName<double> {
    static std::string get() { return "double"; }
};

// 全特化：const char*
template<>
struct TypeName<const char*> {
    static std::string get() { return "const char*"; }
};

void test_full_spec() {
    std::cout << TypeName<int>::get() << "\n";          // "int"
    std::cout << TypeName<double>::get() << "\n";       // "double"
    std::cout << TypeName<char>::get() << "\n";         // "unknown"
}

6.2 偏特化

#include <type_traits>
#include <string>

// 偏特化：指针类型
template<typename T>
struct TypeName<T*> {
    static std::string get() {
        return TypeName<T>::get() + "*";
    }
};

// 偏特化：引用类型
template<typename T>
struct TypeName<T&> {
    static std::string get() {
        return TypeName<T>::get() + "&";
    }
};

// 偏特化：const 修饰
template<typename T>
struct TypeName<const T> {
    static std::string get() {
        return "const " + TypeName<T>::get();
    }
};

// 偏特化：数组
template<typename T, size_t N>
struct TypeName<T[N]> {
    static std::string get() {
        return TypeName<T>::get() + "[" + std::to_string(N) + "]";
    }
};

// 偏特化：函数指针
template<typename R, typename... Args>
struct TypeName<R(*)(Args...)> {
    static std::string get() {
        return TypeName<R>::get() + "(*)(...)";
    }
};

void test_partial_spec() {
    std::cout << TypeName<int*>::get() << "\n";           // "int*"
    std::cout << TypeName<const double>::get() << "\n";   // "const double"
    std::cout << TypeName<int[10]>::get() << "\n";        // "int[10]"
}

6.3 函数模板重载 vs 偏特化

C++ 不允许函数模板偏特化，必须用重载替代：

#include <type_traits>
#include <iostream>

// 错误：函数模板不能偏特化
// template<typename T>
// void f(T*) { ... }  // 这是重载，不是偏特化

// 正确：重载
template<typename T>
void describe(T x) {
    std::cout << "generic: " << x << "\n";
}

// 重载：指针
template<typename T>
void describe(T* p) {
    std::cout << "pointer: " << *p << "\n";
}

// 重载：引用（注意与 T 的歧义）
template<typename T>
void describe_wrapper(T& x) {
    describe(x);  // 委托
}

void test_overload() {
    int x = 42;
    describe(42);    // generic
    describe(&x);    // pointer
}

6.4 SFINAE 与 enable_if 的早期形态

#include <type_traits>
#include <iostream>

// enable_if 作为默认模板参数（最常见）
template<typename T,
         typename = std::enable_if_t<std::is_integral_v<T>>>
T abs_safe(T x) {
    return x < 0 ? -x : x;
}

// enable_if 作为返回类型
template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>
abs_safe(T x) {
    return x < 0 ? -x : x;
}

// enable_if 作为函数参数（少见，但有用）
template<typename T>
void log_value(T x, std::enable_if_t<std::is_integral_v<T>, int> = 0) {
    std::cout << "integral: " << x << "\n";
}

// 错误：仅 enable_if 默认参数差异不构成重载
// template<typename T, typename = enable_if_t<...>> void f(T);
// template<typename T, typename = enable_if_t<...>> void f(T);  // 重定义！

// 正确：通过返回类型差异
template<typename T>
auto f(T) -> std::enable_if_t<std::is_integral_v<T>, int> { return 1; }

template<typename T>
auto f(T) -> std::enable_if_t<std::is_floating_point_v<T>, int> { return 2; }

void test_enable_if() {
    abs_safe(-5);     // 调用整数版本
    abs_safe(-3.14);  // 调用浮点版本
    f(42);            // 返回 1
    f(3.14);          // 返回 2
}

第 7 章 SFINAE 与 enable_if 深度解析

7.1 SFINAE 决策树

graph TD
    A[模板参数替换] --> B{替换是否合法?}
    B -->|合法| C[候选加入重载集]
    B -->|非法| D{发生在哪里?}
    D -->|函数签名/返回类型/参数类型| E[立即上下文]
    D -->|函数体/成员函数定义| F[非立即上下文]
    E --> G[SFINAE: 静默剔除]
    F --> H[硬错误: 编译失败]
    G --> I{是否有其他候选?}
    I -->|是| J[继续重载解析]
    I -->|否| K[错误: 无匹配函数]
    style C fill:#c8e6c9
    style G fill:#fff9c4
    style H fill:#ffcdd2
    style K fill:#ffcdd2

7.2 SFINAE 的多种表达形式

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

// 形式 1：enable_if 作为默认模板参数
template<typename T,
         typename = std::enable_if_t<std::is_default_constructible_v<T>>>
T make_default() { return T{}; }

// 形式 2：enable_if 作为返回类型
template<typename T>
std::enable_if_t<std::is_copy_constructible_v<T>, T>
clone(const T& x) { return T(x); }

// 形式 3：enable_if 作为非类型模板参数
template<typename T,
         std::enable_if_t<std::is_move_constructible_v<T>, int> = 0>
T move_clone(T& x) { return T(std::move(x)); }

// 形式 4：decltype + comma（最常见的「检测表达式」SFINAE）
template<typename T>
auto size(const T& c) -> decltype(c.size(), size_t{}) {
    return c.size();
}

template<typename T>
auto size(const T& arr) -> decltype(sizeof(arr), size_t{}) {
    return sizeof(arr) / sizeof(arr[0]);
}

// 形式 5：void_t 检测内嵌类型
template<typename, 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 {};

// 形式 6：检测成员函数
template<typename, 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 {};

void test_sfinae_forms() {
    static_assert(has_value_type<std::vector<int>>::value);
    static_assert(!has_value_type<int>::value);
    static_assert(has_size<std::vector<int>>::value);
    static_assert(!has_size<int>::value);
}

7.3 高阶 SFINAE：检测任意表达式

#include <type_traits>
#include <utility>

// 检测类型 T 是否支持 a + b
template<typename T, typename U, typename = void>
struct is_addable : std::false_type {};

template<typename T, typename U>
struct is_addable<T, U, std::void_t<
    decltype(std::declval<T>() + std::declval<U>())
>> : std::true_type {};

// 检测类型 T 是否有 begin() 和 end()
template<typename T, typename = void>
struct is_iterable : std::false_type {};

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

// 检测类型 T 是否是std::vector特化
template<typename T>
struct is_vector : std::false_type {};

template<typename T, typename Alloc>
struct is_vector<std::vector<T, Alloc>> : std::true_type {};

// 检测类型 T 是否有静态成员 value
template<typename T, typename = void>
struct has_static_value : std::false_type {};

template<typename T>
struct has_static_value<T, std::void_t<
    decltype(T::value)
>> : std::true_type {};

void test_detection() {
    static_assert(is_addable<int, double>::value);
    static_assert(!is_addable<std::string, int>::value);  // string + int 不合法
    static_assert(is_iterable<std::vector<int>>::value);
    static_assert(!is_iterable<int>::value);
    static_assert(is_vector<std::vector<int>>::value);
    static_assert(!is_vector<int>::value);
}

7.4 SFINAE 友好的 traits 设计

#include <type_traits>
#include <iterator>

// 标准库的 iterator_traits 是 SFINAE 友好设计的典范
// C++20 之前的实现：
template<typename Iter, typename = void>
struct iterator_traits_saf {  // SFINAE 友好版
    // 空：当 Iter 不是迭代器时，无内嵌类型
};

template<typename Iter>
struct iterator_traits_saf<Iter, std::void_t<
    typename Iter::iterator_category,
    typename Iter::value_type,
    typename Iter::difference_type,
    typename Iter::pointer,
    typename Iter::reference
>> {
    using iterator_category = typename Iter::iterator_category;
    using value_type = typename Iter::value_type;
    using difference_type = typename Iter::difference_type;
    using pointer = typename Iter::pointer;
    using reference = typename Iter::reference;
};

// 使用：对非迭代器类型，iterator_traits_saf<T> 不会产生硬错误
struct NotIter {};

static_assert(std::is_same_v<
    iterator_traits_saf<NotIter>::iterator_category,  // 错误：无该成员
    void>);  // 但如果用 SFINAE 检测，会是 false 而非硬错误

第 8 章 C++17 void_t 与 constexpr if

8.1 void_t 的原理与魔法

std::void_t<T> 是一个极简的别名模板：它将任意类型映射到 void。其「魔法」不在于功能，而在于将类型表达式的合法性检查纳入 SFINAE 立即上下文。

#include <type_traits>

// void_t 的标准实现
template<typename...>
using void_t = void;

// 经典用法：检测成员是否存在
template<typename, typename = void>
struct has_type_member : std::false_type {};

template<typename T>
struct has_type_member<T, void_t<typename T::type>>
    : std::true_type {};

// 检测多个成员
template<typename T, typename = void>
struct is_iterator_like : std::false_type {};

template<typename T>
struct is_iterator_like<T, void_t<
    typename T::iterator_category,
    typename T::value_type,
    decltype(*std::declval<T>()),
    decltype(++std::declval<T&>())
>> : std::true_type {};

// void_t 链式检测
template<typename, typename = void>
struct detect : std::false_type {};

template<typename T>
struct detect<T, void_t<
    decltype(std::declval<T>().first()),
    decltype(std::declval<T>().second())
>> : std::true_type {};

8.2 constexpr if：编译期条件分支

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

// constexpr if 替代 SFINAE 进行分支选择
template<typename T>
std::string stringify(const T& value) {
    if constexpr (std::is_same_v<T, std::string>) {
        return value;
    } else if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_pointer_v<T>) {
        return "pointer:" + stringify(*value);
    } else {
        return static_cast<std::string>(value);
    }
}

// 未选中分支不会实例化
template<typename T>
void maybe_push(std::vector<T>& v, const T& value) {
    if constexpr (std::is_default_constructible_v<T>) {
        v.push_back(T{});
    }
    v.push_back(value);
}

// 递归模板终止
template<typename... Args>
void print_all(Args... args) {
    if constexpr (sizeof...(args) > 0) {
        std::cout << sizeof...(args) << " args\n";
        // 折叠表达式处理参数包
        ((std::cout << args << " "), ...);
        std::cout << "\n";
    } else {
        std::cout << "no args\n";
    }
}

void test_constexpr_if() {
    std::cout << stringify(42) << "\n";
    std::cout << stringify(3.14) << "\n";
    std::cout << stringify(std::string("hello")) << "\n";
    print_all(1, 2, 3);
    print_all();
}

8.3 constexpr if vs SFINAE 的工程权衡

第 9 章 C++20 Concepts 深度解析

9.1 Concepts 的四种 requires 形式

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

// 形式 1：简单 requires 表达式
template<typename T>
concept HasPlus = requires(T a, T b) {
    a + b;
};

// 形式 2：复合 requires（约束返回类型）
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

// 形式 3：类型 requires
template<typename T>
concept HasValueType = requires {
    typename T::value_type;
};

// 形式 4：嵌套 requires
template<typename T>
concept NumericContainer = requires {
    typename T::value_type;
    requires std::integral<typename T::value_type>;
};

// 组合：合取与析取
template<typename T>
concept Number = std::integral<T> || std::floating_point<T>;

template<typename T>
concept StrictNumber = Number<T> && !std::same_as<T, bool>;

// 使用
template<HasValueType T>
typename T::value_type first_value(const T& c) {
    return *c.begin();
}

template<NumericContainer C>
auto sum_numeric(const C& c) {
    typename C::value_type s{};
    for (auto& x : c) s += x;
    return s;
}

void test_concepts() {
    std::vector<int> v{1, 2, 3};
    std::cout << sum_numeric(v) << "\n";  // 6
}

9.2 Concepts 的 subsumption 与重载排序

#include <concepts>
#include <iostream>

// 概念层级：integral -> signed_integral -> integral_signed_long
template<typename T>
    requires std::integral<T>
void classify(T) { std::cout << "integral\n"; }

template<typename T>
    requires std::signed_integral<T>
void classify(T) { std::cout << "signed integral\n"; }

// 注意：以下会与第一个构成歧义，因为 std::signed_integral 不一定 ⊢ std::integral
// 实际上 std::signed_integral = std::integral && std::is_signed_v，所以 signed_integral ⊢ integral

template<typename T>
    requires std::integral<T> && (sizeof(T) >= 4)
void classify(T) { std::cout << "large integral\n"; }

void test_subsumption() {
    classify(42);          // int: 候选 1, 2, 3，但 2 与 3 无包含关系 -> 歧义？
    // 实际上 std::signed_integral<int> 与 (integral<int> && sizeof(int)>=4) 无包含关系
    // 故上述 classify(42) 编译错误：ambiguous
}

9.3 Concepts 与 auto

#include <concepts>

// 缩写函数模板
void print(std::integral auto x) { /* ... */ }

// 缩写函数模板（多参数）
auto add(std::integral auto a, std::integral auto b) {
    return a + b;
}

// 缩写函数模板与可变参数
void print_all(std::convertible_to<std::string> auto... args) {
    // 折叠表达式
    // ((std::cout << args << " "), ...);
}

// Concepts 约束的类模板参数推导（CTAD）
template<typename T>
struct Wrapper {
    T value;
    Wrapper(T v) : value(v) {}
};

// C++20 起，CTAD 自动推导
Wrapper w{42};  // Wrapper<int>

// 用 Concepts 约束 CTAD
template<typename T>
    requires std::integral<T>
Wrapper(T) -> Wrapper<T>;

9.4 Concepts 检查流程

graph TD
    A[模板使用] --> B[推导模板参数]
    B --> C{有 Concepts 约束?}
    C -->|否| D[直接实例化]
    C -->|是| E[计算约束的原子约束集]
    E --> F{所有原子约束满足?}
    F -->|是| G[加入重载集]
    F -->|否| H[从重载集剔除]
    G --> I{有多个候选?}
    I -->|是| J[subsumption 排序]
    I -->|否| K[选择唯一候选]
    J --> L{有最受约束者?}
    L -->|是| K
    L -->|否| M[错误: 歧义]
    K --> D
    style K fill:#c8e6c9
    style M fill:#ffcdd2

9.5 Concepts 标准库概览

#include <concepts>
#include <iterator>
#include <ranges>

// 核心语言概念
static_assert(std::same_as<int, int>);
static_assert(std::derived_from<std::true_type, std::integral_constant<int, 1>>);

// 比较概念
static_assert(std::equality_comparable<int>);
static_assert(std::totally_ordered<double>);

// 对象概念
static_assert(std::default_initializable<int>);
static_assert(std::movable<std::string>);
static_assert(std::copyable<std::string>);
static_assert(std::regular<int>);
static_assert(std::semiregular<std::string>);

// 可调用概念
static_assert(std::invocable<decltype([](int){ return 0; }), int>);
static_assert(std::predicate<decltype([](int x){ return x > 0; }), int>);

// 迭代器概念
static_assert(std::input_iterator<std::vector<int>::iterator>);
static_assert(std::random_access_iterator<std::vector<int>::iterator>);
static_assert(std::contiguous_iterator<std::vector<int>::iterator>);

// 范围概念
static_assert(std::ranges::range<std::vector<int>>);
static_assert(std::ranges::random_access_range<std::vector<int>>);
static_assert(std::ranges::sized_range<std::vector<int>>);

第 10 章 可变参数模板与折叠表达式

10.1 参数包基础

#include <tuple>
#include <iostream>

// 类模板参数包
template<typename... Ts>
struct Tuple {};

// 函数模板参数包
template<typename... Args>
void print(Args... args) {
    // sizeof... 获取包大小
    std::cout << "size: " << sizeof...(args) << "\n";
}

// 模板参数包 + 类型参数
template<typename T, typename... Rest>
struct Head {
    using type = T;
};

// 使用
void test_packs() {
    Tuple<int, double, char> t;
    print(1, 2.0, "hello");  // size: 3
    print();                  // size: 0
    static_assert(std::is_same_v<Head<int, double, char>::type, int>);
}

10.2 折叠表达式

C++17 折叠表达式有四种形式：

// 一元右折叠：(pack op ...)
template<typename... Args>
auto sum_r(Args... args) {
    return (args + ...);  // arg1 + (arg2 + (arg3 + ...))
}

// 一元左折叠：(... op pack)
template<typename... Args>
auto sum_l(Args... args) {
    return (... + args);  // ((arg1 + arg2) + arg3) + ...
}

// 二元右折叠：(pack op ... op init)
template<typename... Args>
auto sum_init_r(Args... args) {
    return (args + ... + 0);  // arg1 + (arg2 + (... + 0))
}

// 二元左折叠：(init op ... op pack)
template<typename... Args>
auto sum_init_l(Args... args) {
    return (0 + ... + args);  // ((0 + arg1) + arg2) + ...
}

// 折叠与不同运算符
template<typename... Args>
bool all_true(Args... args) {
    return (... && args);  // 全部为真
}

template<typename... Args>
bool any_true(Args... args) {
    return (... || args);  // 任一为真
}

template<typename... Args>
auto comma_all(Args... args) {
    return (args , ...);  // 逗号折叠，返回最后一个
}

// 折叠与函数调用
template<typename F, typename... Args>
void for_each(F f, Args... args) {
    ((void)f(args), ...);  // 对每个参数调用 f
}

void test_fold() {
    std::cout << sum_r(1, 2, 3, 4) << "\n";   // 10
    std::cout << sum_init_r() << "\n";          // 0（空包）
    std::cout << all_true(true, true, false) << "\n";  // 0

    for_each([](auto x) { std::cout << x << " "; }, 1, 2.0, "hello");
    // 输出: 1 2 hello
}

10.3 折叠表达式的形式语义

折叠表达式等价于函数式编程中的 foldr / foldl：

一元折叠要求参数包非空（除 &&、||、, 外），二元折叠可处理空包。

10.4 可变参数模板与 std::tuple

#include <tuple>
#include <utility>
#include <iostream>

// 编译期遍历 tuple
template<typename Tuple, typename F, size_t... Is>
void for_each_impl(Tuple&& t, F&& f, std::index_sequence<Is...>) {
    ((void)std::forward<F>(f)(std::get<Is>(std::forward<Tuple>(t))), ...);
}

template<typename... Args, typename F>
void for_each_tuple(const std::tuple<Args...>& t, F&& f) {
    for_each_impl(t, std::forward<F>(f),
                  std::index_sequence_for<Args...>{});
}

// 编译期选择 tuple 元素
template<size_t I, typename... Args>
auto select(const std::tuple<Args...>& t) {
    return std::get<I>(t);
}

// 类型级折叠：所有类型相同
template<typename... Args>
struct all_same;

template<typename T>
struct all_same<T> : std::true_type {};

template<typename T, typename... Rest>
struct all_same<T, T, Rest...> : all_same<T, Rest...> {};

template<typename T, typename U, typename... Rest>
struct all_same<T, U, Rest...> : std::false_type {};

// C++17 折叠版本
template<typename... Args>
constexpr bool all_same_v = (std::is_same_v<Args, Args> && ...);  // 不对
// 正确写法：需要第一个类型作为基准
template<typename First, typename... Rest>
constexpr bool all_same_v2 = (std::is_same_v<First, Rest> && ...);

void test_variadic() {
    auto t = std::make_tuple(1, 2.0, "hello");
    for_each_tuple(t, [](auto x) { std::cout << x << " "; });
    // 输出: 1 2 hello

    static_assert(all_same<int, int, int>::value);
    static_assert(!all_same<int, double, int>::value);
}