template< 模板参数表> 类名｛ ｝；
其中，template 是声明类模板的关键字，表示声明一个模板，模板参数可以是一个，也可以是多个，可以是类型参数 ，也可以是非类型参数。类型参数由关键字class或typename及其后面的标识符构成。非类型参数由一个普通参数构成，代表模板定义中的一个常量。
例：
template< type, width> Graphics;
注意：
(1)如果在全局域中声明了与模板参数同名的变量，则该变量被隐藏掉。
(2)模板参数名不能被当作类模板定义中类成员的名字。
(3)同一个模板参数名在模板参数表中只能出现一次。
(4)在不同的类模板或声明中，模板参数名可以被重复使用。
typedef type;
template< type, width>
Graphics
{
type node;
typedef type;
};
template< type, type>
Rect;
template< type>
Round;
(5)在类模板的前向声明和定义中，模板参数的名字可以不同。
template < T> Image;
template < U> Image;
template < Type>
Image {
(6)类模板参数可以有缺省实参，给参数提供缺省实参的顺序是先右后左。
template < type, size = > Image; template < type=, size > Image；
(7)类模板名可以被用作一个类型指示符。当一个类模板名被用作另一个模板定义中的类型指示符时，必须指定完整的实参表
template< type>
Graphics
{
Graphics *next;
};
template <calss type>
show(Graphics<type> &g)
{
Graphics<type> *pg=&g;
}
定义：从通用的类模板定义中生成类的过程称为模板实例化。
例：Graphics<int> gi;
类模板什么时候会被实例化呢？
①当使用了类模板实例的名字，并且上下文环境要求存在类的定义时。
②对象类型是一个类模板实例，当对象被定义时。此点被称作类的实例化点。
③一个指针或引用指向一个类模板实例，当检查这个指针或引用所指的对象时。
例:
template< Type>
Graphics{};
f1(Graphics<>);
Rect
{
Graphics<>& rsd;
Graphics<> si;
}
main(){
Graphcis<>* sc;
f1(*sc);
iobj=(Graphics<>);
}
要点：
①绑定给非类型参数的表达式必须是一个常量表达式。
②从模板实参到非类型模板参数的类型之间允许进行一些转换。包括左值转换、限定修饰转换、提升、整值转换。
③可以被用于非类型模板参数的模板实参的种类有一些限制。
例:
Template<* ptr> Graphics{…….};
Template< Type, size> Rect{……..};
size=;
Graphics<&size> bp1;
Graphics<> bp2;
db=;
Rect<,db> fa1;
unsigned fasize=;
Rect<String, fasize> fa2;
Int arr[];
Graphics<arr> gp;
要点：
①类模板的成员函数可以在类模板的定义中定义(inline函数)，也可以在类模板定义之外定义(此时成员函数定义前面必须加上template及模板参数)。
②类模板成员函数本身也是一个模板，类模板被实例化时它并不自动被实例化，只有当它被调用或取地址，才被实例化。
template< type>
Class Graphics{
Graphics(){…}
();
};
template< type>
Graphics<type>::(){…}
类模板中可以有三种友元声明：
Graphics{ ();};
Template< T>
Class Rect{
friend Graphics;
friend create();
friend Graphics::();
};
第二种声明表示类模板的实例和它的友元之间是一种一对一的映射关系。
如图：
第三种声明表示类模板的实例和它的友元之间是一种一对多的映射关系。
如图：
例：绑定的友元模板
template< type>
create(Graphics<type>);
template< type>
Graphics{
friend create<type>(Graphics<type>);
};
例：非绑定的友元模板
template< type>
Graphics{
template< T>
friend create(Graphics<T>);
};
注意：当把非模板类或函数声明为类模板友元时，它们不必在全局域中被声明或定义，但将一个类的成员声明为类模板友元，该类必须已经被定义，另外在声明绑定的友元类模板或函数模板时，该模板也必须先声明。
例：
template < T>
A {
:
friend B<T>;
};
template < T>
B{};
要点：
①静态数据成员的模板定义必须出现在类模板定义之外。
②类模板静态数据成员本身就是一个模板，它的定义不会引起内存被分配，只有对其实例化才会分配内存。
③当程序使用静态数据成员时，它被实例化，每个静态成员实例都与一个类模板实例相对应，静态成员的实例引用要通过一个类模板实例。
例：
template< type>
Graphics{
Graphics *next;
type item;
};
template< type>
Graphics<type> * Graphics<type>::next=;
template< type>
type Graphics<type>::item=NULL;
要点：
①在类模板中允许再嵌入模板，因此类模板的嵌套类也是一个模板，它可以使用外围类模板的模板参数。
②当外围类模板被实例化时，它不会自动被实例化，只有当上下文需要它的完整类类型时，它才会被实例化。
③公有嵌套类型可以被用在类定义之外，这时它的名字前必须加上类模板实例的名字。
例:
template< type>
Graphics{
:
template< T>
Rect{ (type a,T b);};
};
Graphics<>::Rect<> node;
定义：成员定义前加上template及模板参数表。
要点：
①在一个类模板中定义一个成员模板,意味着该类模板的一个实例包含了可能无限多个嵌套类和无限多个成员函数．
②只有当成员模板被使用时，它才被实例化.
③成员模板可以定义在其外围类或类模板定义之外．
例:
template< type>
Graphics<type>{
:template< T>
Rect{ (type a,T b);};};
template< Gtype> template< TT>
Graphics<Gtype>::Rect<TT>::(Gtype a,TT b){}
Graphics<>的实例可能包括下列嵌套类型：
Graphics<>::Rect<>
Graphics<>::Rect<>
注意：类模板参数不一定与类模板定义中指定的名字相同。
这种编译模式下，类模板的成员函数和静态成员的定义必须被包含在“要将它们实例化”的所有文件中，如果一个成员函数被定义在类模板定义之外，那么这些定义应该被放在含有该类模板定义的头文件中。
这种模式下，类模板定义和其inline成员函数定义被放在头文件中，而非inline成员函数和静态数据成员被放在程序文本文件中。
例：
export template< type>
Class Graphics
{ Setup( type &);};
#include “Graphics.h”
Template < type>
Void Graphics<type>::Setup( type &){…}
#include “Graphics.h”
Void main()
{Graphics<> *pg= Graphics<>;
Int ival=;
Pg->Setup(ival);
}
Setup的成员定义在User.c中不可见,但在这个文件中仍可调用模板实例Graphics<int>::Setup(const int &)。为实现这一点，须将类模声明为可导出的：当它的成员函数实例或静态数据成员实例被使用时，编译器只要求模板的定义，它的声明方式是在关键字template前加关键字export
当使用包含编译模式时，类模板成员的定义被包含在使用其实例的所有程序文本文件中，何时何地编译器实例化类模板成员的定义，我们并不能精确地知晓，为解决这个问题，标准C++提供了显式实例声明：关键字template后面跟着关键字class以及类模板实例的名字。
例：
#include “Graphics.h” Template Graphics<>;
显式实例化类模板时，它的所有成员也被显式实例化。
先看下面的例子：
Template< type>
Class Graphics{
Public: (type figure){…}};
Class Rect{…};
如果模板实参是Rect类型，我们不希望使用类模板Graphics的通用成员函数定义，来实例化成员函数out()，我们希望专门定义Graphics<Rect>::out()实例，让它使用Rect里面的成员函数。
为此，我们可以通过一个显示特化定义，为类模板实例的一个成员提供一个特化定义。
格式：template<> 成员函数特化定义
下面为类模板实例Graphics<Rect>的成员函数out()定义了显式特化：
Template<> void Graphics<Rect>::out(Rect figure){…}
注意：
①只有当通用类模板被声明后，它的显式特化才可以被定义。
②若定义了一个类模板特化，则必须定义与这个特化相关的所有成员函数或静态数据成员，此时类模板特化的成员定义不能以符号template<>作为打头。(template<>被省略)
③类模板不能够在某些文件中根据通用模板定义被实例化，而在其他文件中却针对同一组模板实参被特化。
如果模板有一个以上的模板参数，则有些人就可能希望为一个特定的模板实参或者一组模板实参特化类模板，而不是为所有的模板参数特化该类模板。即，希望提供这样一个模板：它仍然是一个通用的模板，只不过某些模板参数已经被实际的类型或值取代。通过使用类模板部分特化，可以实现这一点。
例：
template< hi, wid>
Class Graphics{…};
Template< hi>
Class Graphics<hi,>{…};
格式：template<模板参数表>
注意：
①部分特化的模板参数表只列出模板实参仍然未知的那些参数。
②类模板部分特化是被隐式实例化的。编译器选择“针对该实例而言最为特化的模板定义”进行实例化，当没有特化可被使用时，才使用通用模板定义。
例：Graphics<24,90> figure;
它即能从通用类模板定义被实例化，也能从部分特化的定义被实例化，但编译器选择的是部分特化来实例化模板。
③类模板部分特化必须有它自己对成员函数、静态数据成员和嵌套类的定义。
类模板定义也可以被放在名字空间中。例如：
Namespace cplusplus_primer{
Template< type>
Class Graphics{…};
Template< type>
Type create()
{…}
}
当类模板名字Graphics被用在名字空间之外时，它必须被名字空间名cplusplus_primer限定修，或者通过一个using声明或指示符被引入。例如：
Void main()
{
cplusplus_primer::Graphics;
Graphics<> *pg= Graphics<>;
}
注意：在名字空间中声明类模板也会影响该类模板及其成员的特化和部分特化声明的方式，类模板或类模板成员的特化声明必须被声明在定义通用模板的名字空间中（可以在名字空间之外定义模板特化）。
一个关于队列的例子，下面将其代码整理如下:
#include
template < Type> QueueItem;
template < Type>
Queue {
:
friend ostream& <<(ostream &os, Queue<Type> &q);
Queue() : front( ), back ( ) { }
~Queue(){}
add( Type & );
is_empty()
{
front == ;
}
Type remove();
:
QueueItem<Type> *front;
QueueItem<Type> *back;
};
template < Type>
QueueItem
{
:
QueueItem(Type val){item=val;next=;}
friend Queue<Type>;
friend ostream& <<(ostream &os, Queue<Type> &q);
friend ostream& <<(ostream &os, QueueItem<Type> &qi);
:
Type item;
QueueItem *next;
};
template < Type>
Queue<Type>::add( Type &val)
{
QueueItem<Type> *pt = QueueItem<Type>(val);
( is_empty() )
front = back = pt;
{
back->next = pt;
back = pt;
}
}
template < Type>
Type Queue<Type>::remove()
{
( is_empty() )
{
cerr << ;
exit(-);
}
QueueItem<Type> *pt = front;
front = front->next;
Type retval = pt->item;
delete pt;
retval;
}
template < Type>
ostream& <<(ostream &os, Queue<Type> &q)
{
os << ;
QueueItem<Type> *p;
( p = q.front; p; p = p->next )
os << *p << “ ;
os << “ >”;
os;
}
template < Type>
ostream& << ( ostream &os, QueueItem<Type> &qi )
{
os << qi.item;
os;
}
main()
{
Queue<> qi;
cout << qi << endl;
ival;
( ival = ; ival < ; ++ival )
qi.add( ival );
cout << qi << endl;
err_cnt = ;
( ival = ; ival < ; ++ival ) {
qval = qi.remove();
( ival != qval ) err_cnt++;
}
cout << qi << endl;
( !err_cnt )
cout << ;
cout << “?? queue errors:
}
运行结果
作者：Out Man
出处：http://www.cnblogs.com/assemble8086/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留作者信息，且在文章页面明显位置给出原文连接。
尚无评论！