本文参考了博文：C++ Template、C++模板详解、为什么C++编译器不能支持对模板的分离式编译。
在编写含有模板的程序的时候，我还是按照一个头文件声明，一个源文件的方法来组织，结果编译的时候总出现一些很奇怪的语法问题，但程序明明是没有问题的。后来经过查阅才知道原来是因为C++编译器不支持对模板的分离式编译，详细原因可参考博文为什么C++编译器不能支持对模板的分离式编译。所以，我在编写程序的时候，使用的是模板声明和实现放在同一个文件中的方法，即使用后缀为.hpp的文件（当然也可以是.h文件，但用.hpp文件更方便表明声明和实现放在一起）。
模板
模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。
模板是一种对类型进行参数化的工具；
通常有两种形式：函数模板和类模板；
函数模板针对仅参数类型不同的函数；
类模板针对仅数据成员和成员函数类型不同的类。
使用模板的目的就是能够让程序员编写与类型无关的代码。比如编写了一个交换两个整型int 类型的swap函数，这个函数就只能实现int 型，对double，字符这些类型无法实现，要实现这些类型的交换就要重新编写另一个swap函数。使用模板的目的就是要让这程序的实现与类型无关，比如一个swap模板函数，即可以实现int 型，又可以实现double型的交换。模板可以应用于函数和类。下面分别介绍。
注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。
1. 函数模板
1）函数模板的格式
template <class 形参名，class 形参名，......> 返回类型 函数名(参数列表)
{
函数体
}
其中template和class是关键字，class可以用typename 关见字代替，在这里typename 和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为
template <class T> void swap(T& a, T& b)
{
}
当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如swap(a,b)其中a和b是int 型，这时模板函数swap中的形参T就会被int 所代替，模板函数变为swap(int &a, int &b)。而当swap(c,d)其中c和d是double类型时，模板函数会被替换为swap(double &a, double &b)，这样就实现了函数的实现与类型无关的代码。
2）注意
对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行 h(2,3) 这样的调用，或者int a, b; h(a,b)。
3）示例
1 // funcTemp.hpp
2 template<typename T> void swapTest(T& t1, T& t2)
3 {
4 T tmpT;
5 tmpT = t1;
6 t1 = t2;
7 t2 = tmpT;
8 }
funcTemp.hpp
1 // main.cpp
2 #include <iostream>
3 #include "funcTemp.hpp"
4
5 using namespace std;
6
7 int main()
8 {
9 int num1 = 1, num2 = 2;
10 swapTest<int>(num1, num2);
11 cout << "num1: " << num1 << " num2: " << num2 << endl;
12 return 0;
13 }
main.cpp
2. 类模板
1) 类模板的格式
template<class 形参名，class 形参名，…>
class 类名
{
...
};
类模板和函数模板都是以template开始后接模板形参列表组成，模板形参不能为空，一但声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数，即可以在类中使用内置类型的地方都可以使用模板形参名来声明。比如
1 template<class T>
2 class A
3 {
4 public:
5 T a;
6 T b;
7 T hy(T c, T &d);
8 };
在类A中声明了两个类型为T的成员变量a和b，还声明了一个返回类型为T带两个参数类型为T的函数hy。
2) 类模板对象的创建
比如一个模板类A，则使用类模板创建对象的方法为A<int> m;在类A后面跟上一个<>尖括号并在里面填上相应的类型，这样的话类A中凡是用到模板形参的地方都会被int 所代替。当类模板有两个模板形参时创建对象的方法为A<int, double> m;类型之间用逗号隔开。
3) 对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。
比如A<2> m;用这种方法把模板形参设置为int是错误的（编译错误：error C2079: ‘a‘ uses undefined class ‘A<int>‘），类模板形参不存在实参推演的问题。也就是说不能把整型值2推演为int 型传递给模板形参。要把类模板形参调置为int 型必须这样指定A<int> m。
4) 在类模板外部定义成员函数的方法
template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表){ 函数体 }
比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：
template<class T1, class T2> void A<T1, T2>::h(){}
注意：当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。
5) 再次提醒注意
模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。
6) 示例1：栈(大小预定)
1 // stackTest.hpp
2 template<class T>
3 class stackTest
4 {
5 public:
6 stackTest();
7 ~stackTest();
8 void push(T t);
9 T pop();
10 bool isEmpty();
11
12 private:
13 T *m_pT;
14 int m_maxsize;
15 int m_size;
16
17 };
18
19
20 template<class T> stackTest<T>::stackTest()
21 {
22 m_maxsize = 100;
23 m_size = 0;
24 m_pT = new T[m_maxsize];
25 }
26
27 template<class T> stackTest<T>::~stackTest()
28 {
29 delete[] m_pT;
30 }
31
32 template<class T> void stackTest<T>::push(T t)
33 {
34 m_size++;
35 m_pT[m_size - 1] = t;
36 }
37
38 template<class T> T stackTest<T>::pop()
39 {
40 T t = m_pT[m_size - 1];
41 m_size--;
42 return t;
43 }
44
45 template<class T> bool stackTest<T>::isEmpty()
46 {
47 return m_size == 0;
48 }
stackTest.hpp
1 // main.cpp
2 #include <iostream>
3 #include"stackTest.hpp"
4
5 using namespace std;
6
7 int main()
8 {
9 stackTest<int> tmpStack;
10 tmpStack.push(1);
11 tmpStack.push(2);
12 tmpStack.push(3);
13
14 while (!tmpStack.isEmpty())
15 {
16 cout << tmpStack.pop() << endl;
17 }
18
19 return 0;
20 }
main
7）示例2：栈（大小可配置）
模板可以有类型参数，也可以有常规的类型参数int，也可以有默认模板参数，例如
template<class T, T def_val> class Stack{ ... }
示例中的类模板的栈有一个限制，就是最多只能支持100个元素，我们可以使用模板参数配置这个栈的最大元素数,如果不配置，就设置默认最大值为100，代码如下:
1 // stackTest.h
2
3 template<class T, int maxsize = 100>
4 class stackTest
5 {
6 public:
7 stackTest();
8 ~stackTest();
9 void push(T t);
10 T pop();
11 bool isEmpty();
12
13 private:
14 T *m_pT;
15 int m_maxsize;
16 int m_size;
17
18 };
19
20
21 template<class T, int maxsize> stackTest<T, maxsize>::stackTest()
22 {
23 m_maxsize = maxsize;
24 m_size = 0;
25 m_pT = new T[m_maxsize];
26 }
27
28 template<class T, int maxsize> stackTest<T, maxsize>::~stackTest()
29 {
30 delete[] m_pT;
31 }
32
33 template<class T, int maxsize> void stackTest<T, maxsize>::push(T t)
34 {
35 m_size++;
36 m_pT[m_size - 1] = t;
37 }
38
39 template<class T, int maxsize> T stackTest<T, maxsize>::pop()
40 {
41 T t = m_pT[m_size - 1];
42 m_size--;
43 return t;
44 }
45
46 template<class T, int maxsize> bool stackTest<T, maxsize>::isEmpty()
47 {
48 return m_size == 0;
49 }
stackTest.hpp
1 // main.cpp
2 #include <iostream>
3 #include"stackTest.hpp"
4
5 using namespace std;
6
7 int main()
8 {
9 const int MAXSIZE = 200;
10 stackTest<int, MAXSIZE> tmpStack;
11
12 for (int i = 0; i < MAXSIZE; i++)
13 {
14 tmpStack.push(i);
15 }
16
17 while (!tmpStack.isEmpty())
18 {
19 cout << tmpStack.pop() << endl;
20 }
21
22 return 0;
23 }
main.cpp
更多深入理解及记录稍后添加...