泛型编程

我们在实现交换函数的时候，只能实现一个数据类型的交换函数，想要在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;
}