模板元编程基础：函数模板与类模板、模板特化与偏特化、变参模板、SFINAE技术

模板元编程，说白了就是让编译器在编译期替你干活。我刚开始接触这个概念时，觉得这东西玄乎得很——代码里没有循环、没有变量，却能完成计算？后来在项目中踩过几次坑，才慢慢摸到门道。今天咱们就从头捋一遍，把模板元编程的底裤扒干净。

一、函数模板与类模板

模板的核心思想很简单：类型参数化。你写一份代码，编译器根据实际传入的类型，帮你生成多份不同的代码。

1. 函数模板

函数模板是最基础的模板形式。我习惯把它看作「编译器版的宏」，但比宏安全得多。

template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 使用
int x = max(3, 5);        // T 被推导为 int
double y = max(3.14, 2.7); // T 被推导为 double

这里有个细节：typename 和 class 在模板参数列表中完全等价。我个人习惯用 typename，因为语义更明确——它表示「这是一个类型名」。

2. 类模板

类模板比函数模板更灵活，可以持有状态（通过非类型模板参数）。

template<typename T, size_t N>
class Array {
    T data[N];
public:
    T& operator[](size_t i) { return data[i]; }
    size_t size() const { return N; }
};

Array<int, 10> arr;  // 编译期确定大小

你想想看，这种写法比运行时动态分配内存高效得多——没有堆分配，没有内存碎片，所有信息在编译期就确定了。

二、模板特化与偏特化

模板特化，就是给某些特定类型开小灶。我把它理解为「编译器版的 if-else」。

1. 全特化

全特化是指为所有模板参数都指定具体类型。

// 通用模板
template<typename T>
struct IsPointer {
    static constexpr bool value = false;
};

// 全特化：T 为指针类型
template<>
struct IsPointer<int*> {
    static constexpr bool value = true;
};

std::cout << IsPointer<int>::value;   // 0
std::cout << IsPointer<int*>::value;  // 1

2. 偏特化

偏特化只指定部分模板参数，或者对参数施加约束。这是模板元编程的杀手锏。

// 通用模板
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;
};

RemoveReference<int&>::type x = 42;  // x 是 int 类型

三、变参模板

变参模板是 C++11 引入的利器，允许模板接受任意数量的参数。说白了，就是「模板版的 ...args」。

// 递归终止条件
void print() {}

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

print(1, 2.5, "hello", 'c');  // 输出: 1 2.5 hello c

这里有个关键点：参数包展开。编译器在编译期递归地生成 print(int, double, const char*, char)、print(double, const char*, char) 等重载版本。我在项目中用这个模式写过日志系统，比 va_args 安全得多——类型安全，没有运行时开销。

C++17 引入了折叠表达式，让变参模板更简洁：

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

std::cout << sum(1, 2, 3, 4);  // 10

四、SFINAE 技术

SFINAE 的全称是 Substitution Failure Is Not An Error（替换失败不是错误）。这名字挺绕口，说白了就是：编译器在实例化模板时，如果某个重载或特化导致编译错误，不会直接报错，而是默默忽略这个候选，继续尝试其他候选。

为什么会这样？因为模板的实例化发生在编译期，如果每次失败都报错，那代码根本没法写。SFINAE 让编译器有了「容错」能力。

1. 经典用法：enable_if

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;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
process(T value) {
    std::cout << "浮点数处理: " << value << std::endl;
    return value * 1.5;
}

process(42);      // 调用第一个版本
process(3.14);    // 调用第二个版本

这里 enable_if 就像一个开关：条件为真时，type 存在，函数可用；条件为假时，type 不存在，函数被 SFINAE 掉。

2. 检测表达式合法性

SFINAE 还可以检测某个类型是否有特定成员：

// 检测是否有 size() 方法
template<typename T>
auto getSize_impl(T& t) -> decltype(t.size(), std::size_t{}) {
    return t.size();
}

// 没有 size() 方法的兜底
std::size_t getSize_impl(...) {
    return 0;
}

template<typename T>
std::size_t getSize(T& t) {
    return getSize_impl(t);
}

std::vector<int> v{1,2,3};
int arr[3];
std::cout << getSize(v);   // 3
std::cout << getSize(arr); // 0

五、知识体系总览

下面这张图把本章的核心知识点串了起来，方便你建立整体认知：

六、避坑指南

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

• 编译错误信息难以阅读——模板实例化深度大时，编译器报错能刷好几屏。我的建议是：用 static_assert 加自定义错误信息，能省很多调试时间。
• 代码膨胀——每个不同的模板参数都会生成一份代码。我曾经在嵌入式项目里滥用模板，结果二进制体积翻了三倍。后来改用类型擦除才解决。
• 递归深度限制——变参模板递归展开有深度限制（通常 256 层）。如果参数太多，编译器会罢工。C++17 的折叠表达式能缓解这个问题。
• SFINAE 的陷阱——decltype 中的表达式如果包含模板，可能会触发「立即上下文」之外的错误，导致 SFINAE 失效。嗯，这个坑我花了两天才爬出来。

好了，模板元编程的基础就聊到这儿。记住一句话：模板是编译期的魔法，但魔法用多了会反噬。掌握好度，才能写出既高效又优雅的 C++ 代码。

---