一、函数模板( Function templates)
1、
数，可返回任意类型的值，而不需要对所有可能的数据类型进行函数重载。这在一定
程度上实现了宏（macro）的作用。它们的原型定义可以是下面两种中的任何一个：
template <class identifier> function_declaration;
template <typename identifier> function_declaration
其实是一样的
生成一个模板，返回两个对象中较大的一个，我们可以这样写：
template <class GenericType>
GenericType GetMax (GenericType a, GenericType b) { return (a>b?a:b); }
调用模板
function <type> (parameters);
int x,y;
GetMax <int> (x,y);
通用数据类型的模板，叫做 GenericType。因此在其后面的函数中，GenericType 成为一个有效的数据类型，它被用来定义了两个参数 a和 b ，并被用作了函数 GetMax的返回值类型。
GenericType 仍没有代表任何具体的数据类型；当函数 GetMax 被调用的时候，我们可
以使用任何有效的数据类型来调用它。这个数据类型将被作为 pattern来代替函数中
GenericType 出现的地方。用一个类型 pattern来调用一个模板的方法如下：
on <type> (parameters);
这里是一个例子：
//function template
#include <iostream.h>
template <class T>
T GetMax (T a, T b) {
T result;
result = (a>b)? a : b;
return (result);
}
int main () {
int i=5, j=6, k;
long l=10, m=5, n;
k=GetMax(i,j);
n=GetMax(l,m);
cout << k << endl;
cout << n << endl;
return 0;
}
结果：
6
10
在这个具体的例子中，通用类型 T 被用作函数 GetMax 的参数，不需要说明<int>或
<long>，编译器也可以自动检测到传入的数据类型，因此，我们也可以这样写这个例子：
int i,j;
GetMax (i,j);
因为 i 和 j 都是 int 类型，编译器会自动假设我们想要函数按照 int进行调用。这种暗
示的方法更为有用，并产生同样的结果：
2、
我们也可以使得模板函数接受两种或两种以上类型的数据，例如
template <class T>
T GetMin (T a, U b) { return (a<b?a:b); }
在这个例子中，我们的模板函数 GetMin() 接受两个不同类型的参数，并返回一个与第
一个参数同类型的对象。在这种定义下，我们可以这样调用该函数：
int i,j;
long l;
i = GetMin <int, long> (j,l);
或者，简单的用
i = GetMin (j,l);
虽然 j 和 l 是不同的类型。
二、类模板(Class templates)
我们也可以定义类模板（class templates），使得一个类可以有基于通用类型的成员，
而不需要在类生成的时候定义具体的数据类型，例如：
template <class T>
class pair {
T values [2];
public:
pair (T first, T second) {
values[0]=first;
values[1]=second;
}
};
上面我们定义的类可以用来存储两个任意类型的元素。例如，如果我们想要定义该类
的一个对象，用来存储两个整型数据 115 和 36 ，我们可以这样写：
pair<int> myobject (115, 36);
pair<float> myfloats (3.0, 2.18);
如果我们要在类之外定义它的一个成员函数，我们必须在每一函数前面加
template <... >
//class templates
#include <iostream.h>
template <class T>
class pair {
T value1, value2;
public:
pair (T first, T second) {
value1=first;
value2=second;
}
T getmax ();
};
template <class T>
T pair::getmax (){
T retval;
retval = value1>value2? value1 : value2;
return retval;
}
int main () {
pair myobject (100, 75);
cout << myobject.getmax();
return 0;
}
三、模板特殊化(Template specialization)
模板的特殊化是当模板中的 pattern有确定的类型时，模板有一个具体的实现。
例如假设我们的类模板 pair 包含一个取模计算（module operation）的函数，而我们希望这个函数只有当对象中存储的数据为整型(int)的时候才能工作，其他时候，我们需要这个函数总是返回 0。这可以通过下面的代码来实现：
//Template specialization
#include <iostream.h>
template <class T>
class pair {
T value1, value2;
public:
pair (T first, T second){
value1=first;
value2=second;
}
T module () {return 0;}
};
template <>
class pair <int> {
int value1, value2;
public:
pair (int first, int second){
value1=first;
value2=second;
}
int module ();
};
template <>
int pair<int>::module() {
return value1%value2;
}
int main () {
pair <int> myints (100,75);
pair <float> myfloats (100.0,75.0);
cout << myints.module() << '\n';
cout << myfloats.module() << '\n';
return 0;
}
结果：
25
0
由上面的代码可以看到，模板特殊化由以下格式定义：
template <> class class_name <type>
这个特殊化本身也是模板定义的一部分，因此，我们必须在该定义开头写 template
<>。而且因为它确实为一个具体类型的特殊定义，通用数据类型在这里不能够使用，
所以第一对尖括号<> 内必须为空。在类名称后面，我们必须将这个特殊化中使用的
具体数据类型写在尖括号<>中。
当我们特殊化模板的一个数据类型的时候，同时还必须重新定义类的所有成员的特殊
化实现（如果你仔细看上面的例子，会发现我们不得不在特殊化的定义中包含它自己
的构造函数 constructor，虽然它与通用模板中的构造函数是一样的）。这样做的原因
就是特殊化不会继承通用模板的任何一个成员。
四、模板的参数值(Parameter values for templates)
除了模板参数前面跟关键字 class 或 typename 表示一个通用类型外，函数模板和类模
板还可以包含其它不是代表一个类型的参数，例如代表一个常数，这些通常是基本数
据类型的。例如，下面的例子定义了一个用来存储数组的类模板：
//array template
#include <iostream.h>
template <class T, int N>
class array {
T memblock [N];
public:
void setmember (int x, T value);
T getmember (int x);
};
template <class T, int N>
void array<T,N>::setmember (int x, T value) {
memblock[x]=value;
}
template <class T, int N>
T array<T,N>::getmember (int x) {
return memblock[x];
}
int main () {
array <int,5> myints;
array <float,5> myfloats;
myints.setmember (0,100);
myfloats.setmember (3,3.1416);
cout << myints.getmember(0) << '\n';
cout << myfloats.getmember(3) << '\n';
return 0;
}
结果：
100
3.1416
我们也可以为模板参数设置默认值，就像为函数参数设置默认值一样。
下面是一些模板定义的例子：
template <class T> //最常用的：一个 class 参数。
template <class T, class U> //两个 class 参数
template <class T, int N> //一个 class 和一个整数。
template <class T = char> //有一个默认值。
template <int Tfunc (int)> //参数为一个函数。