模板 (C++)

在C++程序设计语言中，模板（）是指函数模板与类模板，是一种参数化类型机制。Java和C＃中的泛型与C++的模板大体对应，但也有一些功能上的显著差异（C++模板支持两者没有明确对应的模板模板参数和模板非类型参数，但不支持Java的通配符以及C#的泛型类型约束）。模板是C++的泛型编程中不可缺少的一部分。
模板是C++程序员绝佳的武器，特别是结合了多重继承与运算符重载之后。C++的标准函数库提供的许多有用的函数大多结合了模板的概念，如STL以及iostream。
语法.
模板的声明与定义.
模板定义以关键字codice_1开始，后接模板形参表（template parameter list），模板形参表是用尖括号括住的一个或者多个模板形参的列表，形参之间以逗号分隔。模板形参可以是表示类型的类型形参（type parameter），也可以是表示常量表达式的非类型形参（non-type parameter）。非类型形参跟在类型说明符之后声明。类型形参跟在关键字class或typename之后声明。模板形参可以给出默认值（default arguments for template parameters）。
模板的非类型形参.
模板的非类型形参（template non-type parameter）允许为下述形式：
模板的非类型参数被声明为数组或函数的，将被转换为指针或函数指针。例如：
 template&lt;int a[4]&gt; struct A { };
 template&lt;int f(int)&gt; struct B { };
 int i;
 A&lt;&amp;i&gt; x;
 B&lt;&amp;g&gt; y;
模板的非类型形参允许用const或volatile限定（而模板的类型形参是不允许cv限定的）。模板的非类型形参是不允许声明为浮点型、class类型、void型。
模板的模板参数.
类模板的模板参数允许是另外一个类模板，这称为模板的模板参数（template template parameter），也译作“模板参数模板”。函数模板不允许有模板的模板参数。例如：
 template&lt;template &lt;class T&gt; class X&gt; class A { }; //类模板A的第二个参数是另外一个类模板X
 template&lt;class T&gt; class B { };
 A a; //模板A的实际使用。其中的B是模板的模板实参（template template argument）
模板参数的默认值.
模板形参可以给出默认值（default arguments for template parameters）。如果一个模板参数给出了默认值，那么模板形参列表中在其后声明的模板参数都应该给出默认值。例如：
 template&lt;class T = char, class U, class V = int&gt; class X { }; //编译出错，或者给出U的默认值，或者不给出T的默认值
一个模板的各次声明给出的模板参数的默认值可以累积其效果。例如：
 template&lt;class T, class U = int&gt; class A;
 template&lt;class T = float, class U&gt; class A;
 template&lt;class T, class U&gt; class A {
 public:
 T x;
 U y;
 A&lt;&gt; a; //a.x is float, and the type of a.y is int
但是如果交换本示例第一行与第二行的次序，将编译报错。因为如果第一个模板参数T有了默认值，此时编译器必须已经知道其后的第二个模板参数U的默认值。
在同一个作用域（scope）中，不能对同一个模板的同一个参数多次声明其默认值。例如：
 template&lt;class T = char&gt; class X;
 template&lt;class T = char&gt; class X { };//编译报错。如果在本行中不给出模板参数T的默认值将编译通过
模板参数的作用域为从其声明之处至该模板的定义结束之处。因此可以使用一个模板参数作为其后声明的其他模板参数的一部分或默认值。例如：
 template&lt;class V, V obj&gt; class C; 
 template&lt;class T, class U = T&gt; class D { };
变量模板.
变量模板（variable template）是C++14引入的新的一个种类的模板。可用于在命名空间作用域声明一个变量。例如：
 template&lt;class T&gt;
 constexpr T pi = T(3.1415926535897932385); // variable template
 template&lt;class T&gt;
 T circular_area(T r) // function template
 return pi&lt;T&gt; * r * r; // pi&lt;T&gt; is a variable template instantiation
可以在类作用域声明一个静态数据成员： 
 struct matrix_constants
 template&lt;class T&gt;
 using pauli = hermitian_matrix&lt;T, 2&gt;; // alias template
 template&lt;class T&gt; static constexpr pauli&lt;T&gt; sigma1 = { { 0, 1 }, { 1, 0 } }; // static data member template
 template&lt;class T&gt; static constexpr pauli&lt;T&gt; sigma2 = { { 0, -1i }, { 1i, 0 } };
 template&lt;class T&gt; static constexpr pauli&lt;T&gt; sigma3 = { { 1, 0 }, { 0, -1 } };
类的静态数据成员模板，也可以用类模板的非模板数据成员来实现：
 struct limits {
 template&lt;typename T&gt;
 static const T min; // declaration of a static data member template
 template&lt;typename T&gt; const T limits::min = { }; // definition of a static data member template
 template&lt;class T&gt; class X {
 static T s; // declaration of a non-template static data member of a class template
 template&lt;class T&gt; T X&lt;T&gt;::s = 0; // definition of a non-template data member of a class template
变量模板不能用作模板的模板参数（template template arguments）。
模板的使用.
使用模板时，可以在模板名字后面显式给出用尖括号括住的模板实参列表（template argument list）。对模板函数或类的模板成员函数，也可不显式给出模板实参，而是由编译器根据函数调用的上下文推导出模板实参，这称为模板参数推导。
如果模板参数使用其默认值，则在模板实参列表中可以忽略它。如果所有的模板参数都使用了默认值，模板实参列表为空，但仍然必须写出成对的尖括号。例如：
 template&lt;class T = int&gt; class X { };
 X&lt;&gt; a; //编译通过
 X b; //编译报错
对于作为类型的模板实参，不允许是局部类型（local type）、无链接性的类型（type with no linkage）、无名类型（unnamed type）或包括了这三种情形的复合类型。但C++11以及允许本地类型作为模板实参。
示例.
函数模板.
以下以取最大值的函数模板maximum为例。此函数在编译时会自动产生对应参数类型的代码，而不用显式声明。
template &lt;typename T&gt;
inline const T&amp; maximum(const T&amp; x,const T&amp; y)
 if(y &gt; x){
 return y;
 else{
 return x;
int main(void)
 using namespace std;
 int a=3,b=7;
 float x=3.0,y=7.0;
 //Calling template function
 std::cout « maximum&lt;int&gt;(a,b) « std::endl; //输出 7
 std::cout « maximum(a, b) « std::endl; //自动补充类型声明
 std::cout « maximum&lt;double&gt;(x,y) « std::endl; //输出 7
 return 0;
类模板.
template &lt;typename Ty&gt;
class ComPtr
protected:
 Ty* m_ptr;
public:
 ComPtr()
 m_ptr = NULL;
 ComPtr(const ComPtr&amp; rhs)
 m_ptr = NULL;
 SetComPtr(rhs.m_ptr);
 ComPtr(Ty* p)
 m_ptr = NULL;
 SetComPtr(p);
 ~ComPtr()
 Release();
 const ComPtr&amp; operator=(const ComPtr&amp; rhs)
 SetComPtr(rhs.m_ptr);
 return *this;
 Ty* operator=(Ty* p)
 SetComPtr(p);
 return p;
 operator Ty* ()
 return m_ptr;
 Ty* operator-&gt;()
 return m_ptr;
 operator Ty** ()
 Release();
 return &amp;m_ptr;
 operator void** ()
 Release();
 return (void**)&amp;m_ptr;
 bool IsEmpty()
 return (m_ptr == NULL);
 void SetComPtr(Ty* p)
 Release();
 m_ptr = p;
 if (m_ptr)
 m_ptr-&gt;AddRef();
 void Release()
 if (m_ptr)
 m_ptr-&gt;Release();
 m_ptr = NULL;
模板的嵌套：成员模板.
对于类中的模板成员函数、嵌套的成员类模板，可以在封闭类的内部或外部定义它们。当模板成员函数、嵌套类模板在其封闭类的外部定义时，必须以封闭类模板的模板参数（如果它们也是模板类）和成员模板的模板参数开头。如下例：
template &lt;typename C&gt; class myc{
 public:
 template &lt;typename S&gt; C foo(S s);
//下行需要给出外部类与内部嵌套类的模板形参列表：
template&lt;typename C&gt; template &lt;typename S&gt; C myc&lt;C&gt;::foo(S s){
C var;
return var; 
int main()
float f;
myc&lt;int&gt; v1;
v1.foo(f);
C++标准规定：如果外围的类模板没有特例化，里面的成员模板就不能特例化。例如：
template &lt;class T1&gt; class A {
 template&lt;class T2&gt; class B {
 template&lt;class T3&gt; void mf1(T3);
 void mf2();
};
template &lt;&gt; template &lt;class X&gt;
 class A&lt;int&gt;::B {
 template &lt;class T&gt; void mf1(T);
template &lt;&gt; template &lt;&gt; template&lt;class T&gt;
template &lt;class Y&gt; template &lt;&gt;
 void A&lt;Y&gt;::B&lt;double&gt;::mf2() { } // ill-formed; B&lt;double&gt; is specialized but its enclosing class template A is not
依赖名字与typename关键字.
一个模板中的依赖于一个模板参数（template parameter）的名字被称为依赖名字 （dependent name）。当一个依赖名字嵌套在一个类的内部时，称为嵌套依赖名字（nested dependent name）。一个不依赖于任何模板参数的名字，称为非依赖名字（non-dependent name）。
编译器在处理模板定义时，可能并不确定依赖名字表示一个类型，还是嵌套类的成员，还是类的静态成员。C++标准规定：如果解析器在一个模板中遇到一个嵌套依赖名字，它假定那个名字不是一个类型，除非显式用typename关键字前置修饰该名字。
typename关键字有两个用途：
在下述情形，对嵌套依赖类型名字不需要前置修饰typename关键字：
因为它们的上下文已经指出这些标识符就是作为类型的名字。例如：
template &lt;class T&gt; class A: public T::Nested { //基类列表中的T::Nested
 public:
 A(int x) : T::Nested(x) {}; //成员初始化列表中的T::Nested
 struct T::type1 m; //已经有了struct关键字的T::type1
class B{
 public:
 class Nested{
 public:
 Nested(int x){};
 typedef struct {int x;} type1;
int main()
 A&lt;B&gt; a(101);
 return 0;
template关键字.
template关键字有两个用途：
class A { public:
 template &lt;class U&gt; class B{
 public: typedef int INT;
template &lt;typename T&gt;
int f()
 typename T::template B&lt;double&gt;::INT i;
 i=101;
 T a, *p=&amp;a;
 a.template foo&lt;char&gt;();
 p-&gt;template foo&lt;long&gt;();
 return 0;
int main()
 f&lt;A&gt;();
 A::B&lt;double&gt;::INT i; // 自C++11起，也可写作typename A::template B&lt;double&gt;::INT i;
别名模板.
别名模板（aliase template）是C++11引入的技术。在C++03标准中，可以用typedef给全特化模板定义新的类型名。但是不允许用typedef施加于偏特化模板上。例如： 
template &lt;typename First, typename Second, int Third&gt;
class SomeType;
template &lt;typename Second&gt;
typedef SomeType&lt;OtherType, Second, 5&gt; TypedefName; // Illegal in C++03
C++11增加了给偏特化模板增加别名的功能，例如： 
template &lt;typename First, typename Second, int Third&gt;
class SomeType;
template &lt;typename Second&gt;
using TypedefName = SomeType&lt;OtherType, Second, 5&gt;;
codice_11在C++11中也可用于其他的类型别名的声明:
typedef void (*FunctionType)(double); // Old style
using FunctionType1 = void (*)(double); // New introduced syntax
模板实例化.
模板实例化（）是指在编译或链接时生成函数模板或类模板的具体实例源代码。ISO C++定义了两种模板实例化方法：隐式实例化（当使用实例化的模板时自动地在当前代码单元之前插入模板的实例化代码）、显式实例化（直接声明模板实例化）。在C++语言的不同实现中，模板编译模式（模板初始化的方法）大致可分为三种：
ISO C++标准规定，如果隐式实例化模板，则模板的成员函数一直到引用时才被实例化；如果显式实例化模板，则模板所有成员立即都被实例化，所以模板的声明与定义在此处都应该是可见的，而且在其它程序文本文件使用了这个模板实例时用编译器选项抑制模板隐式实例化，或者模板的定义部分是不可见的，或者使用"template&lt;&gt; type FUN_NAME(type list)"的语句声明模板的特化但不实例化。
g++的模板实例化，目前分为三种方式：
VC++7.0中必须类模板实例化只有Borland模型；函数模板一般隐式实例化，自5.0版以后也可显式实例化。