目录
[1.1 问题引入](#1.1 问题引入)
[1.2 泛型编程思想](#1.2 泛型编程思想)
[2.1 函数模板概念](#2.1 函数模板概念)
[2.2 函数模板格式](#2.2 函数模板格式)
[2.3 函数模板的原理](#2.3 函数模板的原理)
[2.4 函数模板的实例化](#2.4 函数模板的实例化)
[2.5 普通函数和函数模板的匹配原则](#2.5 普通函数和函数模板的匹配原则)
[3.1 类模板的定义格式](#3.1 类模板的定义格式)
[3.2 类模板的实例化](#3.2 类模板的实例化)
1.泛型编程
1.1 问题引入
我们想写个通用的交换函数，用于交换各种类型 ，怎么办？
cpp
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;
}我们只能利用函数重载分开实现，这种实现有一些缺陷：
-
重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
-
代码的可维护性比较低，一个出错可能所有的重载均出错。
这时候需要介绍泛型编程了：
1.2 泛型编程思想
泛型编程是与类和对象并列的C++语法特性之一，所谓泛型编程就是独立于任何特定类型的方式编写代码，使用一种通用类型 T 来进行程序设计，T 只是一个占位符，实际在 T 的位置真实的数据类型取决于用户的需求，占位符的替换由编译器在编译阶段完成。
而支持C++进行泛型编程的语法基础就是模板，模板又分为函数模板和类模板。
2.函数模板
2.1 函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
2.2 函数模板格式
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
（注意：typename可以替换class，class更常用）
这里的T也称作模板参数 ，模板参数都是类型（或者常量）。
cpp
template<class T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
2.3 函数模板的原理
函数模板其实不是函数，而是一个蓝图（模具），是编译器用产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
cpp
template<class T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int i1 = 1, i2 = 2;
Swap(i1, i2);
double d1 = 1.0, d2 = 2.0;
Swap(d1, d2);
return 0;
}
在编译器编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
2.4 函数模板的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
1.隐式实例化
隐式实例化：让编译器根据实参推演模板参数的实际类型。
cpp
template<class T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int i1 = 1, i2 = 2;
Swap(i1, i2);
double d1 = 1.0, d2 = 2.0;
Swap(d1, d2);
return 0;
}
2.显式实例化
有些场景编译器不能自己推导出模板参数T的类型，比如模板参数并不在函数参数中时，编译器就不能通过传入的实参来推导模板参数类型。
cpp
template<class T>
T* alloc()
{
T* p = new T[10];
return p;
}
int main()
{
//报错，没有参数列表匹配
//int* p = alloc();
return 0;
}
这时候只能使用显示实例化：
显式实例化：在函数名后加个<>并指定模板参数的实际类型
cpp
template<class T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
template<class T>
T* alloc()
{
T* p = new T[10];
return p;
}
int main()
{
int i1 = 1, i2 = 2;
Swap<int>(i1, i2);
double d1 = 1.0, d2 = 2.0;
Swap<double>(d1, d2);
int* p = alloc<int>();
return 0;
}
2.5 普通函数和函数模板的匹配原则
-
一个普通函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个普通函数。
cpp// 专门处理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版本 } -
普通函数和同名的函数模板同时存在，而且都能完美匹配，优先调用普通函数而不会从函数模板产生出一个实例。（有现成用现成 ）
-
普通函数和同名的函数模板同时存在，但是函数模板可以产生一个更好匹配的函数， 从函数模板产生出一个更好匹配的实例。（有更好用更好）
cpp// 专门处理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(1, 2.0); //模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数 } -
函数模板不允许自动类型转换，但普通函数可以进行自动类型转换
3.类模板
3.1 类模板的定义格式
cpp
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
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;
}
注意：
-
类模板不是类，是编译器根据被实例化的类型生成具体类的模具。
-
模板类中的函数在类外定义时，不仅要指定类域还要加上模板参数列表。
3.2 类模板的实例化
-
类模板实例化与函数模板实例化不同，类模板必须显示实例化，需要在类模板名字后跟<>，然后将实例化的类型放在<> 中。
-
类模板的名字不是真正的类，而实例化的结果才是真正的类，也就是 类名<实例化类型> 才是真正的类。
cpp
// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;