模板元编程：SFINAE、enable_if、变参模板、类型萃取

模板元编程，说白了就是让编译器在编译期替你干活。很多人一听「元编程」就觉得高深莫测，其实没那么玄乎。我刚开始接触的时候也犯怵，后来发现它本质上就是一套「编译期计算」的技巧。你想想看，把运行时的工作挪到编译期，程序跑起来自然就快了。

这一章我们聊四个核心概念：SFINAE、enable_if、变参模板、类型萃取。它们就像模板元编程的四大护法，搞懂了它们，你就能写出既灵活又高效的代码。

1. 类型萃取：让编译器帮你做类型判断

类型萃取，英文叫 type_traits。它的作用很简单：在编译期判断类型的属性。比如这个类型是不是整数？是不是指针？有没有拷贝构造函数？

我在项目中遇到过一个问题：写一个通用的序列化函数，需要根据类型选择不同的处理方式。如果是整数，直接写二进制；如果是字符串，要处理长度。用 type_traits 就能优雅解决。

#include <type_traits>
#include <iostream>

template<typename T>
void serialize(const T& value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数类型，直接序列化\n";
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点类型，特殊处理\n";
    } else {
        std::cout << "其他类型，走通用逻辑\n";
    }
}

这里用了 if constexpr，它是 C++17 的特性。说白了就是编译期的 if 判断，条件不成立的分支根本不会实例化。嗯，这里要注意：if constexpr 和 type_traits 是绝配。

2. SFINAE：编译器的「不行就换」机制

SFINAE 的全称是 Substitution Failure Is Not An Error。翻译过来就是：替换失败不是错误。什么意思呢？

编译器在实例化模板时，如果某个重载或特化版本替换后不合法，它不会报错，而是默默把这个版本从候选集中移除，继续找下一个。我个人习惯把这个机制叫做「编译器的备胎策略」。

// 只有整数类型才能调用这个函数
template<typename T>
typename std::enable_if<std::is_integral_v<T>, void>::type
print(T value) {
    std::cout << "整数: " << value << "\n";
}

// 只有浮点类型才能调用这个函数
template<typename T>
typename std::enable_if<std::is_floating_point_v<T>, void>::type
print(T value) {
    std::cout << "浮点数: " << value << "\n";
}

调用 print(42) 时，编译器会尝试两个模板。第二个模板替换后 enable_if 的条件不满足，没有 type 成员，替换失败。但 SFINAE 说：没关系，继续用第一个。最终输出「整数: 42」。

3. enable_if：条件编译的开关

enable_if 是 SFINAE 的经典实现工具。它的原理很简单：如果条件为真，就暴露一个 type 类型；否则啥也没有。

你想想看，这就像个开关。条件满足，门打开，模板实例化通过；条件不满足，门关上，模板被忽略。

// C++11 风格
template<typename T>
typename std::enable_if<std::is_arithmetic_v<T>, T>::type
add(T a, T b) {
    return a + b;
}

// C++14 以后可以用 enable_if_t 简化
template<typename T>
std::enable_if_t<std::is_arithmetic_v<T>, T>
add(T a, T b) {
    return a + b;
}

// C++17 以后更推荐用 if constexpr
template<typename T>
T add(T a, T b) {
    if constexpr (std::is_arithmetic_v<T>) {
        return a + b;
    } else {
        static_assert(false, "不支持非算术类型");
    }
}

我个人更偏爱 if constexpr 的写法，代码更直观。但很多老项目还在用 enable_if，你得能看懂。

4. 变参模板：处理任意数量的参数

变参模板是 C++11 引入的。它让你能写出接受任意数量参数的模板。我记得第一次看到 ... 语法时，心想这玩意儿怎么这么像 C 的变参函数？但变参模板是类型安全的，比 C 的 va_list 强太多了。

// 递归终止函数
void print_all() {
    std::cout << "\n";
}

// 变参模板
template<typename T, typename... Args>
void print_all(T first, Args... rest) {
    std::cout << first << " ";
    print_all(rest...);
}

// 调用
print_all(1, 2.5, "hello", 'c');

这里的关键是递归展开。每次调用取出第一个参数，剩下的继续递归。直到参数包为空，调用终止版本。

template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 一元右折叠
}

template<typename... Args>
void print_all(Args... args) {
    ((std::cout << args << " "), ...);  // 逗号表达式折叠
}

5. 综合实战：一个类型安全的工厂函数

把上面这些技术结合起来，就能写出很强大的代码。下面是一个类型安全的工厂函数，它只允许构造可拷贝构造的类型，并且支持任意参数。

#include <type_traits>
#include <memory>

template<typename T, typename... Args>
std::enable_if_t<std::is_copy_constructible_v<T>, std::unique_ptr<T>>
create(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...);
}

// 使用
struct MyClass {
    MyClass(int, double) {}
    MyClass(const MyClass&) = default;
};

auto obj = create<MyClass>(42, 3.14);  // 编译通过

struct NoCopy {
    NoCopy(int) {}
    NoCopy(const NoCopy&) = delete;
};

// auto obj2 = create<NoCopy>(10);  // 编译错误！NoCopy 不可拷贝

这个例子用到了 enable_if 做条件过滤，变参模板做参数转发，type_traits 做类型检查。你看，四个技术完美配合。

6. 知识体系总览

下面这张图把本章的核心逻辑串起来了。我画图时习惯把「编译期」和「运行期」分开，这样思路更清晰。

7. 避坑指南

模板元编程虽然强大，但坑也不少。我把自己踩过的坑分享给你：

• 编译错误信息难读：模板实例化失败时，编译器能给你吐出一屏错误。我的经验是：从第一个错误开始看，往往就是根因。
• 不要滥用：能用普通函数解决的问题，别硬上模板元编程。代码可读性也是性能的一部分。
• 注意编译时间：复杂的模板元编程会显著增加编译时间。我见过一个项目，改一行代码要编译 5 分钟，就是因为模板嵌套太深。
• if constexpr 不是万能的：它只能用于函数模板内部，不能用于类模板的成员选择。

模板元编程是 C++ 高性能编程的进阶之路。刚开始可能会觉得别扭，但用多了你会发现，它让代码既灵活又高效。嗯，多写多练，慢慢就上手了。