模版初阶（模版）

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int Add(const int& x, const int& y)
{
	return (x + y) * 10;
}

int main()
{
	cout << Add(10, 20) << endl;
	return 0;
}

这里面用class或者typename都可以

函数模版的原理：

函数模版是一个蓝图，它本身不是函数，和活体印刷差不多

c++中用swap的库，有多个模版参数就可以使用不用的类型

template<typename T>
void swap(T& a,T& b)
{
T temp = a;
a = b;
b= temp;
}

在编译器的编译阶段，编译器需要根据传入的实参类型来推演生成对应的类型的函数来供调用，当时利用double类型来时用函数模版时候，编辑器通对实参的推演，将T确定为double的类型，然后产生一个专门处理double类型的代码

函数模版的实例化：

这里面的实例化有两种：1.隐式实例化 2 .显示实例化

显示实例化：可以解决不用类型相加的问题

在c语言里面想要不同类型的转换，我们一般只有强制类型转换

不同类型的参数使用函数模板的时候就是函数模版的实例化

Add(a,(int)d);//推导实例化

Add<int>(a,b);//显示实例化

模版参数的匹配使用

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

隐式类型的转化：主要在整形之间各种的转化，当然浮点数和整形之间都是可以的

特点：

1.对于非模版函数和同名的函数模版，如果其他的条件都是相同的话，在调用的时候会先调用非模版函数而不是先去从该模版里面创建一个实例。但是如果模版可以产生提个具有更好匹配的函数，那么回去选择模版函数

2.模版函数不允许自动类型转换，但是普通函数可以进行自动类型转换

类模板：

if空间如果不够的话，不能调用realloc去扩容，由于realloc的寇蓉不回去调用构造函数去初始化，所以从此以后我们都去手动扩容，这里面扩容有两种，一种是内存够用的话就是蹦迪扩容，如果内存不够的话就是异地扩容。

这里面就是一个例子

#include<iostream>
using namespace std;
template<class T>
class stack
{
public:
	stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = size;
	}
	~stack()
	{
		delete[] _array;
		_array = nullptr;
		_capacity = _size = 0;
	}

	//void push(const T& x);
	void push(const X& y)
	{
		if (_capacity == _size)
		{
			X* tmp = new X[_capacity * 2];
			memcpy(tmp, _array, sizeof(X) * size);
			delete[] _array;
			_array = tmp;
			_capacity *= 2;
		}
		_array[_size++] = y;
	}
private:
	T* _array;
	size_t _size;
	size_t  _capacity;
};