泛型编程

比如我们想实现一个通用的交换函数，我们当然是可以使用函数重载来实现许多哥函数，但是这样也很有缺点，代码复用率比较低，一旦我们想再加一个类型，那么我们又要写一个函数，而且维护性较低，一个出错了，所有的函数都错了，这时候修改就很麻烦了。 那么我们需要一个通用的函数，这个时候模板就应运而生了。

函数模板

概念

模板其实不是一个具体的函数，它在使用时调用具体的参数，然后产生函数的特定类型版本

格式

template<typename T1,typename T2,......> 例如

template<typename T>

void Swap( T& left, T& right)

{

T temp = left;

left = right;

right = temp;

}

原理

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

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例

化。 比如这个主函数

int main()

{

int a1 = 10, a2 = 20;

double d1 = 10.0, d2 = 20.0;

Add(a1, a2);

Add(d1, d2);

/*

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型

通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，

编译器无法确定此处到底该将T确定为int 或者 double类型而报错

注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅

Add(a1, d1);

*/

// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化

Add(a, (int)d);

return 0；
}

显式实例化就是在前面加上指定的类型比如 Add(a, b);

函数参数的匹配原则

比如我们有一个模板，还有一个具体的函数，当我们要调用的函数都符合时，优先调用那个具体的函数

// 专门处理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版本

}

类模板

当然我们也可以定义类模板，比如我们想定义两个栈，但是两个栈的类型不同，这是就可以用上类模板了 看下面的实例

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;

}

类模板也可以实例化 // Vector类名，Vector才是类型

Vector s1;

Vector s2;