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

这种写法的问题很明显：每个类型都要写一遍几乎相同的函数体，扩展性差，且维护困难。一旦算法逻辑变更，所有重载都得改。

2. 模板方法：函数模板

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

#include <iostream>
#include <string>
#include <typeinfo>
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>
返回值类型 函数名 (参数列表) {
    // 函数实现
}

注意：typename 和 class 在这里是等价的，都用于定义模板参数。通常习惯用 typename，但 class 也是合法的。

示例：交换函数

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

多模板参数

当有多个模板参数时，可以接受不同类型的实参。

#include <iostream>
using namespace std;

template<class T1, class T2>
void func2(const T1& x, const T2& y) {
    cout << x << " " << y << endl;
}

int main() {
    int a = 10;
    double b = 3.14;
    func2(a, b); // T1=int, T2=double
    return 0;
}

实例化机制

函数模板本身不是函数，而是编译器生成特定类型函数的蓝图。这个过程称为实例化，分为隐式和显式两种。

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 到底是 int 还是 double。

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

解决办法：

1. 用户强制转换类型。
2. 显式指定模板参数。

2. 显式实例化

在函数名后的 <> 中明确指定类型，告诉编译器跳过推导过程。

int main() {
    int a = 10;
    double b = 20.0;
    Add<int>(a, b); // 指定 T 为 int，b 会被隐式转换为 int
    return 0;
}

这里 Add<int> 会生成 int Add(const int&, const int&) 的签名。虽然 b 是 double，但它可以隐式转换为 int，所以调用成功。

匹配原则

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

1. 优先非模板： 如果其他条件相同，优先调用非模板函数。
2. 更好匹配选模板： 如果模板能产生更精确匹配的函数，则选择模板。

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);     // 模板函数生成更匹配的版本
}

类模板

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

定义与外部实现

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

template <typename T>
class Stack {
public:
    void push(const T& x);
    T pop();
private:
    T* _array;
    size_t _capacity;
    size_t _size;
};

// 类外定义成员函数
template <typename T>
void Stack<T>::push(const T& x) {
    if (_size == _capacity) {
        size_t newcapacity = _capacity * 2;
        T* tmp = new T[newcapacity];
        memcpy(tmp, _array, _capacity * sizeof(T));
        delete[] _array;
        _array = tmp;
        _capacity *= 2;
    }
    _array[_size++] = x;
}

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

实例化

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

int main() {
    Stack<int> st1;      // 整形栈
    st1.push(1);
    st1.push(2);

    Stack<double> st2;   // 浮点栈
    st2.push(1.1);

    Stack<double>* pst = new Stack<double>();
    return 0;
}

类模板通常需要显示实例化，不像函数模板那样容易做到完全隐式推导。