C++ 模板编程入门：泛型编程核心概念与实战

当我们把函数中的类型换成自己定义的类型名后，只要我们在函数中使用自己定义的类型名，比如 T1，那么编译器在编译时就会按需给我们生成对应类型的函数，我们直接来举一个例子。

#include <iostream>
using namespace std;

// 这里也可以使用 template<class T>，用于声明类型，可以有多个类型
template <typename T>
void Swap(T& x, T& y) // 将类型替换成 T
{
    T tmp = x;
    x = y;
    y = tmp;
}

int main()
{
    int a = 1;
    int b = 2;
    cout << "交换前：a:" << a << "b:" << b << endl;
    // 编译器根据需求会自动按照模板生成一个 int 类型的 Swap
    Swap(a, b);
    cout << "交换前：a:" << a << "b:" << b << endl;
    double c = 1.2;
    double d = 23.1;
    cout << "交换前：c:" << c << "d:" << d << endl;
    // 编译器根据需求会自动按照模板生成一个 double 类型的 Swap
    Swap(c, d);
    cout << "交换前：c:" << c << "d:" << d << endl;
    return 0;
}

在上面的例子中，我们使用模板写了一个 Swap 函数，属于函数模板，编译器按需实例化出一个又一个的 Swap 函数，比如我们传 int 类型的参数，编译器就会生成 int 类型的 Swap 函数，就跟我们上面讲的草莓玩具的例子一样，根据模具就能很轻松的制作出来草莓玩具。

编译器也可以根据函数模板很轻松地实例化出不同的类型的函数，我们来看看上面举例的代码的运行结果，看看是否能做到我说的效果。

可以看到代码没有问题，这里我们简单了解了一下函数模板的格式并且举了一些例子，接下来我们详细讲讲函数模板的原理和实例化。

函数模板的原理

函数模板的原理其实我们都已经说过了，跟草莓模具的描述差不多，但是我们还是简单总结一下，函数模板就像是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

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

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化，接下来我们一个一个介绍。

隐式实例化

隐式实例化就是不需要程序员指定相应的类型，让编译器自己去根据实参的类型实例化出对应的函数，比如之前我们举的 Swap 函数的例子，我们使用的就是隐式实例化，因为我们没有指定函数内部的类型，是靠编译器根据实参实例化出的。

隐式实例化有时候非常方便，因为不需要我们关心类型，但是隐式实例化也有它的不足，因为在一定的情况下编译器也不知道到底怎么实例化出对应的函数，我们来看以下的例子：

#include <iostream>
using namespace std;

template <class T> // 也可以用 typename T
Add(const T& x, const T& y)
{
    return x + y;
}

int main()
{
    int a = 1;
    double b = 2.2;
    Add(a, b); // 报错
    return 0;
}

在上面的例子中，我们设计 Add 的函数模板时只给了一个类型，但是传参数时却传了两种类型，编译器此时就不知道到底该用哪种类型去实例化，所以就会报错，解决办法有三种，第一种方法就是对任意一个参数进行强制类型转换，让参数类型强行一致，第二种方法就是增加模板参数，第三种方法就是显式实例化。

我们先讲一下前两种方法，最后一种方法我们在显式实例化部分讲解。

// 方法一：将某个变量进行强转
Add(a, (int)b);

// 方法二：增加模板参数
template <class T1, class T2> // 也可以用 typename T1
Add(const T1& x, const T2& y)
{
    return x + y;
}

上面两种方法都能解决报错，但是给我们的感觉就是麻烦，因为如果一个函数有很多参数，就有可能强转多次，并且修改模板参数也很麻烦，最后还是只能返回一种类型，跟强转效果差不多但是更麻烦，那么有没有什么更好的方法呢？其实就是第三种方法，显式实例化，我们一起来学习。

显式实例化

显式实例化就是在函数后面加一对尖括号，里面写上类型，这样就说明你已经确定要将这个函数实例化为某种类型，不用编译器去推导，过程中如果出现其它类型，那么编译器就会将它强转为尖括号中的类型，如果强转不了就会报错。

// 方法三：显式实例化
Add<int>(a, b); // b 会被强转为整形

一般来说显式实例化用在类模板实例化中，但是其实函数模板也可以使用，就是用来应对上面的这种场景，那么函数模板我们就了解到这里，后面我们还有进阶，不过要等后面讲完 STL 后我们再学习，接下来我们就来学习类模板。

类模板

有了函数模板的基础我们学习类模板就轻松很多了，因为类模板和函数模板类似，甚至比函数模板更简单，我们先来看看类模板的格式。

// 这里可以是 class 也可以是 typename
template <class T1, class T2, ..., class Tn>
class 类模板名 {
    // 类内成员定义以及成员函数的实现
};

可以看出类模板的定义和函数模板的定义都是非常相似的，是在类的最前面定义好类型供我们在实现中使用，接下来我们就来举一个例子，看看类模板是否实用。

#include <iostream>
using namespace std;

// 类模版
template <typename T>
class Stack
{
public:
    Stack(size_t capacity = 4) { _array = new T[capacity]; _capacity = capacity; _size = 0; }
private:
    T* _arr;
    size_t _capacity;
    size_t _size;
};

这里我们利用类模板简单写了一个栈，跟之前唯一不同的是其中数据类型被替换成我们定义的类型 T 了，这样写的好处是根据要求实例化出不同类型的栈，比 typedef 一个类型好用多了，因为类模板可以同时使用多个类型的栈，但是 typedef 做不到，它一次只能替换一个类型，使用类模板是非常重要的。

除此之外类模板的实例化也很重要，它不能由编译器来自动识别，也就是不能隐式实例化，只能显式实例化，这是为什么呢？我们来看看一个类对象的实例化语句。

Stack st; // 错误：无法推断类型

不知道大家发现没有，类对象实例化时是看不出来类型的，函数模板可以通过实参推导，可类模板做不到，因为没有参数，所以类模板只能采用显式实例化的方式实例化对象。

// 让类模板实例化出来一个 int 类型的栈
Stack<int> st1;
// 让类模板实例化出来一个 double 类型的栈
Stack<double> st2;

那么今天模板初阶的内容就讲到这里。