模板初阶（泛型编程、函数模板、类模板）

1.泛型编程

如何实现一个通用的交换函数呢？

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}
int main()
{
    int i=0,int j=1;
    Swap(i,j);
}

使用函数重载虽然可以实现，但是有几个不好的地方：

内部的逻辑都是一样的，只是类型不一样。所以就引出模板template

2.函数模板

template<class T>

template<typename T>,typename是用来定义模板参数关键字，也可以使用class,切记L不能使用struct代替class

template<typename T1,typename T2>

更改上面的交换函数为：

template<typename T>

void Swap(T& left,T& right )

{

      T temp=left;

       left=right;

      right=temp;

}

int main()
{
    int i=0,int j=1;
    Swap(i,j); //都是调用Swap函数吗

    double x=1.1,double y=2.2

    Swap(x,y);

    cout<<Swap(int(1.1),2)<<endl;

    cout<<Swap(1.1,double(2))<<endl;

    cout<<Swap<int>(1.1,2)<<endl; 显示实例化

   cout<<Swap<double>(1.1,2)<<endl;
}

 调用的不是同一个Swap,执行的指令不一样，temp大小都不一样,建立的栈帧大小不一样，一个开4个字节，一个开8个字节

根据模板走一个实例化，编译器用模板实例化生成对应的Swap函数，                                  

3.类模板

用栈举例为什么要用类模板

typedef int DataType;
class Stack
{
public:
    Stack(size_t n = 4)
    {
        cout << "Stack()" << endl;
        _array = new DataType[capacity];//new不用检查失败，失败抛异常
        top = 0;
        capacity = n;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        delete[] _array;
        _array = nullptr;
        top = capacity = 0;
    }
    void push(DataType x)
    {
        _array[top++] = x;
    }
private:
    //成员变量
    DataType* _array;
    int top;
    int capacity;
};
int main()
{
    Stack st1;//int
    Stack st2;//double typedef就不能用了
    return 0;
}

但是现在有两个栈，一个想存int,一个想存double,typedef就不能用了，所以就用模板 

template<class T>
class Stack
{
public:
    Stack(size_t n = 4)
    {
        cout << "Stack()" << endl;
        _array = new T[capacity];//new不用检查失败，失败抛异常
        top = 0;
        capacity = n;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        delete[] _array;
        _array = nullptr;
        top = capacity = 0;
    }
    void push(const T& x)//不知道T是什么类型，就把const &加上
    {
        _array[top++] = x;
    }
private:
    T* _array;
    int top;
    int capacity;
};
int main()
{
    Stack<int> st1;//int
    Stack<double> st2;//double
    return 0;
}