1、所谓泛型编程就是以独立于任何特定类型的方式编写代码。使用泛型程序时，我们需要提供具体程序实例所操作的类型或值。
在泛型编程中，我们所编写的类和函数能够多态地用于跨越编译时不相关的类型。
2、模板是泛型编程的基础。
3、面向对象编程的多态性称为运行是多态性，应用于存在继承关系的类，我们能够编写这样的代码，忽略于基类与派生类之间的类型差异。
泛型编程所依赖的多态称为编译时多态性或参数式多态性。
4、模板定义以关键字 template 开始，后接模板形参表，模板形参表是用尖括号括住的一个或多个模板形参的列表，形参之间以逗号分隔。
模板形参表不能为空。
示例代码
template <typename T>
returntype functionname(parameter_list)
{
//..
}
5、模板形参可以是表示类型的类型形参，也可以是表示常量表达式的非类型形参。非类型形参跟在类型说明符之后说明。
6、使用函数模板时，编译器会推断那个（或那些）模板实参绑定到模板形参。一旦编译器确定了实际的模板实参，就称它为实例化了的函数模板的一个实例。
7、inline函数模板
如同非模板函数一样声明；注意inline的位置。
示例
//ok: inline specifier follows template parameter list template <typename T> inline T min(const T&, const T&); //error: incorrect placement of inline specifier inline template <typename T> T min(const T&, const T&);
8、类模板
同函数模板一样，在类定义前面加template <class Type>。
9、可以给模板形参赋予的唯一含义是区别形参是类型形参还是非类型形参。如果是类型形参，我们就知道该形参表示未知类型，如果是非类型形参，我们就知道它是一个未知值。
10、作用域：模板形参的名字可以在声明为模板形参之后直到模板声明或定义的末尾处使用。模板形参遵循常规名字屏蔽规则。用作模板形参的名字不能在模板内部重用，可以在不同模板中重用。
11、可以只声明，不定义模板。同一模板的声明和定义中，模板形参的名字不必相同。每个模板类型形参前面必须带上关键字typename/class,每个非类型形参前面必须带上类型名字。
示例代码
// all three uses of calc refer to the same function template
// forward declarations of the template
template <class T> T calc(const T&, const T&) ;
template <class U> U calc(const U&, const U&) ;
// actual definition of the template
template <class Type>
Type calc(const Type& a, const Type& b) { /* ... */ }
12、模板类型形参可作为类型说明符用在模板中的任何地方：返回类型，函数形参类型，变量声明，强制类型转换。
13、typename与class相同含义，而typename更直观。
14、由类型形参定义的名字可能是一个类型，也可能是一个成员值。要通过typename显示通知编译器这是一个类型。
示例
template <class Parm, class U>
Parm fcn(Parm* array, U value)
{
Parm::size_type * p; // If Parm::size_type is a type, then a declaration
// If Parm::size_type is an object, then multiplication
//typename Parm::size_type *p //ok, declares p to be a pointer
}
15、非类型形参：调用函数时非类型形参将用值代替，值的类型在模板形参表中指定。
示例
// initialize elements of an array to zero
template <class T, size_t N>
void array_init(T (&parm)[N])
{
for (size_t i = 0; i != N; ++i)
{
parm[i] = 0;
cout << i << endl;
}
}
int main()
{
int x[42];
array_init<int, 42>(x); //instantiates array_init(int(&)[42])
//array_init(x);
//...
return 1;
}
对模板的非类型形参而言，求值结果相同的表达式将认为是等价的。
16、编写模板代码时，对实参类型的要求尽可能少是很有益的。
17、产生模板的特定类型实例的过程称为实例化。模板在使用时将进行实例化，类模板在引用实际模板类类型时实例化，函数模板在调用它或用它对函数指针进行初始化或赋值时实例化。
18、类模板的每次实例化都会产生一个独立的类类型。类模板的特定的实例化是通过提供模板实参与每个模板形参匹配定义的。使用函数模板时，编译器通常会为我们推断模板实参。
19、从函数实参确定模板实参的类型和值的过程叫做模板实参推断。多个类型的形参与实参必须完全匹配。
20、一般而言，不会转换实参以匹配已有的实例化，会产生新的实例。除了产生新的实例化之外，编译器只会执行两种转换。
1）const转换：接受const引用或const指针的函数可以分别用非const对象的引用或指针来调用，无须产生新的实例。如果函数接受非引用类型，形参类型和实参都忽略const,即无论传递const或非const对象给接受非引用类型的函数，都使用相同的实例化。
2）数组或函数到指针的转换：如果模板形参不是引用类型，则对数组或函数类型的实参应用常规指针转换。数组实参将当作指向其第一个元素的指针，函数实参当作指向函数类型的指针。
示例
template <typename T>
T fobj(T, T); // arguments are copied
template <typename T>
T fref(const T&, const T&); // reference arguments
int main()
{
string s1("a value");
const string s2("another value");
fobj(s1, s2); // ok: calls f(string, string), const is ignored
fref(s1, s2); // ok: non const object s1 converted to const reference
int a[10], b[42];
fobj(a, b); // ok: calls f(int*, int*)
fref(a, b); // error: array types don't match; arguments aren't converted to pointers
return 1;
}
当形参为引用时，数组不能转换为指针。
21、类型转换的限制只适用于类型为模板形参的那些实参。普通类型定义的形参可以使用常规转换。
示例
template <class Type> Type sum(const Type &op1, int op2)
{
return op1 + op2;
}
int main()
{
double d = 3.14;
string s1("hiya"), s2(" world");
sum(1024, d); // ok: instantiates sum(int, int), converts d to int
sum(1.4, d); // ok: instantiates sum(double, int), converts d to int
sum(s1, s2); // error: s2 cannot be converted to int
return 1;
}
22、可以使用函数模板对函数指针进行初始化或赋值。
示例
template <typename T>
int compare(const T&, const T&);
// pf1 points to the instantiation int compare (const int&, const int&)
int main()
{
int (*pf1) (const int&, const int&) = compare;
return 1;
}
