【C++模板】：开启泛型编程之门（函数模版，类模板）

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

template<typename T> // 只有一
T Add(const T& left, const T& right) {
    return left + right;
}

int main() {
    int a = 10, b = 20;
    double c = 10.0, d = 20.0;
    Add(a, b); // 编译器将T推演为int，生成处理int类型的Add函数
    Add(c, d); // 编译器将T推演为double，生成处理double类型的Add函数
    return 0;
}

int main() {
    int a = 10;
    double b = 20.0;
    // Add(a, b);  // 报错，无法确定T的类型（因为在这个模板的参数列表里面只有一个参数）
    // 解决方法一：用户强制类型转换
    Add(a, (int)b);
    // 解决方法二：使用显式实例化
    Add<int>(a, b)
    return 0;
}

int main() {
    int a = 10;
    double b = 20.0;
    Add<int>(a, b); 
    return 0;
}

#include <iostream>

// 函数模板，接受多个参数并打印它们
template<typename T1, typename T2, typename T3>
void printMultiple(const T1& a, const T2& b, const T3& c) {
    std::cout << "Values are: " << a << ", " << b << ", " << c << std::endl;
}

int main() {
    int intValue = 1;
    double doubleValue = 2.5;
    char charValue = 'A';

    printMultiple(intValue, doubleValue, charValue);
	// 显式实例化：printMultiple<int, double, char>(intValue, doubleValue, charValue);
    return 0;
}

// 专门处理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(1, 2.0); // 调用模板函数生成的更匹配版本
}

template<class T1, class T2, ..., class Tn>
class 类模板名 {
    // 类内成员定义
};

template<typename T>
class Stack {
public:
    Stack(size_t capacity = 4) {
        _array = new T[capacity];
        _capacity = capacity;
        _size = 0;
    }
    void Push(const T& data);
private:
    T* _array;
    size_t _capacity;
    size_t _size;
};
template<class T>
void Stack<T>::Push(const T& data) {
    // 扩容逻辑
    _array[_size] = data;
    ++_size;
}

int main() {
    Stack<int> st1; // 实例化出处理int类型的栈
    Stack<double> st2; // 实例化出处理double类型的栈
    return 0;
}