为什么需要模板

比如需要设计一个描述点的类，大致很快可以写成这样：

class Point_F
{
public:
  /*默认传入参数为0，0*/
 Point_F(float x0 = 0, float y0 = 0)
  :x(x0), y(y0) /*初始化列表*/
 { }
  
  /*用const修饰函数，表示函数不会修改成员数据*/
 float get_x() const { return x; }
 float get_y() const { return y; }

private:
  /*一般会将数据放在私有区，以对外隐藏*/
 float x;
 float y;
};

可问题是，在有的场合这点的坐标系有可能不需要浮点，比如界面设计中点往往是整型表示即可，那此时就需要再设计一个整型成员类：

class Point_I
{
public:
  /*默认传入参数为0，0*/
 Point_f(int x0 = 0, int y0 = 0)
  :x(x0), y(y0) /*初始化列表*/
 { }
  
  /*用const修饰函数，表示函数不会修改成员数据*/
 int get_x() const { return x; }
 int get_y() const { return y; }

private:
  /*一般会将数据放在私有区，以对外隐藏*/
 int x;
 int y;
};

可是在应用代码中，往往发现对于不同数据成员的应用操作确实基本类似，而且应用代码往往这两种（甚至更多成员数据类型）都可能会同时用到，仅仅因为数据类型就需要笨笨的将原代码在改写一下，在现代高级语言中，这显然就比较机械了。

C++中有没有可能将不同成员数据类型但是其顶层逻辑相同的对象，设计为一个类呢？就比如：

C++模板编程正是为了解决这样的需求而设计的机制。该机制允许函数或类使用泛型类型(generic type)进行操作。从而，函数或类就可以处理许多不同的数据类型，而无需为每种数据类型重写相应的类或者函数。

怎么实现的呢？

这里又可以大致分这样三种情况：

函数模板(Function templates)
类模板(Class templates)
**成员模板(Member templates) **

函数模板

函数模板其基本语法范式为：

template <class identifier> function_declaration;
template <typename identifier> function_declaration;

template 为模板关键字
<typename identifier> 、<class identifier> 定义函数参数泛型类型或函数体类变量泛型类型

比如：

#include <iostream>
using namespace std;

template <typename T>
T max(T a, T b)
{
 return a > b ? a : b ;
}

又或者写成如下形式：

#include <iostream>
using namespace std;

template <class T>
T max(T a, T b)
{
 return a > b ? a : b ;
}

那么或许有的朋友会任务关键字class就意味着自定义类，而typename则是基本数据类型，比如int,float等，这样理解其实是不对的，从C++编译器的角度template <typename T>与template <class T>其语义是一样的，都是泛型，用户在使用这个模板函数的时候，所传入的参数都既可以是基本数据类型，也可以是类名。

对于上面的代码，或许初使用的朋友还会问，是不是可以随便传入类，这有可能编译不过。为什么呢？你传入的类需要支持>操作符，如果对于某个类你想使用该函数，而本身不支持>操作符，则需要实现>操作符。

类模板

与函数模板类似，类内部成员数据或者函数的参数或变量会使用，模板关键字定义的泛型名。比如：

template <typename T>
class Point_T
{
public:
 Point_T(T x0 = 0, T y0 = 0)
  :x(x0), y(y0)
 { }
 T get_x() const { return x; }
 T get_y() const { return y; }

private:
 T x;
 T y;
};

这小段代码就回答了之前提出的问题，可以支持不同数据类型的点。

int main()
{
 Point_T<int>   p1(1, 2);
 Point_T<float> p2(1.1f, 2.2f);
 cout << p1.get_x() << endl << p1.get_y() << endl;
 cout << p2.get_x() << endl << p2.get_y() << endl;
}

以上述简单例子看，分别构造了整型点p1,以及浮点型点p2，那么究竟怎么做到的呢？为了理解得更清楚，这里将其关键汇编代码段拷贝下来简要看看：

	Point_T<int>   p1(1, 2);
000C1D6C  push        2  
000C1D6E  push        1  
000C1D70  lea         ecx,[p1]  
000C1D73  call        Point_T<int>::Point_T<int> (0C11D1h)  
	Point_T<float> p2(1.1f, 2.2f);
000C1D78  push        ecx  
000C1D79  movss       xmm0,dword ptr [__real@400ccccd (0C7B34h)]  
000C1D81  movss       dword ptr [esp],xmm0  
000C1D86  push        ecx  
000C1D87  movss       xmm0,dword ptr [__real@3f8ccccd (0C7B30h)]  
000C1D8F  movss       dword ptr [esp],xmm0  
000C1D94  lea         ecx,[p2]  
000C1D97  call        Point_T<float>::Point_T<float> (0C1064h)

可见编译器对不同类型参数实际上做了相应解析，相当于根据用户程序传入的参数编译出相应的多份代码。所以可以简单理解成编译器根据不同泛型实际参数类型生成了相应的处理代码。而前面所说的模板函数其原理也基本类似。