C++ 模板初阶：泛型编程基础

缺点很明显：

1. 代码重复：每个类型都要写一遍几乎相同的逻辑。
2. 扩展性差：如果要支持新类型（如 char），必须手动添加新重载。
3. 维护困难：修改算法（比如改为返回较小值）需要改动所有重载函数。

2. 模板方法：函数模板

模板允许将类型作为参数，编译器会根据调用时传入的具体类型生成对应的代码。

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T max(T a, T b) {
    cout << "template version for " << typeid(T).name() << "\n";
    return a > b ? a : b; // 要求 T 支持 operator>
}

int main() {
    cout << max(3, 5) << "\n";          // T = int
    cout << max(3.14, 2.7) << "\n";     // T = double
    cout << max("hello", "world") << "\n"; // T = string
    cout << max('a', 'b') << "\n";      // T = char
    return 0;
}

优点：

1. 一份代码适用于所有类型，只要该类型支持 operator>。
2. 无需单独编写，维护成本低。
3. 效率相同：编译器生成的代码与手写重载效率一致。

二、函数模板详解

1. 概念与定义

函数模板代表了一个函数家族，在使用时被参数化。定义以 template 关键字开头，后跟模板参数列表。

语法要点：

• 使用 template <class T> 或 template <typename T>。
• T 是占位符，可自定义名称，但不能用 struct 代替 class。
• 多个模板参数时用逗号分隔，例如 template<class T1, class T2>。

示例：交换两个数

#include <iostream>
using namespace std;

template<class T>
void Swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int m = 10, n = 20;
    double a = 1.2, b = 2.5;
    Swap(m, n);
    Swap(a, b);
    return 0;
}

2. 实例化机制

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

隐式实例化

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

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

int main() {
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);   // T 推导为 int
    Add(d1, d2);   // T 推导为 double
    return 0;
}

注意： 如果只有一个模板参数，传入两个不同类型会报错。

int main() {
    int a1 = 10;
    double d1 = 3.14;
    Add(a1, d1); // 编译报错：无法确定 T 是 int 还是 double
    return 0;
}

原因： 编译器看到 Add(a1, d1) 时，通过 a1 将 T 推演为 int，通过 d1 将 T 推演为 double。由于模板参数列表中只有一个 T，冲突导致报错。模板中编译器通常不会进行隐式类型转换，以免掩盖潜在问题。

显式实例化

在函数名后的 <> 中指定模板参数的实际类型。

int main() {
    int a1 = 10;
    double d1 = 3.14;
    
    // 强制指定 T 为 int，d1 会被隐式转换为 int
    Add<int>(a1, d1); 
    
    // 强制指定 T 为 double，a1 会被隐式转换为 double
    Add<double>(a1, d1); 
    return 0;
}

这里告诉编译器：'别推了，就用我指定的类型'。编译器会检查调用是否合法，如果类型不匹配且无法转换，依然会报错。

3. 匹配原则

当存在非模板函数和同名函数模板时，匹配规则如下：

1. 优先调用非模板函数：如果其他条件都相同，优先调用非模板函数。
2. 模板更匹配则选模板：如果模板可以产生一个具有更好匹配的函数，选择模板。

// 专门处理 int 的加法函数
int Add(int left, int right) { return left + right; }

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

void Test() {
    Add(1, 2);       // 与非模板函数匹配
    Add(1, 2.0);     // 模板函数生成更匹配的版本 (T=double)
}

三、类模板

1. 概念与定义

类模板不是具体的类，而是'类的蓝图'。它使用模板参数描述成员的类型。

基本语法：

template<class T>
class Stack {
public:
    void push(const T& x);
    T pop();
private:
    T data[100];
    int top;
};

注意： 成员函数如果在类外定义，必须再次声明模板参数，并使用完整的类名 <T> 限定。

template <typename T>
void Stack<T>::push(const T& x) {
    data[++top] = x;
}

template <typename T>
T Stack<T>::pop() {
    return data[top--];
}

2. 实例化

类模板实例化需要在类名后跟 <>，并将类型放入其中。类名本身不是类型，实例化后的结果才是。

template<class T>
class Stack {
public:
    Stack(int n = 4) : _array(new T[n]), _capacity(n), _size(0) {}
    void Push(const T& x);
    ~Stack() { delete[] _array; }
private:
    T* _array;
    size_t _capacity;
    size_t _size;
};

template<class T>
void Stack<T>::Push(const T& x) {
    if (_size == _capacity) {
        int newcapacity = _capacity * 2;
        T* tmp = new T[newcapacity];
        memcpy(tmp, _array, _capacity);
        delete[] _array;
        _array = tmp;
        _capacity *= 2;
    }
    _array[_size++] = x;
}

int main() {
    Stack<int> st1;      // 整形栈
    st1.Push(1);
    st1.Push(2);
    
    Stack<double> st2;   // 浮点栈
    st2.Push(1.1);
    
    return 0;
}

类模板通常需要显示实例化，不能像函数模板那样完全依赖隐式推导。