C++ 模板初阶：函数与类模板详解

这种方式的问题很明显：每个类型都要写一遍几乎相同的函数体，扩展性差。如果要支持新类型（如 char），必须添加新重载，修改算法逻辑时还得改动所有重载函数。

模板方法：函数模板

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

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

优点显而易见：一份代码适用于所有类型，只要该类型支持 operator>。维护成本低，且编译器生成的代码效率与手写重载相同。

函数模板详解

概念与定义

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

语法提示：

• 使用 template <class T> 或 template <typename T>。
• T 是占位符，可自定义名称。
• 注意区分 class 和 struct，模板参数中通常用 class 或 typename。

// 示例 1：交换两个数
template<class T>
void Swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

// 示例 2：返回类型也是模板参数
template<class T>
T max(T a, T b) {
    return a > b ? a : b;
}

// 示例 3：多个模板参数
template<class T1, class T2>
void func(const T1& x, const T2& y) {
    cout << x << " " << y << endl;
}

实例化原理

函数模板本身不是函数，而是编译器用来产生特定类型函数的模具。这个过程叫实例化，分为隐式和显式。

1. 隐式实例化 让编译器根据实参推演模板参数的实际类型。

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

注意： 如果只有一个模板参数，传入两个不同类型，编译器无法确定 T 是哪一个，会报错。例如 Add(a1, d1) 会导致编译失败。编译器在模板中通常不会进行隐式类型转换，因为这可能导致歧义。

解决办法：

• 用户强制转换：Add(a1, (int)d1)。
• 显式指定类型：Add<int>(a1, d1)。这会告诉编译器跳过推导，直接使用 int 实例化。此时编译器会检查 d1 是否能转换为 int（可以，会有截断）。

2. 显式实例化 在函数名后的 <> 中直接指定类型。

int main() {
    int a = 10;
    double b = 20.0;
    Add<int>(a, b); // 显式指定 T 为 int
    return 0;
}

匹配原则

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

1. 优先调用非模板函数（如果完全匹配）。
2. 如果模板能产生更好的匹配（如类型更精确），则选择模板。

// 专门处理 int 的加法
int Add(int left, int right) { return left + right; }
// 通用加法模板
template<class T1, class T2> T1 Add(T1 left, T2 right) { return left + right; }

void Test() {
    Add(1, 2);       // 匹配非模板函数
    Add(1, 2.0);     // 匹配模板函数（因为 1 是 int，2.0 是 double，非模板不匹配）
}

类模板

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

定义与实例化

类模板定义必须以 template 开头。类名不能代表类型，必须绑定模板参数才能成为类型。

template <typename 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--];
}

实战示例：动态栈实现

这里演示一个带扩容功能的栈类模板。

template<class T>
class Stack {
public:
    Stack(int n = 4) : _array(new T[n]), _capacity(n), _size(0) {}
    ~Stack() { delete[] _array; }
    
    void 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;
    }

private:
    T* _array;
    size_t _capacity;
    size_t _size;
};

int main() {
    Stack<int> st1;
    st1.Push(1);
    st1.Push(2);
    
    Stack<double> st2;
    st2.Push(1.1);
    st2.Push(1.2);
    
    return 0;
}

类模板都需要显示实例化，不能像函数模板那样通过参数隐式推导。比如 Stack<int> st1; 就是明确的实例化操作。