@TOC

1. 泛型编程

函数重载可以实现不同类型的交换函数 ——

void Swap(int& x1, int& x2)
{
    int tmp = x1;
    x1 = x2;
    x2 = tmp;
}

void Swap(double& x1, double& x2)
{
    int tmp = x1;
    x1 = x2;
    x2 = tmp;
}

int main()
{
    int i1 = 10, i2 = 20;
    double d1 = 1.1, d2 = 2.2;
    Swap(i1, i2);
    Swap(d1, d2);
    return 0;
}

但这有一些缺陷 ——

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

如何实现一个通用的交换函数？那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

:heart: 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

2. 函数模板

函数模板代表了一个函数家族，与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.1 函数模板格式

template <typename T1, typename T2, ... ,typename Tn> // 模板参数列表 —— 参数类型
返回值 func(参数列表)                                      //函数参数列表 —— 参数对象
{
    // ...
}

typename是用来定义模板参数的关键字，也可以使用class(但不能使用struct代替class)

//template<class T> 
template<typename T> 
void Swap(T& x1, T& x2) 
{
    T tmp = x1;
    x1 = x2;
    x2 = tmp;
}

2.2 函数模板的原理

函数模板只是一个模板，并不是一个函数。在编译阶段，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

转至反汇编可以看到，函数地址都不一样 ——

" title="">

2.3 函数模板的实例化

:yellow_heart: 1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

上述的代码都采用了隐式实例化。

看如下代码，该语句不能通过编译。因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a将T推演为int，通过实参d将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错

" title="">

注：模板函数不允许隐式类型转换

此时有两种处理方式：① 强制类型转换 ② 显式实例化

// ① 强制类型转换
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a = 10;
    double d = 10.1;
    Add(a, (int)d);
    return 0;
}

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

#include<iostream>
using namespace std;

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a = 10;
    double d = 10.1;

    // 显式实例化
    cout << Add<int>(a, d) << endl;
    cout << Add<double>(a, d) << endl;
    return 0;
}

2.4 模板参数匹配规则

一个普通函数可以和一个同名的函数模板同时存在，如果其他条件都相同，在调动时会优先调用普通函数而不会从该模板产生出一个实例。

如果模板可以产生一个具有更好匹配的函数， 那么优先选择模板

" title="">

3. 类模板

C语言没有数据结构，很大程度上是因为不支持泛型编程。虽然我们用typedef int DataType; 类型重命名，可以稍作改动来更改数据类型，但是如果在一个大型工程里，我们同时要用int栈和char栈，只能勉强把相同逻辑的代码写两遍。C++有了类模板，编译器可以根据被实例化的类型生成真正的类。

3.1类模板定义格式

我们以栈为例 ——

template<class T>
class Stack
{
public:
    Stack(int capacity = 4)
        :_top(0)
        , _capacity(capacity)
    {
        _a = new T[_capacity];
    }

    ~Stack()
    {
        delete[] _a;
        _a = nullptr;
        _top = _capacity = 0;
    }

private:
    T* _a;
    int _top;
    int _capacity;
};

3.2 类模板实例化

类模板实例化与函数模板实例化不同，函数模板可以指定模板参数类型，也可以不指定，编译器会根据实参进行推演。但是类模板实例化只支持显示实例化，因为没法推演。

    Stack<int> st1;    // 存储int
    Stack<double> st2;    // 存储double

注：这里Stack是类名，Stack<T>才是类型！

:yellow_heart: 注意：如果类模板中的函数放到类外定义，仍然都需要加上模板参数列表

template<class T>
class Stack
{
public:
    Stack(int capacity = 4)
        :_top(0)
        , _capacity(capacity)
    {
        _a = new T[_capacity];
    }

    ~Stack()
    {
        delete[] _a;
        _a = nullptr;
        _top = _capacity = 0;
    }

    void StackPush(const T& x);

private:
    T* _a;
    int _top;
    int _capacity;
};

template<class T>
void Stack<T>::StackPush(const T& x)
{
    // ...
}


int main()
{
    Stack<int> st1;    // 存储int
    Stack<double> st2;    // 存储double
    Stack<char> st3;
    st1.StackPush(1);
    st1.StackPush(1);
    st1.StackPush(1);
    return 0;
}