模板与泛型编程

一.泛型编程

1.为什么要存在泛型编程

当我们希望可以用同一个函数处理不同类型的参数时(比如写一个交换函数，可以处理各种不同类型的数据）,我们可以怎么解决？
1、函数重载（同一作用域；函数名相同；参数列表不同）
缺点：

        a、只要有新类型出现，就必须添加对应的函数
        b、除了类型外，所有的函数体都相同，代码的复用率太低
        c、如果只是返回类型不同，函数重载不能实现
        d、一个方法有问题，所有的方法都有问题，不好维护

2、使用宏
缺点：

	a、不是函数，不会进行类型检测，安全性不高        
	b、不能调试        
	c、经常会有副作用（除非将每一项都打上括号）        
	d、直接替换的方式，如果多次使用会使代码变得越来越长

3.使用泛型编程，如下所述。

2.泛型编程是什么？

编写与类型无关的逻辑代码，是代码复用的一种手段。模板是泛型编程的基础。模板相当于一个蓝图，它本身不是类或函数，编译器用模板产生指定的类或函数的特定版本类型，产生模板特定类型的过程称为函数模板的实例化。模板分为函数模板和类模板。

二.模板

1.什么是模板？

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

a.函数模板

1.函数模板使用格式

//typename 是定义模板的关键字，也可以用class代替
template<typename t1,typename t2,...typename t3>
返回值类型 函数名(参数列表){}

例如：定义一个交换函数的模板

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

2.函数模板的原理

模板是一个蓝图，它本身并不是函数，是编译器产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。在编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
例如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然 后产生一份专门处理double类型的代码。

3. 函数模板的实例化

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

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

template<class T>
T Sub(const T& x1, const T& x2)
{
 return x1 - x2;
}
int main()
{
 int a1 = 2, a2 = 3;
 double d1 = 10.0, d2 = 20.0;
 Sub(a1, a2);
 Sub(d1, d2);
 //Sub(a1, d1);这样不行，两个类型编译器不知道要用那个类型生成新的代码
 //解决方法:1.将d1强制类型转换为int或者把a1强制类型转换为double
 Sub(a1, (int)d1);
 //2.采用显示实例化
 Sub<int>(a1, d1);
 return 0;
}

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

template<class T>
T Sub(const T& x1, const T& x2)
{
 return x1 - x2;
}
int main()
{
 int a1 = 2, a2 = 3;
 double d1 = 10.0, d2 = 20.0;
 Sub<int>(a1, d1);//函数名后加上类型指定模板参数的实际类型
 return 0;
}

注：如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

4.模板参数的匹配原则

• 一个非模板函数可以和一个同名的函数模板同时存在

//专门处理int的函数
int Sub(const int& x1, const int& x2)
{
 return x1 - x2;
}
//调用的函数模板
template<class T>
T Sub(const T& x1, const T& x2)
{
 return x1 - x2;
}
int main()
{
 int a1 = 2, a2 = 3;
 Sub(a1, a2);//与非模板函数匹配，编译器不需要特化 
 Sub<int>(a1, a2);//调用编译器特化的函数
 return 0;
}

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

//专门处理int的函数
int Sub(const int& x1, const int& x2)
{
 return x1 - x2;
}
//调用的函数模板
template<class T>
T Sub(const T& x1, const T& x2)
{
 return x1 - x2;
}
int main()
{
 int a1 = 2, a2 = 3;
 double d1 = 10.0;
 Sub(a1, a2);//与非函数模板类型完全匹配，不需要函数模板实例化
 Sub(a1, d1);//模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的函数
 return 0;
}

• 显式指定一个空的模板实参列表，该语法告诉编译器只有模板才能来匹配这个调用， 而且所有的模板参数都应该根据实参演绎出来

//专门处理int的函数
int Sub(const int& x1, const int& x2)
{
 return x1 - x2;
}
//调用的函数模板
template<class T>
T Sub(const T& x1, const T& x2)
{
 return x1 - x2;
}
int main()
{
 int a1 = 2, a2 = 3;
 Sub(a1, a2);//与非函数模板类型完全匹配，不需要函数模板实例化
 Sub<>(a1, a2);//调用模板生成的Add函数
 return 0;
}

• 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

b.类模板

1.类模板的定义

template<class T1,class T2...>
class 类模板名
{
	//成员变量
}；

例如：使用类模板定义一个动态顺序表

#include <iostream>
#include <string.h>
using namespace std;
template<class T>
class Vector
{
 public:
   Vector(int capacity)
     :_pData(new T[capacity])
      , _size(0)
      ,_capacity(capacity)
      {}
   //析构函数,类外定义
   ~Vector();
   //检查顺序表是否已满，已满则扩容
   void checkcapacity()
   {
     if(_size == _capacity)
     {
       _capacity *= 2;
       T* tmp = new T[_capacity];
       memcpy(tmp, _pData, sizeof(T)*_size);
       delete[] _pData;
       _pData = tmp;
     }
   }
   //尾插
   void PushBack(const T& data)
   {
     checkcapacity();
     _pData[_size++] = data;
   }
   size_t GetSize()
   {
     return _size;
   }
   T* GetData()
   {
     return _pData;
   }
 private:
   T* _pData;
   size_t _size;
   size_t _capacity;
}；
// 类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T>
Vector<T>::~Vector()
{
  if(_pData)
  {
    delete[] _pData;
  }
  _size = _capacity = 0;
}

注：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具

2.类模板的实例化

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

以上述动态顺表为例：

int main()
{
  Vector<int> s1(3);
  s1.PushBack(1);
  s1.PushBack(2);
  s1.PushBack(3);
  s1.PushBack(4);
  Vector<double> s2(3);
}