C++ 模板编程入门：从零理解泛型核心

示例：使用模板重写 Swap 函数。

#include <iostream>
using namespace std;

template<typename T>
void Swap(T& x, T& y) {
    T tmp = x;
    x = y;
    y = tmp;
}

int main() {
    int a = 1, b = 2;
    cout << "交换前：a:" << a << " b:" << b << endl;
    Swap(a, b); // 编译器实例化 int 版本的 Swap
    cout << "交换后：a:" << a << " b:" << b << endl;

    double c = 1.2, d = 23.1;
    cout << "交换前：c:" << c << " d:" << d << endl;
    Swap(c, d); // 编译器实例化 double 版本的 Swap
    cout << "交换后：c:" << c << " d:" << d << endl;

    return 0;
}

在这个例子中，我们只写了一份 Swap 模板，编译器会根据实参自动实例化出 int 和 double 版本，就像用模具批量生产玩具一样高效。

2. 函数模板的原理

函数模板本身不是函数，它更像是一个蓝图或模具。在编译阶段，编译器根据传入的实参类型推演模板参数，生成具体的函数代码。

例如，当调用 Swap(double, double) 时，编译器将 T 推导为 double，生成处理 double 类型的代码。对于其他类型也是如此，无需手动重复编写。

3. 函数模板的实例化

使用不同类型参数调用函数模板的过程称为实例化，分为隐式实例化和显式实例化。

隐式实例化

隐式实例化不需要程序员指定类型，由编译器根据实参自动推导。上面的 Swap 例子就是典型的隐式实例化。

这种方式很方便，但有时编译器无法确定类型。例如：

#include <iostream>
using namespace std;

template<class T>
T Add(const T& x, const T& y) {
    return x + y;
}

int main() {
    int a = 1;
    double b = 2.2;
    Add(a, b); // 报错：编译器无法推断 T 是 int 还是 double
    return 0;
}

这里传入了两种类型，编译器无法确定 T 是什么。解决思路有三种：强制类型转换、增加模板参数、显式实例化。

// 方法一：强转其中一个参数
Add(a, (int)b);

// 方法二：增加模板参数支持不同输入类型
template<class T1, class T2>
T1 Add(const T1& x, const T2& y) {
    return x + y;
}

虽然前两种方法可行，但在多参数场景下略显繁琐。第三种方法——显式实例化，往往更直接。

显式实例化

显式实例化是在函数名后加尖括号指定类型，明确告诉编译器如何生成代码。

// 方法三：显式指定类型为 int
Add<int>(a, b); // b 会被隐式转换为 int

一般来说，类模板更常涉及显式实例化，但函数模板在类型推导失败时同样适用。

三、类模板

有了函数模板的基础，学习类模板会轻松许多。类模板的定义方式与函数模板类似，只是在类名前加上模板声明。

template<class T1, class T2, ..., class Tn>
class ClassName {
    // 成员定义及实现
};

示例：一个简单的栈类模板。

#include <iostream>
using namespace std;

template<typename T>
class Stack {
public:
    Stack(size_t capacity = 4) {
        _array = new T[capacity];
        _capacity = capacity;
        _size = 0;
    }
private:
    T* _arr;
    size_t _capacity;
    size_t _size;
};

这里数据类型被替换为 T，可以根据需求实例化不同类型的栈。相比 typedef 一次只能替换一个类型，类模板更加灵活强大。

注意： 类模板的实例化不能像函数模板那样隐式推导，必须显式指定类型。

// 错误写法：Stack st; // 编译器不知道 T 是什么
// 正确写法：
Stack<int> st1;   // 实例化为 int 类型的栈
Stack<double> st2; // 实例化为 double 类型的栈

这是因为类对象实例化时没有参数可供推导，所以必须显式告知类型。