c++ 模版

    泛型编程：
        是指数据的类型是广泛，任意的数据类型

    模板：可以将一个函数或类描述成一个模板，例如：画画，给一个人物模型上色彩，根据用户上的色彩是什么人物显示什么样的色彩，模版并不能直接使用，它只是一个框架。
模板：函数模板和类模板

1 函数模版

关键字：template、class/typename
格式：
    template   <模板形参1，模板形参2，........>函数返回值   函数名   （[参数1，参数2，.......]）
    {

    }
    template   <class T1，class T2，........>函数返回值   函数名   （[参数1，参数2，.......]）
    {
        
    }
    template   <typename T1，typename T2，........>函数返回值   函数名   （[参数1，参数2，.......]）
    {

    }    
注意：
    （1）template用于声明一个模板
    （2）typename/class来声明模板形参，模板形参是指传递给该函数的参数类型（模板形参就是该函数的参数类型），指定该函数里用的模板形参的类型
    （3）模板形参要与函数形参一一对应
    
函数模板的调用：
    与C/C++普通函数调用一致：
        格式：
            函数名（实参1，实参2）；//隐式调用（模板形参）
        例如：
            sum（10，20）；
    函数模板的显示调用（模板形参）：
        格式：
            函数名 <数据类型1，数据类型2，.......>（实参1，实参2，......）;
        例如：
            sum<int ,   char> （10，'a'）;

以下代码可以实现两个值的交换，T代表任意数据类型：

#include<iostream>
using namespace std;
template<typename T>//T可以为多个类型的数据
void exchange(T &a,T &b)//C++引用
{
    T t;//定义T作为交换中介
    t=b,b=a,a=t;//交换
}
main()
{
    int a=4,b=5;
    float c=2.4,d=3.6;
    exchange(a,b);
    cout<<a<<"\t"<<b<<endl;
    exchange(c,d);
    cout<<c<<"\t"<<d;
}

2 类模版

关键字：template、class/typename
格式：
    template  <模板形参1 ， 模板形参2，非类型形参，......> class  类名
    {
        
    }；
    template  <class T1 ， class T2，int  sum，......> class  类名
    {
        
    }；    
    template  <typename T1 ， typename T2，int  sum，......> class  类名
    {
        
    }；
注：
    （1）class T1/T2等是模板形参，int  sum：非类型形参
        非类型：是指实例化类的时候，不能传递类型，只能传递实参，非类型形参是整型：int\short\long等等，不能是字符串或浮点型等
    （2）<>里的classs用于声明模板形参，类名前的class用于声明一个类

实例化类模板：
格式：
    类名 <参数类型1，参数类型2，非类型实参，......>对象名 （构造函数实参1，构造函数实参2，....）;
例如：
    People<int , int>people（10,20）；//实例化模板类的对象
    People<int , int，10>people（10,20）；//实例化模板类的对象 ，10是非类型形参的实参

以下是一个简单的堆栈类模板的示例：

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

// 定义堆栈类模板
template <typename T>
class Stack {
private:
    vector<T> elements;  // 使用 vector 作为底层存储结构

public:
    // 将元素推入堆栈
    void push(const T& element) {
        elements.push_back(element);
    }

    // 从堆栈中弹出元素
    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }

    // 获取堆栈顶部的元素
    T top() const {
        if (!elements.empty()) {
            return elements.back();
        }
        // 在实际应用中可能需要处理空堆栈的情况
        // 这里简化为返回默认值
        return T();
    }

    // 检查堆栈是否为空
    bool isEmpty() const {
        return elements.empty();
    }

    // 获取堆栈中的元素数量
    size_t size() const {
        return elements.size();
    }
};

int main() {
    // 使用堆栈类模板存储整数
    Stack<int> intStack;

    intStack.push(10);
    intStack.push(20);
    intStack.push(30);

    cout << "Top element: " << intStack.top() << endl;
    cout << "Stack size: " << intStack.size() << endl;

    intStack.pop();

    cout << "Top element after pop: " << intStack.top() << endl;
    cout << "Stack size after pop: " << intStack.size() << endl;

    // 使用堆栈类模板存储字符串
    Stack<std::string> stringStack;

    stringStack.push("Hello");
    stringStack.push("World");

    cout << "Top element (string): " << stringStack.top() << endl;
    cout << "Stack size (string): " << stringStack.size() << endl;

    return 0;
}