C++ 模板入门：从函数重载到泛型编程

函数模板：通用函数的实现方案

1. 函数模板概念

函数模板代表一个函数家族，它与类型无关，在使用时通过'参数化'（指定类型），生成对应类型的具体函数。

2. 函数模板的格式

template <typename T1, typename T2, ..., typename Tn>
返回值类型 函数名 (参数列表) { }

• template：声明'这是模板'的关键字。
• typename：定义模板参数的关键字（也可以用 class，但不能用 struct）。
• T1, T2...：模板参数（相当于'类型占位符'，后续用具体类型替换）。

下面我们用函数模板重写 Swap：

// 通用交换模板（支持所有可赋值类型）
template <typename T>
void Swap(T& left, T& right) {
    // 参数类型用 T 表示
    T temp = left;
    left = right;
    right = temp;
}

这样一来，不管是 int、double 还是 char，一个模板就能搞定，再也不用写一堆重载函数！

3. 函数模板的工作原理

很多初学者会误以为'函数模板是一个能处理所有类型的函数'，这是错的。函数模板本身并不是函数，而是一个蓝图。编译器会根据传入的实参类型推演生成特定类型的函数。

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

int main() {
    int i = 1, j = 2;
    double m = 1.1, n = 2.2;
    
    Swap(i, j);   // 调用 1：实参是 int，编译器推演 T=int，生成 Swap(int&, int&)
    Swap(m, n);   // 调用 2：实参是 double，编译器推演 T=double，生成 Swap(double&, double&)
    return 0;
}

我们发现调用的并不是同一个函数，这两个函数是编译器帮我们生成的。编译器的工作流程如下：

1. 编译阶段：当我们调用模板函数时（比如 Swap(a, b)），编译器先推演模板参数类型。
2. 生成代码：根据推演的类型（比如 int），编译器自动生成一份'处理该类型'的具体函数。
3. 调用函数：最终程序运行时，调用的是编译器生成的具体函数，而非模板本身。

4. 函数模板的实例化（隐式 vs 显式）

'用不同类型调用函数模板'的过程，称为函数模板的实例化。根据'是否手动指定类型'，分为两种方式：

隐式实例化

让编译器根据实参推演模板参数的实际类型。

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

int main() {
    int a1 = 10, a2 = 20;
    double d1 = 10.5, d2 = 20.5;
    
    // 隐式实例化：编译器根据实参类型推演 T
    Add(a1, a2);  // T=int，生成 Add(int, int)
    Add(d1, d2);  // T=double，生成 Add(double, double)
    return 0;
}

注意一个坑：如果实参类型不统一，编译器无法推演 T，会直接报错！比如 Add(a1, d1) 会报错，因为 a1 是 int，d1 是 double，编译器不知道 T 该设为 int 还是 double。编译器不会自动做类型转换（怕出 bug 背锅）。

解决方法有两种：

1. 手动强制类型转换：Add(a1, (int)d1)。
2. 使用显式实例化。

显式实例化

手动指定类型。我们在函数名后加 <类型>，直接指定模板参数 T 的具体类型。

int main() {
    int a = 10;
    double b = 20.5;
    
    // 显式实例化：指定 T=int，编译器会尝试将 b 转为 int
    Add<int>(a, b);  // 结果是 30（20.5 被截断为 20）
    
    // 也可以指定 T=double，将 a 转为 double
    Add<double>(a, b); // 结果是 30.5
    return 0;
}

如果类型无法转换（比如 Add(a, "hello")），编译器会直接报错。

5. 模板参数的匹配原则

当'非模板函数'和'同名的函数模板'同时存在时，编译器会怎么选择？记住 3 个原则：

原则 1：非模板函数和模板函数可以共存 模板可以被实例化为与非模板函数完全相同的版本。

// 非模板函数：专门处理 int
int Add(int left, int right) {
    cout << "非模板函数：";
    return left + right;
}

// 函数模板：通用加法
template <class T> T Add(T left, T right) {
    cout << "模板函数：";
    return left + right;
}

void Test() {
    Add(1, 2);           // 调用非模板函数（完全匹配，不用实例化模板）
    Add<int>(1, 2);      // 调用模板实例化的 Add(int, int)（手动指定类型）
}

原则 2：优先调用非模板函数，除非模板匹配更好 如果非模板函数不完全匹配，但模板能生成更匹配的版本，编译器会选择模板。

// 非模板函数：只处理 int
int Add(int left, int right) {
    cout << "非模板函数：";
    return left + right;
}

// 模板函数：支持两种不同类型（T1 和 T2）
template <class T1, class T2> T1 Add(T1 left, T2 right) {
    cout << "模板函数（多参数）：";
    return left + right;
}

void Test() {
    Add(1, 2);           // 非模板完全匹配，调用非模板
    Add(1, 2.5);         // 模板能生成 Add(int, double)，匹配更好，调用模板
}

原则 3：模板不支持自动类型转换，普通函数支持 函数模板的参数类型必须严格匹配（除非显式实例化），但普通函数可以自动做类型转换。

void Test() {
    // 普通函数：int 和 double 可以自动转换（2.5→2）
    Add(1, 2.5);         // 调用非模板 Add(int, int)，结果 3
    
    // 模板函数：T 必须统一，不能自动转换（1 是 int，2.5 是 double）
    Add<>(1, 2.5);       // 错误！无法推演统一的 T
}

类模板：通用类的设计思路

除了函数，类也会有'通用逻辑但不同类型'的场景 —— 比如栈（Stack）、链（LinkedList），既可以存 int，也可以存 double、string。这时就需要类模板。

1. 类模板的定义格式

类模板的定义和函数模板类似，先声明模板参数，再定义类：

template <class T1, class T2, ..., class Tn>
class 类模板名 {
    // 类内成员（成员变量/函数的类型可以用模板参数）
};

以'通用栈'为例，实现一个类模板：

#include <iostream>
using namespace std;

// 类模板：通用栈
template <typename T>
class Stack {
public:
    // 构造函数：默认容量 4
    Stack(size_t capacity = 4) : _array(new T[capacity]), _capacity(capacity), _size(0) {}

    // 成员函数声明
    void Push(const T& data);
    void Pop();
    T& Top();

    ~Stack() {
        delete[] _array;
        _capacity = _size = 0;
    }

private:
    T* _array;          // 指向 T 类型数组的指针
    size_t _capacity;   // 栈的容量
    size_t _size;       // 栈的当前元素个数
};

2. 类模板的成员函数实现

类模板的成员函数如果在类外定义，必须加'模板参数声明'，并且在类名后指定模板参数。

格式：

template <class T>
// 返回值类型 类模板名<T>::成员函数名 (参数列表) {
//     函数逻辑
// }

比如实现 Push 和 Top 函数：

// 入栈函数：类外定义
template <class T>
void Stack<T>::Push(const T& data) {
    // 简单扩容逻辑（省略判断，实际项目需完善）
    if (_size == _capacity) {
        T* newArray = new T[_capacity * 2];
        for (size_t i = 0; i < _size; ++i) {
            newArray[i] = _array[i];
        }
        delete[] _array;
        _array = newArray;
        _capacity *= 2;
    }
    // 存入数据
    _array[_size++] = data;
}

// 获取栈顶函数：类外定义
template <class T>
T& Stack<T>::Top() {
    // 实际项目需判断栈是否为空
    return _array[_size - 1];
}

3. 类模板的实例化（关键区别）

类模板的实例化和函数模板完全不同：

• 函数模板支持隐式实例化（编译器推演类型）。
• 类模板必须显式实例化 —— 因为编译器无法从构造函数的参数推断模板参数（比如 Stack s(10)，不知道 T 是 int 还是 double）。

格式：类模板名<具体类型> 对象名 (构造参数)

int main() {
    // 显式实例化：Stack<int>是真正的类类型，st1 是该类型的对象
    Stack<int> st1;      // 存储 int 类型的栈
    st1.Push(10);
    st1.Push(20);
    cout << "栈顶：" << st1.Top() << endl; // 输出 20

    // 显式实例化：存储 double 类型的栈
    Stack<double> st2;
    st2.Push(3.14);
    st2.Push(6.28);
    cout << "栈顶：" << st2.Top() << endl; // 输出 6.28

    // 错误写法：类模板不能隐式实例化
    // Stack st3; // 编译器不知道 T 是什么类型
    return 0;
}

重要概念：Stack 是类模板名（不是真正的类），Stack<int>、Stack<double> 才是真正的类类型 —— 这就像'模具'和'铸件'的区别，模具本身不是产品，铸件才是。

4. 类模板的常见问题：声明与定义分离

很多初学者会把类模板的'声明放在 .h 文件，定义放在 .cpp 文件'，结果编译通过但链接报错。原因是：

1. 编译 .cpp 文件时，编译器不知道用户会用什么类型实例化模板，所以不会生成具体的成员函数实现。
2. 编译使用模板的文件（比如 main.cpp）时，包含 .h 文件只能看到类声明，链接时找不到成员函数的具体实现，导致报错。

解决方案：

1. 将类模板的声明和定义都放在 .h 文件中（推荐，简单直接）。
2. 用 .hpp 文件（专门用于模板，将声明和定义合并）。

总结

模板的核心优势：

1. 代码复用：一个模板搞定所有相似类型的逻辑，不用重复写重载 / 重复类。
2. 可维护性：修改逻辑只需改模板，不用改所有派生代码。
3. 类型安全：编译时推演类型，避免运行时类型错误。

初学者必记的注意事项：

1. 函数模板可以隐式实例化（编译器推类型），类模板必须显式实例化（手动指定类型）。
2. typename 和 class 都能定义模板参数，但不能用 struct。
3. 类模板的声明和定义不要分离到 .h 和 .cpp（会报链接错误），建议放同一个 .h 或 .hpp。
4. 函数模板不支持自动类型转换（除非显式实例化），普通函数支持。

模板是 C++ 的核心特性之一，也是 STL（标准模板库）的基石。掌握模板，不仅能写出更优雅的代码，也能更好地理解 STL 的实现原理。