模板初阶

【本节目标】
1.泛型编程
2.函数模板
3.类模板

1.泛型模板
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。
模板是泛型编程的基础。
分类：函数模板和类模板
2.函数模板
2.1概念：函数模板代表了一个函数家族，该模板与类型无关，在使用时被参数化，根据实参类型产生函数的待定类型版本。
2.2格式:

template<typename T1,typename T2...,typenameTn>
返回值类型 函数名（参数列表）
{}

//typename是用来定义模板参数关键字，也可以用class（切记：不能用struct代替class）

template<class T>//模板参数列表
T Add(T left, T right)//参数列表
{
 cout << typeid(T).name() << endl;
 return left + right;
}

2.3函数模板的原理
模板不是函数，是编译器使用方式产生特定具体类型函数的摸具。在编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
2.4函数模板的实例化
概念：用不同类型的参数使用函数模板时，称为函数模板的实例化。
分类：隐式实例化和显示实例化
1.隐式实例化：让编译器根据实参推演模板参数的实际类型。
2.显示实例化：在函数名后<>中指定模板参数的实际类型
如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法成功编译器将会报错。

template<class T>//模板参数列表
T Add(T left, T right)//参数列表
{
 cout << typeid(T).name() << endl;
 return left + right;
}

int main()
{
 //对函数模板进行实例化
 //在编译阶段，如果编译器检测到对某个函数模板进行了实例化
 //对实参的类型进行推演，根据推演结果，确认模板参数列表T的实际类型
 //结合函数模板生成具体类型的函数
 Add(1, 2);
 Add(1.0, 2.0);
 Add('1', '2');
 //模板参数一般不进行类型转化
 //两种处理方法：1.用户自己来强制转化 2.使用显示实例化
 Add(1,(int) 1.0);//显式实例化
 Add<int>(1, 2.0);//编译器：可能进行隐式类型转化
 return 0;
}

2.5模板参数的匹配原则
1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

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

2.对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
 return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
 return left + right;
}
void Test()
{
 Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
 Add(1, 2.0); 
 // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

3.模板函数不允许自动转换，但普通函数可以进行自动类型转换。
3.类模板
3.1定义格式：

template<class T1,class T2,...class T3>
class 类模板名
{
//类内成员函数
}；

#include<assert.h>
//typedef int DateType;
//动态类型顺序表
template<class T>
class SeqList
{
public:
 SeqList(size_t capacity=10)
  :_array(new T[capacity])
  , _size(0)
  , _capacity(capacity)
 {}
 ~SeqList()
 {
  if (_array)
  {
   delete[] _array;
   _array = nullptr;
   _capacity = 0;
   _size = 0;
  }
 }
 void PushBack(const T& data);//尾插
 //类外定义
 void PopBack()
 {
  _size--;
 }
 //任意位置插入和删除
 void Insert(size_t pos, const T& data)
 {
  _CheckCapacity();
  for (size_t i = _size-1; i >=pos; i--)
  {
   _array[i + 1] = _array[i];
  }
  _array[pos] = data;
  _size++;
 }
 void Erase(size_t pos)
 {
  for (size_t i = pos; i < _size; i++)
  {
   _array[i] = _array[i + 1];
  }
  _size--;
 }
 //在const类型成员函数中不能修改成员变量
 //修饰this指针
 size_t size() const
 {
  return _size;
 }
 size_t Capacity()const
 {
  return _capacity;
 }
 bool Empty()const
 {
  return 0 == _size;
 }
 T& operator[](size_t index)
 {
  assert(index < _size);
  return _array[index];
 }
 const T&operator[](size_t index)const
 {
  assert(index < _size);
  return _array[index];
 }
private:
 void _CheckCapacity()
 {
  if (_size == _capacity)
  {
   //开辟新空间
   T* array = new T[2 * _capacity];
   //拷贝元素
   //memcpy(array, _array, _size*sizeof(T));
   for (size_t i = 0; i < _size; ++i)
   {
    array[i] = _array[i];
   }
   //释放旧空间
   delete[] _array;
   _array = array;
   _capacity *= 2;
  }
 }
private:
 T* _array;
 size_t _size;
 size_t _capacity;
};
//注意：类模板中的函数放在类外进行定义时，需要加模板参数列表
template<class T>
void SeqList<T>::PushBack(const T& data)
{
 _CheckCapacity();
 _array[_size++] = data;
}

3.2类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

//SeqList类名，SeqList<int>才是类型
SeqList<int> s1;
SeqList<double> s2;