lesson05-C++模板

泛型编程

我们先看一个代码：

看着是不是有点麻烦，我们有没有一种通用的办法，让编译器能够根据不同的类型自动生成不同的函数呢？有，就是模板。

泛型编程：

编写与类型无关的通用代码，是代码复用的一种手段。

而模板是泛型编程的基础

函数模板

我们先看代码：

template<typename T>
void Swap(T& a, T& b)
{
  T tmep = a;
  a = b;
  b = temp;
}

函数模板概念 ：

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

我们以上面代码为例讲解：

首先，函数模板的格式：

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

返回值 函数名(参数列表){}

template 的意思就是模板。

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

T1，T2等就是编译器自己根据实参类型推导出来的，或者由我们显式实例化(后面说)。

接下来我们进行各种可能的实验。

错误原因是，编译器通过实参a将T推导为int类型，通过实参e将T推导为double类型，但是只有一个T，编译器无法确定他是int还是double，就会报错。

template<class T1, class T2>
void Swap(T1& a, T2& b)
{
  double temp = a;
  a = b;
  b = temp;
}

多了这样一个重载就没问题了，因为我们多了一个模板参数，则T1推导为int，T2推导为double。

换成Add函数还有另一种解决办法：强制类型转换

template<class T>
T Add(T& a, T& b)
{
  return a + b;
}

但是这里涉及引用的隐式类型转换，参照：C++入门，目录-引用，所以我们的Swap函数需要变点东西：

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

ret结果为4。

去掉const，就会出现权限放大的问题，在e强制类型转换时产生临时变量，具有常性，而函数的参数是变量，就会报错。

还有一种解决办法，叫做显式实例化：

我们指定模板的模板参数，叫做显式实例化，编译器自己推导，叫做隐式实例化。

模板参数的匹配规则：

一个非模板函数可以和一个函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

#include <iostream>
using namespace std;
int add(int a, int b)
{
  return a + b;
}
template<class T>
T add(T a, T b)
{
  return a + b;
}
int main()
{
  add(1, 2);
  add<int>(1, 2);
  return 0;
}

对于非模板函数和同名函数模板，如果调用函数时传参与非模板函数完全相同，那么就优先调用非模板函数，而不是调用函数模板实例化出来的函数；如果模板可以产生一个具有更好匹配的函数，那么将选择模板去实例化函数。

#include <iostream>
using namespace std;
int Add(int a, int b)
{
  return a + b;
}
template<class T1, class T2>
T1 Add(T1 a, T2 b)
{
  return a + b;
}
int main()
{
  cout << Add(1, 2) << endl;
  cout << Add(1.0, 2) << endl;
  return 0;
}

我们进入调试时，第二个Add函数是模板实例化出来的函数。

类模板

类模板定义格式：

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

class 类模板名字{}

我们可以使用类模板写一个动态顺序表，而且通过类模板，我们更加能够体会到他的魅力以及他的强大，如果我们使用C语言来写，而我们的要求是写出多种数据类型的顺序表，用C语言需要重复拷贝多次去修改类型，代码会有很多重复，但是有了模板就不一样了。

template<class T>
class Vector
{
  T* _Data;
  int _size;
  int _capacity;
public:
  Vector(int capacity = 4)
    :_size(0)
    ,_capacity(capacity)
    ,_Data(new T[_capacity])
  {}
  ~Vector()
  {
    if (_Data)
      delete[] _Data;
    _Data = nullptr;
    _size = _capacity = 0;
  }
  T& operator[](int pos)
  {
    if (pos >= 0)
    {
      assert(pos < _size && pos >= 0);
      return _Data[pos];
    }
  }
};

各种类型的对象我们都可以实例化出来。

类模板的实例化

类模板实例化与函数模板实例化不同，需要显式写出模板参数

也许你有这样的疑问，是不是因为我没有传参数，所以类模板无法推导T是什么，但是我们可以看看class 类名，有参数列表吗？显然没有，所以才需要我们显式去传模板参数。

同时我们需要注意的是：

类模板并不是真正的类，就像模板函数一样，只有将他实例化后才是函数，才是真正的类。