模板

---

写在前面：

C++ 里面的模板分为
1.模板函数
2.类模板

提到模板、模具 大家都会联想到一些什么ppt word之类的模板或者工厂里面的用来批量生产某个东西的模具。那么这里的模板又是什么意义呢？

先来看一段代码：

#include<stdlib.h>
#include<iostream>
using namespace std;
void Swap(int&x1, int&x2)
{int temp;temp = x1;x1 = x2;x2 = temp;
}
void Swap(double&x1, double&x2)
{double temp;temp = x1;x1 = x2;x2 = temp;
}
int main()
{int x = 10; int y = 12;double x1 = 1.2; double y1 = 2.4;Swap(x, y);Swap(x1,y1);cout << x << " " << y << endl;cout << x1 << " " << y1 << endl;return 0;
}

这里想实现一个交换不同类型的变量的Swap函数，使用了函数重载，
可以看到每增加一种数据类型的数据交换 就需要在重载一个Swap 函数
这样显得有些繁琐，此外这样多的函数重载还有以下缺点：

1. 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错

这时候C++提供了一种模板，根据模板生成我们需要的函数，变得更加方便。
在C++中 ，模板是泛型编程的基础 模板是创建类或函数的蓝图或公式。

函数模板

1 .模板函数定义

我们可以不用给每个类型定义一个新函数，而只是定义一个函数模板 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

2 .函数模板格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class) 且模板形参不能为空。

例如：

template<class T>
void Swap(T&x1, T&x2)
{T temp;temp = x1;x1 = x2;x2 = temp;
}
int main()
{int x = 10; int y = 12;double x1 = 1.2; double y1 = 2.4;string s("hello"); string q("world");Swap(x, y);Swap(x1, y1);Swap(s, q);cout << x << " " << y << endl;cout << x1 << " " << y1 << endl;cout << s << " " << q << endl;return 0;
}

结果：
可以看到使用了函数模板之后 整个代码变得更加简洁不繁琐，并且函数模板似乎可以自动识别所传入的实参的数据类型，而它是如何实现的呢？

模板，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。使用函数模板时，编译器会推断哪个模板实参绑定到模板形参。一旦编译器确定了实际的模板实参，就称它实例化了函数模板的一个实例，所以其实模板就 是将本来应该我们做的重复、单调的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然 后产生一份专门处理double类型的代码，对于字符类型也是如此。

看到这里大家是不是想起了auto 关键字觉得他们有相似之处呢?

但函数模板实例化时这里会有一个问题

函数模板实例化

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

1.隐式实例化

也就是让编译器根据实参推演模板参数的实际类型

T Add(T&x1, T&x2)
{return x1 + x2;
}
void test_template2()
{int a = 10; int b = 20;double a1 = 10.2; double b1 = 21.2;cout << Add(a1, b1) << endl;cout << Add(a, b) << endl;//cout << Add(a, b1) << endl; 报错没有与参数列表匹配的函数模板
}

注意：因为这里的T是根据传入的第一个参数推演出数据类型之后就会认为参数类型为第一个参数的类型 检查之后大仙第二个参数的类型不一样时编译器无法确定T的类型就会报错。

那如何解决这种问题呢？

1.强制转换类型

Add(a,(int)b1);

2.显示实例化:在函数名后的<>中指定模板参数的实际类型

Add<int>(a,b1);

模板参数

模板参数分为类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之后的参数类型名称。
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用
注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果

template<class T, string>//此处报错非类型模板不能为类类型
template<class A,double i=10.0>//报错浮点模板参数是非标准的

模板参数的匹配原则

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

这里的返回值用来观察系统调用了哪个函数
注意看以下代码：

int Add(int x1, int x2)
{return 3;
}
template<class T>
T Add(T x1, T x2)
{return 4;
}
void test_template3()
{int a = 1; int b = 2;cout<< Add(a,b) << endl;//与非模板函数匹配cout<<Add<int>(a,b) <<endl; //强调调用函数模板
}

结果：
可以看到当有与函数模板同名的非模板函数时会调用非模板函数 如果强调使用的话会调用函数模板所生成的函数

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

template<class T1,class T2>
T2 Add(T1 x1, T2 x2)
{return 3;
}
int Add(int x1, int x2)
{return 2;
}
void test_template4()
{cout << Add(1, 2) << endl;cout << Add(3, 4.0) << endl;
}

结果：

可以看到 当有更适合、更匹配的函数模板时就会调用函数模板。
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

类模板

看一段代码：

template<class T>
class Arry
{
public:Arry(int capacity=10000): _data(new T[capacity]), _size(0), _capacity(capacity){}void PushBack(const T& data) {          _data[_size++] = data;    }        T& operator[](size_t pos)    {       assert(pos < _size);       return _data[pos];   }private:T*  _data;int _size;int _capacity;
};
int main()
{//这里才是类模板的实例化//格式为 类模板< 类型 >//Arry<int> 才是一个类型Arry<int> a ;Arry<string> s;a.PushBack(1);a.PushBack(2);s.PushBack("hello");s.PushBack("world");cout << a[0] << endl;cout << a[1] << endl;cout << s[0] << endl;cout << s[1] << endl;return 0;
}

结果：

注意：我们编写的Arry并不是一个具体的类，是编译器根据被实例化的类型生成具体类的模具 类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。