函数模板和类模板

函数模板:

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型生成函数的特定类型版本。
格式: template<typename T1, typename T2,......,typename Tn>  

         返回值类型 函数名(参数列表){  };

typename可以换成class

代码演示如下:

template<class T>//一个类型T,所以下面的参数都要是相同类型,即同为int,double,.....
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

template<typename T1, typename T2>//两个类型T1,T2,所以下面的参数可以是不同类型,即一个是int一个是double;
void func(const T1& x, const T2& y)
{

}
int main()
{
	int i = 1, j = 2;
	double m = 1.1, n = 2.2;
	Swap(i, j);
	Swap(m, n);
	//Swap(i, n);报错,不是同一类型

	func(i, m);
	func(i, j);

	return 0;
}

函数模板实例化:

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

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

template<class T>
T* func1(int n)
{
	return new T[n];
}

int main()
{
	// 隐式实例化：让编译器根据实参推演模板参数的实际类型
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	Add(a1, a2);
	Add(d1, d2);

	// 推导实例化
	cout << Add(a1, (int)d1) << endl;
	cout << Add((double)a1, d1) << endl;

	// 显示实例化
	//Add(a1, d1);通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int或者double类型而报错
	
	//在模板中，编译器一般不会进行类型转换操作,此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	Add(a1, (int)d1);//自己强制转换

	cout << Add<int>(a1, d1) << endl;//使用显示实例化
	cout << Add<double>(a1, d1) << endl; //显式实例化：在函数名后的<>中指定模板参数的实际类型

	double* p1 = func1<double>(10);

	return 0;
}

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

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

//int Add(int left, int right)
//{
//	return left + right;
//}
 通用加法函数
//template<class T1, class T2>
//T1 Add(T1 left, T2 right)
//{
//	return left + right;
//}
//void Test()
//{
//	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
//	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
//}

类模板:

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

类模板实例化需要在类模板名字后跟<>，然后将实例化的 类型放在<>中.

//template<typename T>
//class Stack
//{
//public:
//	Stack(int n = 4)//构造函数
//		:_array(new T[n])
//		,_size(0)
//		,_capacity(n)
//	{}
//
//	~Stack()//析构函数
//	{
//		delete[] _array;
//		_array = nullptr;
//		_size = _capacity = 0;
//	}
//
//	void Push(const T& x);//类里面声明
//
//private:
//	T* _array;
//	size_t _capacity;
//	size_t _size;
//};
//
类模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误
//template<class T>
//void Stack<T>::Push(const T& x)//类外面定义,这是类外面定义的格式
//{
//	if (_size == _capacity)//扩容
//	{
//		T* tmp = new T[_capacity * 2];
//		memcpy(tmp, _array, sizeof(T) * _size);
//		delete[] _array;
//
//		_array = tmp;
//		_capacity *= 2;
//	}
//
//	_array[_size++] = x;
//}
//int main()
//{
//	// 类模板都是显示实例化
//	Stack<int> st1; // int
//	st1.Push(1);
//	st1.Push(2);
//	st1.Push(3);
//
//	Stack<double> st2; // double
//	st2.Push(1.1);
//	st2.Push(1.1);
//	st2.Push(1.1);
//
//	Stack<double>* pst = new Stack<double>;
//	delete pst;
//
//	return 0;
//}