C++ 泛型编程之模板详解

原理如下：

1. 编译时生成：函数模板本身不是一个可以直接调用的函数，它只是一个蓝图。
2. 按需生成：当编译器在代码中遇到使用该模板函数的语句时，它会：
   • 根据调用时传递的实际参数类型（或显式指定的类型 <...>），推导出模板参数 T 的具体类型。
   • 根据模板定义，生成（称为实例化）一个处理该具体类型的实际函数。

这个生成的实际函数称为模板函数或函数模板的一个特化/实例。

总结：函数模板让你只写一次函数逻辑，然后让编译器根据你调用时使用的具体数据类型，自动生成处理该类型数据的实际函数版本。它是实现'一次编写，处处使用（不同类型）'的关键工具。

2.3 函数模板的实例化

模板参数实例化分为：隐式实例化和显式实例化。

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); // 编译器自动推导出类型为 int
    Add(d1, d2); // 编译器自动推导出类型为 double
    // Add(a1, d1); // 编译器无法处理，类型不匹配
    return 0;
}

2️⃣ 显式实例化

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

int main() {
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    // 用户强制转化
    Add(a1, (int)d1);
    // 或者显式实例化
    Add<int>(a1, d1);
    return 0;
}

注意：如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

2.4 模板参数的匹配原则

情况 1：非模板函数与同名函数模板共存

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

// 专门处理 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<int>(1, 2); // 调用编译器实例化的 Add 版本
}

情况 2：优先级判断

对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

void main() {
    Add(1, 2);        // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.1);      // 编译器会优先选择非模板函数 int Add(int, int)
                      // 因为非模板函数能匹配成功（通过隐式转换），而模板参数推导失败
}

解释：

1. 函数重载解析规则：当存在模板和非模板的重载函数时，编译器优先考虑非模板函数（如果匹配成功）。非模板函数 int Add(int, int) 要求两个 int 参数。调用时传入的 1（int 类型）完全匹配第一个参数，而 2.1（double 类型）可通过隐式类型转换匹配第二个参数。
2. 模板函数的限制：函数模板 T Add(T left, T right) 要求两个参数类型必须相同。调用 Add(1, 2.1) 传入 int 和 double，编译器无法推导出唯一的 T，导致模板参数推导失败。

三、类模板

背景：如在 C 语言中定义一个栈，若需要存储不同类型的数据，必须定义多个结构体，代码量陡增。

typedef int StackDataType;
typedef struct Stack {
    StackDataType* _Array;
    int _top;
    int _capacity;
}Stack;

模板类可以解决这个问题。

3.1 类模板的定义格式

template <class T>
class Stack_CPP {
public:
    Stack_CPP() {}
    ~Stack_CPP() {}
    void Push(T x) {}
private:
    T* _a;
    int _size;
    int _capacity;
};

int main() {
    Stack_CPP<int> st_cpp_int;       // 实例化为 int 类型
    st_cpp_int.Push(1);
    st_cpp_int.Push(2);
    
    Stack_CPP<double> st_cpp_double; // 实例化为 double 类型
    st_cpp_double.Push(1.1);
    st_cpp_double.Push(2.1);
    return 0;
}

细节注意：类模板实例化需要在类模板名字后跟 <>，然后将实例化的类型放在 <> 中即可。类模板名字不是真正的类，而实例化的结果才是真正的类。