22、模板进阶：可变参数模板、模板元编程与SFINAE

说实话，模板学到这个阶段，才算真正摸到了C++的「魂」。前面那些基础用法，说白了只是热身。今天聊的三个话题——可变参数模板、模板元编程、SFINAE——是C++模板体系里最硬核的部分。我个人习惯把它们称为「模板三剑客」，掌握了它们，你写出来的代码会完全不一样。

一、可变参数模板：让函数接受任意数量的参数

C++11之前，你想写一个能接受任意数量参数的函数？要么用C风格的...（va_list那套），要么重载一堆版本。两种方式都不优雅。C++11引入的可变参数模板，彻底解决了这个问题。

先看一个最简单的例子：

template<typename... Args>
void print(Args... args) {
    // 这里args是一个参数包
}

typename... Args表示「零个或多个类型参数」，Args... args表示「零个或多个函数参数」。这个语法看着有点怪，但用多了就习惯了。

那怎么展开这个参数包呢？最常用的方式是递归展开：

// 递归终止函数
void print() {
    std::cout << std::endl;
}

// 递归展开
template<typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);  // 每次剥离一个参数
}

调用print(1, 2.5, "hello", 'c')时，编译器会生成四个重载版本，层层剥离，直到参数包为空。我在项目中用这个模式写过日志系统，效果非常好。

template<typename... Args>
void print(Args... args) {
    ((std::cout << args << " "), ...);
    std::cout << std::endl;
}

二、模板元编程：在编译期完成计算

模板元编程（TMP）说白了就是「用模板写程序，让编译器替你算」。你想想看，有些计算如果能在编译期完成，运行时就能省下宝贵的时间。

最经典的例子——编译期计算阶乘：

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

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

// 使用
int main() {
    std::cout << Factorial<5>::value;  // 输出120，编译期就算好了
}

编译器看到Factorial<5>，会递归实例化Factorial<4>、Factorial<3>……直到Factorial<0>。整个过程在编译期完成，生成的二进制里直接就是120这个常量。

我记得有一次做嵌入式开发，需要在编译期计算CRC校验表。用模板元编程写了一个版本，编译后查表代码直接内嵌到二进制里，运行时零开销。那种感觉，嗯，很爽。

三、SFINAE与enable_if：编译期条件选择

SFINAE的全称是「Substitution Failure Is Not An Error」——替换失败不是错误。这句话什么意思呢？

当编译器尝试实例化一个模板时，如果某个替换导致非法代码，编译器不会报错，而是把这个版本从候选集中移除，继续找其他匹配的版本。这个机制非常有用。

举个例子，我想写一个函数，只对整数类型生效：

template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {
    std::cout << "处理整数: " << value << std::endl;
    return value * 2;
}

这里std::enable_if就像一个开关。当T是整数类型时，std::is_integral<T>::value为true，enable_if会暴露一个type成员，函数签名合法。否则，type不存在，替换失败——但编译器不会报错，只是把这个版本移除。

我曾经在写一个序列化库时遇到一个问题：需要为不同类型生成不同的序列化代码。用enable_if配合类型萃取，完美解决了：

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value>::type
serialize(T value) {
    // 直接写入二进制
}

template<typename T>
typename std::enable_if<!std::is_arithmetic<T>::value>::type
serialize(const T& obj) {
    // 递归序列化每个成员
}

四、知识体系总览

下面这张图把今天的内容串起来了：

五、实战：三者结合的例子

光说不练假把式。我们写一个实际点的东西——一个通用的「打印任意容器」函数：

// 判断是否有begin/end成员
template<typename T, typename = void>
struct has_begin_end : std::false_type {};

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

// 对容器类型启用
template<typename Container>
typename std::enable_if<has_begin_end<Container>::value>::type
print_container(const Container& c) {
    std::cout << "[ ";
    for (const auto& elem : c) {
        std::cout << elem << " ";
    }
    std::cout << "]" << std::endl;
}

这个例子用到了SFINAE（enable_if）、类型萃取（void_t、decltype），以及可变参数模板的思想（虽然这里没直接展示）。你想想看，如果没有这些机制，想写出一个能同时处理vector、list、set的通用打印函数，得费多大劲？

好了，今天的内容就到这里。可变参数模板让你能处理任意数量的参数，模板元编程把计算提前到编译期，SFINAE则给了你编译期条件选择的能力。这三者结合起来，你就能写出真正「优雅且高效」的C++代码。