放在专栏【C++知识总结】，会持续更新，期待支持🌹

前言

在谈及本章之前，我们先来聊一聊别的。橡皮泥大家小时候应该都玩过吧，通常我们买来的橡皮泥里面都会带有一些小动物的图案的模子。我们把橡皮泥往上面按压，就会得到一个个具有该图案形状的橡皮泥。橡皮泥的颜色不同，得到的形状的颜色也不相同。就好像下面这样：

我们可以看到，我们通过给这个模子不同的材料，从而得到由不同材料铸成的不同结果，但是本身还是一个爱心，只不过材料不同。本次章节所讲解的模板，作用就类似于图纸里的这些“模子”。

泛型编程

模板的作用

• 所谓泛型编程，实际上就是指编写与类型无关的代码，从而实现代码的复用。而模板，则是泛型编程的基础，我们可以通过模板，来实现虽然类型不同（橡皮泥颜色各异），但最终目的相同（都是得到爱心，只不过是不一样的爱心，红黄蓝绿...）。

函数模板

应用场景

这里，假如我们想要实现一个交换的函数，实现所有类型都可以完成交换。我们可以采用函数重载的方式，写很多个代码，来实现int、double、char...等类型的交换，就好像下面这样：

//通过函数重载，来实现各个类型的交换
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;
}

但是，我们发现这个工作很繁琐，并且复用率低（假如出现新类型，还要再手动写）。在这种情况下，我们可以通过函数模板，来实现我们的目的。

函数模板的格式

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表)
{}

（这里typename也可以写成class，为了保持与stl库里（SGI版本）的源码格式一致，我们采用class）

上面的函数便可以写成以下这种形式：

//函数模板，实现各个类型之间的叫交换
template<class T>
void Swap(T& left, T& right)
{
    T tmp = left;
    left = right;
    right = tmp;
}

如此一来，不仅简洁了许多，避免了大量重复的书写工作，还使代码的复用率提高。接下来我们谈一谈它的原理。

函数模板的原理

• 函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。也就是说，在编译阶段，编译器会根据我们传入的实参的类型，来推导T的类型，从而生出来一份专有的代码。（比如我们传入的类型为int，编译器就会自动推导T的类型为int，从而实现一份int类型的代码），如下：

编译器在编译期间根据实参类型自动推演形参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.0, d2 = 20.0;
    //隐式实例化，编译器根据a1，a2的类型，推演出T的类型为int
    Add(a1, a2);
    Add(d1, d2);
}

还有我们上面写的Swap函数，也是属于隐式实例化，由编译器来推演T的类型。

但是，假如我们这里Add(a1,d2),此时就会报错，因为编译器根据a1的类型推演T的类型为int，但是由于d2的类型为double，所以编译器推演T的类型为double，而一个T怎么可能会有两个类型，所以会报错（编译器也很懵逼，这个T到底是int，还是double？？？）

error

此时我们只有两种方式来解决该问题：

1. 将其中一个参数使用类型强制转换：()将类型强转为另一个参数的类型，如下：

  //类型强转
  Add(a1, (int)d2);//将d2的类型强制转换为int

不过我们一般不会采用强转的方式，而是采用接下来讲的显示实例化。（注意一点，强制类型转换会产生临时变量，临时变量具有常性，所以我们的形参得需要const来修饰）

• 显式实例化

我们可以在函数名后的<>中指定模板参数的实际类型，告诉编译器，这个T到底是啥。如下：

Add<int>(a1,d2);//告诉编译器，T的类型为int

此时如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

匹配原则

• 假如一个非模板函数与同名的模板函数同时存在，并且模板函数可以实例化出与非模板函数相同的函数，此时编译器会调用哪一个呢？

答：最优匹配的那一个，并且假如其余条件都相同，编译器会调用非模板函数。如下验证：

//匹配原则：最优原则匹配，假如条件都相同，会匹配非模板函数
//非模板函数，专门处理int类型
int Add(int left, int right)
{
    cout << "int Add(int,int)" << endl;
    return left + right;
}
//通用加法模板函数
template<class T>
T Add(T left, T right)
{
    cout << "T Add(T,T)" << endl;
    return left + right;
}
int main()
{
    Add(1, 2);//调用非模板函数
    Add<int>(1,2);//调用模板函数
    Add(3.5, 3.8);//调用模板函数
}

类模板

使用格式：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 // 类内成员定义
}; 

用法

还记得我们之前写过的栈，我们是采用typedef的形式来类型重命名，如下：

以往采用typedef来定义

这样的话，假如我们想要更换成char类型，直接在typedef处修改即可，不过这样有一个缺陷，就是我们无法同时定义一个char类型与int类型的栈。而类模板的存在则可以解决这个问题。

类模板中的成员函数定义方式：

在类中声明，在类外定义，定义时需要加上模板参数列表。或者直接在类中定义（类中的成员函数会被当做内联函数处理，提高效率）

不过有一点需要注意，就是模板不支持声明与定义分离在不同的文件，会出现链接错误！

注意事项

• 类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。（如上：Stack只是类名，Stack<int>才是类型）

• 模板不支持声明与定义分离在不同的文件，会出现链接错误！

• 类模板在类中声明，类外定义时，需要加模板参数列表

end

生活原本沉闷，但跑起来就会有风！🌹