C++初阶学习————模板使用介绍

泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。

假如写个交换函数，针对整i型、浮点型，那么可以用之前学过的重载

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; 
}

虽然函数重载可以实现，但是也很麻烦
1：例如有多个类型，需要些很多份，
2：维护比较麻烦，想增改功能都需要改

C++就添加了模板，告诉编译器根据不同的类型利用该模板来生成代码，模板是泛型编程的基础

函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

使用格式：

template<typename T1, typename T2,…,typename Tn>
也可以是template<class T1, class T2,…,class Tn>

template<typename T>
void Swap( T& left, T& right) 
{
 	T temp = left;
 	left = right;
 	right = temp; 
}

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用

int main()
{
	int a = 10;
	int b = 20;
	swap(a,b);
	return 0;
}

例如：当用 int 类型使用函数模板时，编译器通过对实参类型的推演，将T确定为 int 类型，然后产生一份专门处理 int 类型的代码

模板实例化

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

template<typename PT1,typename PT2>		//可以根据需要定义多个类型

PT1 Add(PT1 left,PT2 right)
{
	return left + right;
}
int main()
{
	double a = 3.3;
	int b = 4;
	int i = Add(a,b);
	return 0;
}

注意看，编译器也提示了

2.显示实例化

template<class T> T Add(const T& left, const T& right) 
{
 	return left + right; 
}
int main()
{
 	int a1 = 10, a2 = 20;
 	double d1 = 10.0, d2 = 20.0;
 	Add(a1, a2);
 	Add(d1, d2);
 	
	Add(a1,d2);
 	return 0;
}

上面这种情况，因为 参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
解决办法：
（1）强制类型转换

（2）显式实例化：在函数名后的<>中指定模板参数的实际类型

int main()
{
 	int a1 = 10, a2 = 20;
 	double d1 = 10.0, d2 = 20.0;
 	Add(a1, a2);
 	Add<double>(a1, d2);
 	return 0;
}

最好是在加一个参数列表，来确定第几个参数匹配谁还有返回值

模板参数的匹配原则

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

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

int Add(int left, int right) 
{
 	return left + right; 
}

template<class T> 
T Add(T left, T right) 
{
	 return left + right; 
}
template<typename TT1, typename TT2>
TT1 Add(TT1 left, TT2 right) 
{
	return left + right; 
}

int main()
{
	Add(1, 2);		会调用非模板函数
	Add<int>(1,2);	调用第一个模板函数
	Add(1, 2.0);	调用第二个的模板函数 
}

类模板
例如之前模拟的栈，可以通过模板改变成员函数的类型等等

template<class T>
class Stack
{
public :
	Stack(int capacity = 4)
		:_capacity(capacity)
		,_top = 0
	{
		_a = new T[capacity];
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;


		void Push(const T& x)
		{}
	}
private:
	T* _a;							
	int _top;
	int _capcaity;
};

template<class T>
void Stack<T>::Push(const T& x)
{
	
}

int main()
{
	Stack<int>d1;			
	Stack<double>d2;
	return 0;
}