泛型编程

我们在实现交换函数的时候，只能实现一个数据类型的交换函数，想要在C++中完成对应类型数据的交换一种方法是使用函数重载，就像下面这样

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

这样写就显得我们不太聪明的样子，这样写的缺点是：重载的函数仅仅是类型不同，代码复用率较低，只要有新类型出现时，就需要用户自己增加对应的函数。代码的可维护性比较低，一个出错可能所有的重载出错。
针对这些问题，C++中提供了模板的语法

模板

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。后面我们将会大量运用泛型编程。
模板可以分为函数模板和类模板

函数模板

我们来看一下这个代码：

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

上面的代码运用了函数模板的概念，template是C++中提供函数模板参数的一个关键字，上面就是一个交换函数的函数模板，该函数可以适应很多类型的数据交换。

概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，更具实参类型产生函数的特定类型版本。
格式：template <typename T1,typename T2,……typename Tn>
返回值类型函数名(参数列表) {}
注意：typename是用来定义模板参数关键字，也可以使用class（切记：不能使用struct代替class）。

原理

函数模板只是一个模板，它本身不是函数，是编译器使用方式产生特定具体类型函数的模具。所以其实模板就是将本来我们做的重复的事情交给了编译器。
在编译阶段，编译器需要根据传入的实参类型来推演生成对应类型的函数。
在这里插入图片描述

函数模板的实例化

template <typename T>

T Add(const T& left, const T& right)
{
	return left + right;
}

int  main()
{
	int a1 = 1, a2 = 1;
	double d1 = 1.1, d2 = 1.2;
	Add(a1, a2);
	Add(d1, d2);
	//a1和d1不是相同类型的数据，编译器在推演实际的参数是什么类型的时候，
	//会发生二义性的问题，也就是说函数模板参数只有一个编译器不知道是int还是double
	
	//Add(a1, d1);

	//我们可以这样处理
	//这时候我们需要强制类型转换。但是这里还有一个问题，强制类型转换会产生临时变量
	//编译器把这个临时变量传给函数的时候，函数的参数列表必须有const修饰，这是由于
	//临时变量具有常性，如果不加const就会造成权限放大的问题，这时候加上const就是权限平移
	//不会出错
	//1.用户强制转换，2.使用显式实例化(在<>中指定模板参数的实际类型)
	Add(a1, (int)d1);
	Add<int>(a2, d2);
}

也可以这样写，模板参数设置为两个

//通用加法函数
//这样写就不会发生两个类型不同，编译器不知道实例化成哪个的问题了
//但是这样会使精确度下降
template <typename T1,typename T2>
T1 Add(T1& left, T2& right)
{
	return left + right;
}

int main()
{
	int a = 1;
	double b = 1.1;
	cout << Add(a, b) << endl;
}

类模板

定义格式：

template<class T1,class T2,……，class Tn>
class 类模板名
{
	//成员函数
}

实现一个模板栈

template <typename T1>
//模板类
class Stack
{
public:
	Stack(int capacity = 3)
	{
		_array = new T1[capacity];
		_capacity = capacity;
		_top = 0;
	}
	void CheckCapacity()
	{
		if (_top == _capacity)
		{
			T1* temp = (T1*)realloc(_array, sizeof(T1) * _capacity * 2);
			if(NULL == temp)
			{
				perror("realloc failed!\n");
				return;
			}
			_array = temp;
			_capacity *= 2;
			cout << "扩容成功!" << endl;
		}
	}
	void PushStack(T1 x)
	{
		CheckCapacity();
		_array[_top] = x;
		_top++;
	}
	void PopStack()
	{
		if (_top > 0)
		{
			_top--;
		}
		else
		{
			cout << "退栈失败，栈已为空！" << endl;
			return;
		}
	}
	bool EmptyStack()
	{
		return _top == 0;
	}

	T1 StackTop()
	{
		return _array[_top - 1];
	}

	~Stack()
	{
		delete[] _array;
		_array = NULL;
		_capacity = _top = 0;
	}
private:
	T1* _array;
	int _capacity;
	int _top;
};
int main()
{
	Stack<int> s1;
	s1.PushStack(1);
	s1.PushStack(2);
	s1.PushStack(3);
	s1.PushStack(4);
	s1.PushStack(5);
	s1.PushStack(6);
	s1.PushStack(7);
	while (!s1.EmptyStack())
	{
		cout << s1.StackTop() << endl;
		s1.PopStack();
	}
	/*Stack<double> s2;
	Stack<short> s3;*/
	return 0;
}