C++模板和泛型程序设计
泛型程序设计（generic programming）是一种算法在实现时不指定具体要操作的数据的类型的程序设计方法。所谓“泛型”，指的是算法只要实现一遍，就能适用于多种数据类型。泛型程序设计方法的优势在于能够减少重复代码的编写。
泛型程序设计的概念最早出现于 1983 年的 Ada 语言，其最成功的应用就是 C++ 的标准模板库（STL）。也可以说，泛型程序设计就是大量编写模板、使用模板的程序设计。泛型程序设计在 C++ 中的重要性和带来的好处不亚于面向对象的特性。
在 C++ 中，模板分为函数模板和类模板两种。熟练的 C++ 程序员，在编写函数时都会考虑能否将其写成函数模板，编写类时都会考虑能否将其写成类模板，以便实现重用。
C++函数模板（模板函数）详解
面向对象的继承和多态机制有效提高了程序的可重用性和可扩充性。在程序的可重用性方面，程序员还希望得到更多支持。举一个最简单的例子，为了交换两个整型变量的值，需要写下面的 Swap 函数：
void Swap(int & x, int & y)
{
int tmp = x;
x = y;
y = tmp;
}
为了交换两个 double 型变量的值，还需要编写下面的 Swap 函数：
void Swap (double & xr double & y)
{
double tmp = x;
x = y;
y = tmp;
}
如果还要交换两个 char 型变量的值，交换两个 CStudent 类对象的值……都需要再编写 Swap 函数。而这些 Swap 函数除了处理的数据类型不同外，形式上都是一样的。能否只写一遍 Swap 函数，就能用来交换各种类型的变量的值呢？继承和多态显然无法解决这个问题。因此，“模板”的概念就应运而生了。
程序设计语言中的模板就是用来批量生成功能和形式都几乎相同的代码的。有了模板，编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。
函数模板的原理
C++ 语言支持模板。有了模板，可以只写一个 Swap 模板，编译器会根据 Swap 模板自动生成多个 Sawp 函数，用以交换不同类型变量的值。
在 C++ 中，模板分为函数模板和类模板两种。函数模板是用于生成函数的，类模板则是用于生成类的。
函数模板的写法如下：
template
返回值类型 模板名(形参表)
{
函数体
}
其中的 class 关键字也可以用 typename 关键字替换，例如：
template
函数模板看上去就像一个函数。前面提到的 Swap 模板的写法如下：
template
void Swap(T & x, T & y)
{
T tmp = x;
x = y;
y = tmp;
}
T 是类型参数，代表类型。编译器由模板自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编译到调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数。
例如下面的程序：
1. #include
2. u[sin](http://c.biancheng.net/ref/sin.html)g namespace std;
3. template
4. void Swap(T & x, T & y)
5. {
6. T tmp = x;
7. x = y;
8. y = tmp;
9. }
10. int main()
11. {
12. int n = 1, m = 2;
13. Swap(n, m); //编译器自动生成 void Swap (int &, int &)函数
14. double f = 1.2, g = 2.3;
15. Swap(f, g); //编译器自动生成 void Swap (double &, double &)函数
16. return 0;
17. }
编译器由模板自动生成函数的过程叫模板的实例化。由模板实例化而得到的函数称为模板函数。在某些编译器中，模板只有在被实例化时，编译器才会检查其语法正确性。如果程序中写了一个模板却没有用到，那么编译器不会报告这个模板中的语法错误。
C++类模板（模板类）详解
人们需要编写多个形式和功能都相似的函数，因此有了函数模板来减少重复劳动；人们也需要编写多个形式和功能都相似的类，于是 C++引人了类模板的概念，编译器从类模板可以自动生成多个类，避免了程序员的重复劳动。
C++ 中类模板的写法如下：
template <类型参数表>
class 类模板名{
成员函数和成员变量
};
类型参数表的写法如下：
class类塑参数1, class类型参数2, ...
类模板中的成员函数放到类模板定义外面写时的语法如下：
template <类型参数表>
返回值类型 类模板名<类型参数名列表>::成员函数名(参数表)
{
...
}
用类模板定义对象的写法如下：
类模板名<真实类型参数表> 对象名(构造函数实际参数表);
如果类模板有无参构造函数，那么也可以使用如下写法：
类模板名 <真实类型参数表> 对象名;
类模板看上去很像一个类。下面以 Pair 类模板为例来说明类模板的写法和用法。
实践中常常会碰到，某项数据记录由两部分组成，一部分是关键字，另一部分是值。关键字用来对记录进行排序和检索，根据关键字能查到值。例如，学生记录由两部分组成，一部分是学号，另一部分是绩点。要能根据学号对学生进行排序，以便方便地检索绩点，则学号就是关键字，绩点就是值。
下面的Pair类模板就可用来处理这样的数据记录：
1. #include
2. #include
3. u[sin](http://c.biancheng.net/ref/sin.html)g namespace std;
4. template
5. class Pair
6. {
7. public:
8. T1 key; //关键字
9. T2 value; //值
10. Pair(T1 k,T2 v):key(k),value(v) { };
11. bool operator < (const Pair & p) const;
12. };
13. template
14. bool Pair::operator < (const Pair & p) const
15. //Pair的成员函数 operator <
16. { //"小"的意思就是关键字小
17. return key < p.key;
18. }
19. int main()
20. {
21. Pair student("Tom",19); //实例化出一个类 Pair
22. cout << student.key << " " << student.value;
23. return 0;
24. }
程序的输出结果是：
Tom 19
实例化一个类模板时，如第 21 行，真实类型参数表中的参数是具体的类型名，如 string、int 或其他类的名字（如 CStudent）等，它们用来一一对应地替换类模板定义中“类型参数表”中的类型参数。类模板名 <真实类型参数表>就成为一个具体的类的名字。
编译器编译到第 21 行时，就会用 string 替换 Pair 模板中的 T1，用 int 替换 T2，其余部分原样保留，这样就自动生成了一个新的类。这个类的名字编译器是如何处理的不需要知道，可以认为它的名字就是 Pair
Pair
编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类叫模板类。