目录
前言
如何实现一个通用的函数，函数可以实现两个类型的交换？
在往常，我们可能会写下可能用到的类型交换的函数，进行函数重载，但是类型是无穷的，整形、字符型、浮点型、自定义类型...，我们是不可能重载完所有的交换函数，并且函数重载也是有缺点的
例如：
1. 代码复用性比较低，只要有新的类型出现，就需要再次进行函数重载
2. 代码的可维护性比较低，一个出错所有重载均需要修改
C++中，增加了模板这一关键字，可以使编译器根据不同的类型，利用模板来生成相应的代码。
这就是泛型编程——编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。
一、函数模板
1. 概念
函数模板：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
2. 格式
template <typename T1, typename T2, ......, typename Tn>
返回值类型 函数名 (形参列表)
{}例如：
template<typename T> // 模板参数 -- 类型
void Swap(T& x1, T& x2)
{
T tmp = x1;
x1 = x2;
x2 = tmp;
}注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)
//参数为多个模板，返回值也是模板
template<typename T1, typename T2>
T1 Func(const T1& x, const T2& y)
{
cout << x << " " << y << endl;
return x;
}
3. 原理
函数模板是一个蓝图，它本身并不是函数（类似于类和对象的关系），是编译器用使用方式产生特定具体类型函数的模具。所以模板就是将本来应该我们做的重复的事情交给了编译器。
所以，我们在调用模板函数时，真正调用的不是模板，而是模板根据实参的类型实例化的函数
4. 函数模板的实例化
函数模板的实例化：当不同类型的参数使用函数模板时，称为函数模板的实例化。
模板参数实例化分为：隐式实例化和显式实例化
4.1 隐式实例化
隐式实例化：让编译器根据实参推演模板参数的实际类型
当只有一个模板时，实参有两种类型，这时编译器就不知道应该推演T为哪种类型，这就需要我们手动强制类型转换
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.1, d2 = 20.2;
// 实参传递的类型，推演T的类型
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
cout << Add(a1, (int)d1) << endl;
cout << Add((double)a1, d1) << endl;
// 显示实例化，用指定类型实例化
cout << Add<int>(a1, d1) << endl;
cout << Add<double>(a1, d1) << endl;
return 0;
}
注意：对于模板Add函数而言，形参被const修饰，一旦去掉，我们写的代码就跑到不动了，因为我们在调用该模板时，使用了强制类型转换，转换时会产生临时变量，而临时变量具有常性，因为应用的权限不能放大，所以形参必须要用const修饰
4.2 显示实例化
显示实例化：在函数名后<>中指定模板参数的实际类型
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}指定为int后，double型变量b就隐式类型转换为int
如果手动的显示实例化类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
但是上面所述的情况显式实例化的真正用途，因为用两个模板就可以解决上面的问题。
真正会用到显式实例化的情况：有些函数无法自动推导，那么就只能显式实例化.
例：
template<class T> T* Alloc (int c) { return new T[n]; }当调用该模板时，改模板推导不出返回值类型，所以这里就真正的用到显式实例化的功能
int main() { double* p1 = Alloc<double>(10); }
5. 模板参数的匹配原则
5.1
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}5.2
// 专门处理int的加法函数
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函
数
}5.3
模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
二、类模板
由于数据结构中，我们学习过顺序表、栈、队列等等数据结构，但是他们都只能使用一种数据类型，当要使用另一种数据类型时，就需要再拷贝一份并修改里面的数据类型，如果这样使用，那么每使用一个数据类型，我们都需要拷贝一份并修改里面的数据类型，并且，如果原数据结构出现错误，我们需要修改所有的代码。类模板解决了这个问题。
1. 类模板定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};例：
// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
Vector(size_t capacity = 10)
: _pData(new T[capacity])
, _size(0)
, _capacity(capacity)
{}
// 使用析构函数演示：在类中声明，在类外定义。
~Vector();
void PushBack(const T& data)；
void PopBack()；
// ...
size_t Size() { return _size; }
T& operator[](size_t pos)
{
assert(pos < _size);
return _pData[pos];
}
private:
T* _pData;
size_t _size;
size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
if (_pData)
delete[] _pData;
_size = _capacity = 0;
}注意：在模板类中，若要声明与定义分离，那么在类外的定义处，不能只写类名，需要加上模板，并在类名后加上<T>
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}2. 类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;总结
最后，如果小帅的本文哪里有错误，还请大家指出，请在评论区留言（ps：抱大佬的腿），新手创作，实属不易，如果满意，还请给个免费的赞，三连也不是不可以（流口水幻想）嘿！那我们下期再见喽，拜拜！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
