C++11 扩展 - 模板元编程

模板元编程

现代 C++ 的一个进化方向就是在编译时做更多的工作，** 模板元编程（Template Metaprogramming, TMP）** 是 C++ 中一种利用模板机制在编译期进行计算和代码生成的高级技术。它通过模板特化、递归实例化和类型操作，在编译时完成传统运行时才能处理的任务，从而实现零运行时开销的优化。下面我将从核心概念、关键技术、现代发展等方面全面讲解 C++ 模板元编程。

模板元编程最早由 Erwin Unruh 在 1994 年发现，他展示了如何让编译器在错误信息中输出素数序列，随后被 Todd Veldhuizen 和 David Vandevoorde 等人系统化，Todd Veldhuizen 证明了 C++ 模板具有图灵完备性，理论上能执行任何计算任务，它遵循函数式编程范式，模板参数作为不可变数据参与编译期计算

---

模板元编程的核心概念

模板元编程的本质是将计算从运行时转移到编译期，利用编译器作为 "计算引擎" 生成高效代码。其核心思想包括：

1. 编译期计算：所有运算在编译阶段完成，结果直接嵌入最终程序
2. 类型操作：通过模板参数推导和类型萃取（Type Traits）操作类型
3. 递归模板实例化：通过递归展开实现循环和条件逻辑
4. 零运行时开销：结果在编译期确定，不增加程序运行负担

模板元编程基础语法

基本模板结构

模板元编程主要使用类模板（而非函数模板），因为类模板可以包含类型成员和静态成员，再利用模板特化和递归实现复杂逻辑。

template <typename T>
struct MyTemplate {
    using type = T;               // 类型成员
    static const int value = 42;  // 静态成员
};

编译期值计算

最简单的模板元编程是编译期计算阶乘。

template <unsigned int N>
struct Factorial {
    static const unsigned int value = N * Factorial<N - 1>::value;
};

// 终止条件特化
template <>
struct Factorial<0> {
    static const unsigned int value = 1;
};

int main()
{
    constexpr unsigned int fact5 = Factorial<5>::value; // 编译时计算出120
    return 0;
}

编译期类型计算

编译时获取或修改类型信息的操作。

#include <iostream>
using namespace std;

namespace bit
{
    // 主模板
    template <typename T>
    struct is_pointer {
        static constexpr bool value = false;
    };

    // 针对指针类型的偏特化
    template <typename T>
    struct is_pointer<T*> {
        static constexpr bool value = true;
    };

    // 主模板，默认情况类型不同
    template <typename T, typename U>
    struct is_same {
        static constexpr bool value = false;
    };

    // 特化版本，当两个类型相同时
    template <typename T>
    struct is_same<T, T> {
        static constexpr bool value = true;
    };

    // 移除 const
    // 主模板，默认情况下不改变类型
    template <typename T>
    struct remove_const {
        using type = T;
    };

    // 针对 const T 的特化版本，移除 const
    template <typename T>
    struct remove_const<const T> {
        using type = T;
    };

    // 移除指针
    template <typename T>
    struct remove_pointer {
        using type = T;
    };

    template <typename T>
    struct remove_pointer<T*> {
        using type = T;
    };

    template <typename T>
    struct remove_pointer<T* const> {
        using type = T;
    };

    void func()
    {
        static_assert(is_pointer<int*>::value, "int* is a pointer");
        // static_assert(bit::is_pointer<int>::value, "int is not a pointer");

        static_assert(is_same<int, int>::value, "int and int should be the same");
        // static_assert(is_same<int, float>::value, "int and float should be different");

        static_assert(is_same<remove_pointer<int*>::type, int>::value, "int and int should be the same");
        static_assert(is_same<remove_const<const int>::type, int>::value, "int and int should be the same");
    }
}

int main()
{
    bit::func();
    return 0;
}

这其实也是 C++ 元编程底层的简单实现了，就是模板+特化！

类型萃取（type_traits）

类型萃取是 C++ 模板元编程中的核心技术，它允许在编译时检查和修改类型特性。

C++11 版本开始标准库在<type_traits>头文件中提供了大量类型萃取工具。类型萃取是通过模板特化技术实现的编译期类型操作，主要用途包括：检查类型特性 、修改 / 转换类型 、根据类型特性进行编译期分支 。

🔗 参考文档：https://en.cppreference.com/w/cpp/header/type_traits

---

标准库常见的类型萃取

#include <type_traits>

// 1. 基础类型检查
std::is_void<void>::value;          // true
std::is_integral<int>::value;       // true
std::is_floating_point<float>::value; // true
std::is_pointer<int*>::value;       // true
std::is_reference<int&>::value;     // true
std::is_const<const int>::value;    // true

// 2. 复合类型检查
std::is_function<void()>::value;    // true
std::is_member_object_pointer<int (Foo::*)>::value; // true
std::is_compound<std::string>::value; // true（非基础类型）

// 3. 类型关系检查
std::is_base_of<Base, Derived>::value; // 取决于平台
std::is_convertible<From, To>::value;

// 4. 类型修改
std::add_const<int>::type;          // const int
std::add_pointer<int>::type;        // int*
std::add_lvalue_reference<int>::type; // int&
std::remove_const<const int>::type; // int
std::remove_pointer<int*>::type;    // int
std::remove_reference<int&>::type;  // int

// 5. 条件类型选择
std::conditional<true, int, float>::type; // int
std::conditional<false, int, float>::type; // float

// 6. 函数的返回结果类型
std::result_of<F(Args...)>::type;   // C++17以后被废弃
std::invoke_result<F, Args...>::type; // C++17以后使用这个

---

C++17 为类型萃取添加了_v和_t后缀的便利变量模板和类型别名

// C++11方式
std::is_integral<int>::value;
std::remove_const<const int>::type;

// C++14、C++17 更简洁的方式
std::is_integral_v<int>;
std::remove_const_t<const int>;

// C++17 引入的辅助变量模板
template <typename T>
inline constexpr bool is_integral_v = is_integral<T>::value;

// C++14 引入的辅助别名模板
template <typename T>
using remove_const_t = typename remove_const<T>::type;

---

类型萃取库的一些使用样例展示

#include <iostream>
// using namespace std;

template <typename T>
void process(T value) {
    if constexpr (std::is_pointer_v<T>) {
        // 指针类型的处理
        std::cout << "Processing pointer: " << *value << std::endl;
    }
    else if constexpr (std::is_integral_v<T>) {
        // 整数类型的处理
        std::cout << "Processing integer: " << value * 2 << std::endl;
    }
    else if constexpr (std::is_floating_point_v<T>) {
        // 浮点类型的处理
        std::cout << "Processing float: " << value / 2.0 << std::endl;
    }
    else {
        // 默认处理
        std::cout << "Processing unknown type" << std::endl;
    }
}

#if defined(_WIN32)
#include <winsock2.h>
using socket_t = SOCKET;
#else
using socket_t = int;
#endif

template <typename T>
void close_handle(T handle) {
    if constexpr (std::is_same_v<T, SOCKET>) {
        closesocket(handle);
    }
    else {
        close(handle);
    }
}

int main()
{
    int i = 42;
    process(&i);      // Processing pointer: 42
    process(42);      // Processing integer: 84
    process(3.14f);   // Processing float: 1.57
    process("hello"); // Processing unknown type

    return 0;
}

if constexpr 是 C++17 引入的编译期条件分支语句，它的判断逻辑在程序编译阶段就完成，而非运行时。编译器会根据条件表达式的真假（必须是编译期可确定的常量表达式），只保留分支中有效的代码，直接丢弃无效分支的代码（不会对无效分支进行完整的语法检查和编译）。

这段代码是模板函数，处理的类型 T 是编译期才确定的，而不同分支针对的类型操作具有类型依赖性------ 某些操作只对特定类型有效，对其他类型则是非法语法。

如果使用普通 if，即使某个分支在运行时永远不会执行，编译器也会对所有分支的代码进行完整编译和语法检查，从而导致编译错误：

1. 当 T 是 int（整数类型）时，std::is_pointer_v<T> 为 false，但普通 if 仍会检查 *value（解引用操作），而 int 类型无法被解引用，直接编译报错；
2. 当 T 是 int*（指针类型）时，std::is_integral_v<T> 为 false，但普通 if 仍会检查 value * 2（乘法操作），而指针类型的乘法（除了与整数常量相乘）是非法语法，同样编译报错；
3. 对于 close_handle 函数，当非 Windows 平台编译时，SOCKET 类型未定义，普通 if 会检查 closesocket(handle)，导致未定义标识符的编译错误。

而 if constexpr 会在编译期直接丢弃无效分支，只编译有效分支的代码，从根源上避免了这类 "类型不匹配" 的编译错误，让模板函数能够兼容多种不同类型的处理逻辑。

1. 无运行时判断开销 ：普通 if 的条件判断是在程序运行时执行的，即使条件结果是固定的，也会产生对应的判断指令和分支跳转开销；而 if constexpr 的判断在编译期完成，最终生成的可执行文件中只包含有效分支的代码，没有任何多余的条件判断和分支跳转，实现了 "零运行时开销"，这符合 C++ "按需编译、追求高效" 的设计理念。
2. 生成更精简的目标代码：无效分支的代码被直接丢弃，不会进入最终的目标文件（.o/.obj），减少了程序的体积，同时也避免了无效代码可能带来的优化干扰，让编译器能够更好地对有效代码进行优化。

---

类型萃取在 STL 中的一些应用示例

// 类型萃取在STL中一些原理分析及应用
#include <cassert>
#include <vector>

namespace bit {
    struct input_iterator_tag {};
    struct output_iterator_tag {};
    struct forward_iterator_tag : public input_iterator_tag {};
    struct bidirectional_iterator_tag : public forward_iterator_tag {};
    struct random_access_iterator_tag : public bidirectional_iterator_tag {};

    template <class Iterator>
    struct iterator_traits {
        typedef typename Iterator::iterator_category iterator_category;
        typedef typename Iterator::value_type        value_type;
        typedef typename Iterator::difference_type   difference_type;
        typedef typename Iterator::pointer           pointer;
        typedef typename Iterator::reference         reference;
    };

    template <class T>
    struct iterator_traits<T*> {
        typedef random_access_iterator_tag iterator_category;
        typedef T                          value_type;
        typedef ptrdiff_t                 difference_type;
        typedef T*                        pointer;
        typedef T&                        reference;
    };

    template <class InputIterator>
    inline typename iterator_traits<InputIterator>::difference_type
    distance(InputIterator first, InputIterator last, input_iterator_tag) {
        typename iterator_traits<InputIterator>::difference_type n = 0;
        while (first != last) {
            ++first;
            ++n;
        }
        return n;
    }

    template <class RandomAccessIterator>
    inline typename iterator_traits<RandomAccessIterator>::difference_type
    distance(RandomAccessIterator first, RandomAccessIterator last, random_access_iterator_tag) {
        return last - first;
    }

    template <class InputIterator>
    inline typename iterator_traits<InputIterator>::difference_type
    distance(InputIterator first, InputIterator last) {
        return distance(first, last, typename iterator_traits<InputIterator>::iterator_category());
    }

    template <class T>
    class vector {
    public:
        typedef T* iterator;
        // ...

        // 模板的成员函数，也可以是一个函数模板
        template <class InputIterator>
        void resize(InputIterator first, InputIterator last) {
            // 为了提高效率可以做一些优化
            // 这里InputIterator是模板参数，随机迭代器支持减计算个数
            // 单向/双向迭代器只能逐一计数个数
            reserve(distance(first, last));
            while (first != last) {
                push_back(*first);
                ++first;
            }
        }

    private:
        void reserve(size_t n) {
            // ...
        }
        iterator begin() { return nullptr; }
        iterator end() { return nullptr; }
        // ...
    };
}

int main()
{
    std::string str("hello world");
    bit::vector<char> v1(str.begin(), str.end());
    std::list<int> lt(100, 1);
    bit::vector<int> v2(lt.begin(), lt.end());

    return 0;
}

想理解这段 STL 源码中类型萃取的本质，核心结论先明确：类型萃取（iterator_traits 为例）一点不稀奇，它就是模板主模板 + 模板特化 + 内嵌类型 / 成员的组合运用，是 C++ 模板基础特性的常规拼接，而非什么高深的 "黑科技"。下面我们结合代码详细拆解，帮你看清它的本质：

这段代码中的 iterator_traits（迭代器类型萃取），是类型萃取的典型代表，它的实现完全依赖 C++ 模板的基础特性，没有任何额外的特殊语法，拆解如下：

1. 第一步：主模板 ------ 定义 "统一的萃取接口"，本质是普通类模板

template <class Iterator>
struct iterator_traits {
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::value_type        value_type;
    typedef typename Iterator::difference_type   difference_type;
    typedef typename Iterator::pointer           pointer;
    typedef typename Iterator::reference         reference;
};

这就是一个普通的类模板，没有任何特殊之处：

• 它的作用是定义一套 "统一的类型萃取接口"，约定了要萃取迭代器的 5 个核心信息（迭代器类别、值类型、差值类型等）；这个在 STL 中是几乎是每一个迭代器的刚需！
• 内部通过 typedef 定义的内嵌类型成员 ，是萃取的 "输出载体"------ 本质就是在类模板内部定义别名，把迭代器 Iterator 自身的内嵌类型（如 Iterator::iterator_category），封装到 iterator_traits 这个统一的 "萃取容器" 中；
• 这里的 typename 也只是模板编程的基础语法，用于告诉编译器：Iterator::iterator_category 是一个类型，而非静态成员变量，属于模板基础知识点。

简单说，这个主模板就是一个 "通用萃取模板"，针对 "自身带有内嵌类型的迭代器"（如 STL 中的 std::list::iterator、std::string::iterator），做 "原样转发" 的萃取 ------ 把迭代器自己的内嵌类型，封装到统一的 iterator_traits 接口中。

2. 第二步：模板特化 ------ 处理 "特殊情况"，补全萃取的兼容性，本质是模板特化的基础应用

template <class T>
struct iterator_traits<T*> {
    typedef random_access_iterator_tag iterator_category;
    typedef T                          value_type;
    typedef ptrdiff_t                 difference_type;
    typedef T*                        pointer;
    typedef T&                        reference;
};

这是针对 "原生指针（T*）" 的模板偏特化（也可以理解为针对指针类型的全特化变体），同样是 C++ 模板的基础特性，没有任何高深之处：

• 为什么需要它？因为原生指针（如 int*、char*）是 "天然的随机访问迭代器"，但指针是内置类型，不是类 / 结构体，无法像普通迭代器那样定义 iterator_category、value_type 等内嵌类型。如果没有这个特化版本，用 iterator_traits<int*> 萃取原生指针时，会因为找不到 int*::iterator_category 而编译报错；
• 这个特化版本的作用，就是给 "原生指针" 这个特殊对象，"手动补充" 一套符合 iterator_traits 接口规范的内嵌类型 ------ 比如明确原生指针的迭代器类别是 random_access_iterator_tag，值类型是 T，差值类型是 ptrdiff_t；
• 它的实现逻辑和主模板完全一致：依然是通过 typedef 定义内嵌类型成员，只是内嵌类型的值不再来自 "迭代器自身"，而是手动赋予的固定类型，这是模板特化 "针对特殊类型定制逻辑" 的常规用法。

3. 第三步：类型萃取的 "使用"------ 依然是模板 + 内嵌类型的基础访问

这段代码中 distance 函数对 iterator_traits 的使用，也进一步印证了它的普通性：

template <class InputIterator>
inline typename iterator_traits<InputIterator>::difference_type
distance(InputIterator first, InputIterator last) {
    // 访问 iterator_traits 的内嵌类型：iterator_category
    return distance(first, last, typename iterator_traits<InputIterator>::iterator_category());
}

这里的核心操作是 typename iterator_traits<InputIterator>::iterator_category()，本质就是：

1. 通过模板实例化，得到 iterator_traits<InputIterator> 的具体类；
2. 通过 :: 访问类的内嵌类型（iterator_category），并创建该类型的临时对象；
3. 利用函数重载（distance 的两个重载版本，分别接收 input_iterator_tag 和 random_access_iterator_tag），实现 "根据迭代器类型选择高效实现"。

而访问类的内嵌类型，是 C++ 类的基础特性，模板实例化后的类也完全遵循这一规则，没有任何特殊之处。

所以：

1. 核心构成：类型萃取 = 「类模板（主模板）」 + 「模板特化（处理特殊场景）」 + 「内嵌类型 / 静态成员（承载萃取结果）」，三者都是 C++ 模板的基础知识点，没有新增语法，只是组合运用；
2. 核心目的 ：它不是为了 "炫技"，而是为了解决一个实际问题 ------ 提供统一的类型查询 / 提取接口 ，兼容普通迭代器和原生指针等不同类型，让后续的泛型函数（如 distance）可以用统一的逻辑处理不同类型的迭代器，同时实现高效的重载分发；
3. 认知降维：不用把 "类型萃取" 看得高深莫测，它就像用 "模板" 这个基础积木，"特化" 这个辅助积木，"内嵌类型" 这个承载积木，搭出来的一个 "工具模型"，本质是对 C++ 基础模板特性的灵活运用，而非什么全新的高级技术。

简单说，只要你掌握了 C++ 类模板、模板特化、内嵌类型这三个基础知识点，你自己也能写出类似 iterator_traits 的类型萃取工具，这就是它的全部 "秘密"。

SFINAE

SFINAE 是Substitution Failure Is Not An Error的首字母缩写，意思是 "替换失败不是错误"。在模板参数推导或替换时，如果某个候选模板导致编译错误（如类型不匹配、无效表达式等），编译器不会直接报错，而是跳过该候选，尝试其他可行的版本。如果最后都没匹配到合适的版本，再进行报错。

SFINAE 的语法相对复杂难理解，在 C++20 以后，考虑使用 ** 概念（Concepts）** 替代绝大部分的 SFINAE，所以 SFINAE 我们了解一下，后续我们重点学习 C++20 的概念。

---

SFINAE 经典应用场景：函数重载

// 版本1：仅适用于可递增的类型（如 int）
template<typename T>
auto foo(T x) -> decltype(++x, void()) {
    std::cout << "foo(T): " << x << " (can be incremented)\n";
}

// C++17 使用void_t优化上面的写法
// template<typename T>
// auto foo(T x) -> std::void_t<decltype(++x)> {
//     std::cout << "foo(T): " << x << " (can be incremented)\n";
// }

// 版本2：回退版本
void foo(...) {
    std::cout << "foo(...): fallback (cannot increment)\n";
}

int main() {
    foo(42);                 // 调用版本1（int 支持 ++x）
    foo(std::string("111")); // 调用版本2（string 不支持 ++x）
}

这段代码的尾置返回值 decltype(++x, void()) 看起来有点绕，但核心是C++ 基础的逗号表达式，尾置返回值只是承载这个表达式的 "容器"，语法本身没有特殊之处：

逗号表达式的格式是 表达式1, 表达式2, 表达式3, ..., 表达式N，它的执行逻辑有且只有两条：

• 从左到右依次执行所有表达式（每个表达式都会被求值、执行对应的操作）；
• 整个逗号表达式的最终结果（类型 + 值），仅由最后一个表达式决定，前面所有表达式的结果都会被丢弃，只保留最后一个的 "有效信息"。

我们把这个尾置返回值拆开，一步步看它的作用，核心是借助 decltype 推导类型，借助逗号表达式筛选有效模板：

// 尾置返回值完整写法
auto foo(T x) -> decltype(++x, void())

第一步：执行左边的 ++x（关键的 "校验表达式"） 这里的 ++x 不是为了 "修改 x 的值"（实际上在 decltype 中，表达式不会真正执行，只是做类型检查和语法校验 ），它的核心作用是：判断模板参数 T 类型是否支持「前置递增操作」。

• 如果 T 是 int、char 等类型：支持 ++x 操作，语法合法，这一步 "校验通过"；
• 如果 T 是 std::string、const int 等类型：不支持 ++x 操作（std::string 没有前置递增运算符，const int 无法被修改），语法非法，触发「SFINAE 规则」------ 这个模板版本直接被编译器跳过，不会参与重载匹配。

第二步：取右边的 void() 作为最终类型（核心的 "返回值类型载体"） 逗号表达式的最后一个表达式是 void()，它的作用是：给尾置返回值提供一个固定的、无意义的类型（void）。

• decltype(...) 的作用是推导括号内表达式的最终类型，由于逗号表达式的结果由最后一个表达式决定，所以 decltype(++x, void()) 推导的最终类型就是 void；
• 而我们的 foo 函数本身不需要返回有意义的值（函数体内只有打印操作），返回 void 正好符合需求；
• 这里的 void() 可以替换为 void{}，效果完全一致，都是创建一个 void 类型的临时表达式，用于 decltype 推导。

整体逻辑总结（语言演示落地） 当调用 foo(42) 时：

当调用 foo(std::string("111")) 时：

• 模板参数 T 推导为 int，进入尾置返回值校验；
• 先校验 ++42（语法合法，int 支持前置递增）；
• 再通过逗号表达式，取最后一个 void() 的类型，decltype 推导结果为 void；
• 模板校验通过，正常编译，调用版本 1，打印对应信息。
• 模板参数 T 推导为 std::string，进入尾置返回值校验；
• 校验 ++std::string("111")（语法非法，std::string 无前置递增运算符）；
• 触发 SFINAE，这个模板版本被跳过，不参与重载匹配；
• 编译器寻找其他可行版本，匹配到 foo(...) 回退版本，调用并打印对应信息。

补充：尾置返回值的必要性 这里为什么要用尾置返回值（auto -> decltype(...)），而不是直接写 decltype(++x, void()) foo(T x)？因为 ++x 中用到了函数参数 x，而函数参数的声明在括号内，在函数返回值位置（括号前面），编译器还未解析到 x，无法识别 x 的存在，尾置返回值的语法正是为了解决这个问题 ------ 把返回值推导放在函数参数声明之后，让编译器能够识别参数 x，这是尾置返回值的基础用法，并非 SFINAE 专属。

// C++17 替换写法
template<typename T>
auto foo(T x) -> std::void_t<decltype(++x)> {
    std::cout << "foo(T): " << x << " (can be incremented)\n";
}

很多人觉得 std::void_t 是新特性，其实它本质非常简单，就是一个通过 typedef（准确说是 using 类型别名）封装的模板工具，和前面的逗号表达式写法核心逻辑完全一致。

std::void_t 是 C++17 引入的标准库模板，它的定义只有一行，没有任何复杂逻辑：

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

拆解一下这个定义：

• 它是一个变参模板 （typename... Ts），可以接收任意数量、任意类型的模板参数；
• 它通过 using（C++11 起替代 typedef 定义类型别名的更优雅写法），将无论什么模板参数，最终都映射为 void 类型；
• 核心特点：忽略所有输入的模板参数类型，只返回一个固定的 void 类型，这是它的全部功能。

我们对比两种写法，就能发现它们的本质是一致的，只是封装形式不同：

写法	核心步骤	最终结果	核心目的
decltype(++x, void())	1. 校验 ++x 语法合法性；2. 逗号表达式取最后一个 void()，推导为 void	void	校验表达式合法性，返回 void
std::void_t<decltype(++x)>	1. decltype(++x) 校验 ++x 语法合法性并推导类型；2. void_t 忽略该类型，返回 void	void	校验表达式合法性，返回 void

1. 尾置返回值中的 decltype(++x, void())，核心是逗号表达式 ，++x 做语法校验，void() 提供最终类型，decltype 做类型推导，都是 C++ 基础特性；
2. C++17 std::void_t 没有高深之处，就是一个 **using 定义的类型别名模板 **，本质是封装了 "校验表达式 + 返回 void" 的逻辑，和逗号表达式写法等价；
3. 这段代码的核心是 SFINAE 规则，而尾置返回值、逗号表达式、std::void_t 都只是实现 SFINAE 的 "工具"，这些工具本身都是基础语法的组合，没有什么 "稀奇" 的黑科技。

---

std::enable_if：SFINAE 的典型应用

🔗 参考文档：https://en.cppreference.com/w/cpp/types/enable_if

std::enable_if 是一个类型萃取，它的功能和实现具体看上面文档，它是 SFINAE 的典型应用，用于在编译时启用 / 禁用函数模板。

它的核心源码就是下面这几行：：

// 主模板：带默认模板参数
template<bool B, class T = void>
struct enable_if {};

// 偏特化版本：仅当 B = true 时生效
template<class T>
struct enable_if<true, T> { 
    typedef T type; 
};

• 主模板 ：定义了两个模板参数 B（布尔值）和 T（类型，默认是 void）。这个主模板里什么都没有，连 type 这个内嵌类型都没定义。
• 特化版本 ：仅当第一个模板参数 B 为 true 时才会被匹配。这个版本里专门定义了 typedef T type;，也就是提供了一个内嵌类型 type。

#include <type_traits>
#include <iostream>

// 对于整数类型启用此重载
template<typename T>
typename std::enable_if_t<std::is_integral_v<T>, T>
add_one(T t) {
    return t + 1;
}

// 对于浮点类型启用此重载
template<typename T>
typename std::enable_if_t<std::is_floating_point_v<T>, T>
add_one(T t) {
    return t + 2.0;
}

// 模板参数的检查
template<typename T,
         typename = std::enable_if_t<std::is_integral_v<T>>> // 这里不要困惑，就是形参省略不写而已
void process_integer(T value) {
    // 只接受整数类型
}

int main() {
    std::cout << add_one(5) << "\n";     // 调用整数版本，输出6
    std::cout << add_one(3.14) << "\n";  // 调用浮点版本，输出4.14
    // add_one("hello"); // 编译错误，没有匹配的重载

    process_integer(1);
    // process_integer(1.1); // 编译错误，没有匹配的重载
}

第一步：推导模板参数 当你调用 add_one(5) 时，T 被推导为 int。

第二步：计算 std::is_integral_v<T> std::is_integral_v<int> 是编译期常量 true。

第三步：实例化 enable_if 现在 enable_if_t<true, int> 等价于 typename enable_if<true, int>::type。

• 因为 B=true，所以匹配到特化版本 enable_if<true, int>，它有内嵌类型 type，并且 type=int。
• 所以整个返回值类型就推导为 int，模板正常通过。

如果传入浮点数 3.14：

• std::is_integral_v<double> 是 false，此时会匹配主模板 enable_if<false, double>。
• 主模板里没有定义 type，所以 typename enable_if<false, double>::type 会触发编译错误。
• 但根据 SFINAE 规则，这个错误不会直接报错，而是让编译器跳过这个模板，去寻找其他可行的重载版本（比如浮点数版本的 add_one）。

---

核心本质：默认参数 + 模板特化

• 默认参数 ：enable_if 的第二个模板参数 T 有默认值 void，这让你在不需要指定返回类型时可以省略它，比如 enable_if_t<cond> 就等价于 enable_if_t<cond, void>。
• 模板特化 ：只有当 B=true 时，特化版本才会提供 type，否则主模板什么都没有。
• SFINAE ：当 B=false 时，enable_if<B,T>::type 不存在，导致模板替换失败，编译器会跳过这个模板，尝试其他版本。

所以，整个 enable_if 的机制，就是用「默认参数」提供灵活性，用「模板特化」控制 type 的存在与否，再配合 SFINAE 实现编译期的条件启用 / 禁用。

现代 C++ 中对模板元编程特性的增强和优化

---

constexpr 函数（C++11 起）

C++11/14/17/20 逐步增强了constexpr能力，许多模板元编程任务可以用constexpr函数替代，允许函数和变量在编译期求值，替代部分传统模板元编程的递归实例化，constexpr简化了很多相对复杂的模板元编程实现。

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int x = factorial(5); // 120

---

变量模板（C++14）

变量模板直接定义编译期常量值，有了变量模板，类型萃取的一些取值特性就可以简化一些，如is_integral_v等。

template <typename T>
constexpr T pi = T(3.1415926535897932385);

template <class T>
constexpr bool is_integral_v = is_integral<T>::value;

int main() {
    float f = pi<float>;    // 单精度
    double x = pi<double>;   // 双精度

    // 使用不同精度的π
    std::cout.precision(6);
    std::cout << "float π: " << f << std::endl;
    std::cout.precision(10);
    std::cout << "double π: " << x << std::endl;

    return 0;
}

---

if constexpr（C++17）

在编译期根据条件选择代码路径，避免生成无效代码分支，简化 SFINAE 和模板特化的复杂逻辑，提升可读性。

template <typename T>
auto process(T value) {
    if constexpr (std::is_integral_v<T>) {
        return value * 2;
    } else if constexpr (std::is_floating_point_v<T>) {
        return value / 2;
    } else {
        return value;
    }
}

---

折叠表达式（C++17）

简化可变参数模板的参数包展开操作，具体细节在 C++17 章节中讲解。

template <typename... Args>
void print(Args&&... args) {
    (std::cout << ... << args) << '\n';
    // 等价于：((std::cout << arg1) << arg2) << ... << argN;
}

---

概念（C++20）

概念（concept）是 C++20 引入的模板参数约束机制，取代 SFINAE 的复杂约束语法。具体细节在 C++20 章节中细讲。

// 定义一个要求T是整形的概念
template <class T>
concept Integral = std::is_integral_v<T>;

// 1. 模板参数后直接使用
void f1(Integral auto x) {
    std::cout << "有concepts约束" << std::endl;
}

// 2. 模板声明中使用
template <Integral T>
void f2(T x) {
    std::cout << "有concepts约束" << std::endl;
}

---

模块（C++20）

• C++20 引入的模块（Modules）是 C++ 语言的一项重大革新，旨在解决传统头文件包含机制（#include）的诸多问题。其中一个问题就是，每次包含头文件时，编译器都需要重新解析其内容，导致编译时间大幅增加。模块引入以后可以大大缩短编译时间，具体特性我们后面 C++20 再细讲。
• C++20 Modules 代码在 Alibaba Hologres 主线上已稳定运行一年半以上，并减少了 42% 的编译时间。https://xie.infoq.cn/article/5c81d38dcb3949dc0ebb58fa
• 模板元编程的一个重大问题就是让项目的编译时间变长，所以模块的引入可以很好的缓解这个问题。

模板元编程优缺点分析

优点：

1. 零运行时开销：所有计算在编译期完成，运行时无需额外计算，性能达到极致。
2. 类型安全：编译期类型检查，错误在开发阶段就被发现，避免运行时类型错误。
3. 高度抽象：可构建灵活通用的库，通过模板实现与类型无关的泛型逻辑，代码复用性极高。

---

缺点：

1. 编译时间长：复杂的模板实例化会显著增加编译时间，大型项目尤其明显。
2. 学习成本高：许多模板元编程的写法晦涩难懂，需要深入理解模板特化、SFINAE 等复杂机制。
3. 错误信息晦涩：模板错误通常包含大量嵌套的类型信息，难以定位和理解问题根源。
4. 调试困难：编译期计算无法像运行时代码那样通过调试器单步跟踪，问题排查难度大。