c++模板详解

c++ 模板分为2类：
1. 函数模板
格式：template <typename 形参名，typename 形参名>  反回类型函数名(参数列表){函数体}
比如：
template <typename T> void swap(T& a, T& b){}
 
调用时：
int a,b;
swap(a,b);
 
double d1,d2;
swap(d1,d2);
 
但是下面写法是错误的：
swap(int,int):不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行
 
2.类模板
格式：template<typename  形参名，typename  形参名…>    class  类名{}
 
比如：
 
 
Cpp代码    
1. template<typename T>  
2. class A  
3. {  
4.     public:   
5.         T a;  
6.         T b;  
7.         T hy(T c, T &d);  
8. }; 
 类模板对象的创建：比有一个模板类A，则使用类模板创建对象的方法为A<int> m;在类A 后面跟上一个<>尖括号
 
并在里面填上相应的类型，这样的话类A 中凡是用到模板形参的地方都会被int 所代替。当类模板有两个模板形参
时创建对象的方法为A<int, double> m;类型之间用逗号隔开。
 
 
对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。比如A<2>  m;用这种方法把模板形参设置为int
是错误的，类模板形参不存在实参推演的问题。也就是说不能把整型值2 推演为int 型传递给模板形参。要把类模板
形参调置为int 型必须这样指定A<int> m。
 
在类模板外部定义成员函数的方法为：template<模板形参列表> 函数反回类型类名<模板形参名>::函数名(参数列表){函数体}，比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：template<class
T1,class T2> void A<T1,T2>::h(){}。注意当在类外面定义类的成员时template后面的模板形参应与要定义的类的模
板形参一致。
 
模板的形参
 
有三种类型的模板形参：类型形参，非类型形参和模板形参。

1、类型形参
1.1 类型模板形参：类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){};其中T就是一个类型形参，类型形参的名字由用户自已确定。模板形参表示的是一个未知的类型。模板类型形参可作为类型说
明符用在模板中的任何地方，与内置类型说明符或类类型说明符的使用方式完全相同，即可以用于指定反回类型，
变量声明等。
1.2 不能为同一个模板类型形参指定两种不同的类型，比如template<class T>void h(T a, T b){}，语句调用h(2, 3.2)将出错，因为该语句给同一模板形参T指定了两种类型，第一个实参2把模板形参T指定为int，而第二个实参3.2把模板形参指定为double，两种类型的形参不一致，会出错。

2、非类型形参
2.1 非类型模板形参：模板的非类型形参也就是内置类型形参，如template<class T, int a> class B{};其中int a就是非类型
的模板形参。
2.2 非类型形参在模板定义的内部是常量值，也就是说非类型形参在模板的内部是常量。
2.3 非模板类型的形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double*，对象的引用或指针是正确的。
2.4 调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。
2.5 注意： 任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模
板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。
2.6 全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。
 
 
 
类模板非类型形参示例
//模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。
 
Cpp代码    
1. //类模板的定义  
2. template<class T>class A{public:T g(T a, T b); A();};  //定义带有一个类模板类型形参T的类A  
3. template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参T1，T2的类B 
 
 
Cpp代码    
1. //定义类模板的默认类型形参，默认类型形参不适合于函数模板。  
2. template<class T1,class T2=int> class D{public: void g();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。 
Cpp代码    
1. //template<class T1=int, class T2>class E{}; //错误，为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。 
 
 
Cpp代码    
1. //以下为非类型形参的定义 www.2cto.com   
2. //非类型形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double *对象的引用或指  
3. 针是正确的。  
4. template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参，形参为整型  
5. template<class T1,int &a>class Cip{public:void g();};   
6. template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int型的类A的对象的指针。  
7. template<class T1,double *a>class Cd{public:void g();};  //定义模板的非类型形参，形参为double类型的引用。  
8. class E{}; template<class T1,E &m> class Ce{}; //非类型模板形参为对象的引用。  
9. //以下非类型形参的声明是错误的。  
10. //template<class T1,A m>class Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。  
11. //template<class T1,double a>class Cc{}; //错误，非类型模板的形参不能是double类型，可以是double的引用。  
12. //template<class T1,A<int> m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参  
13. 也不例外。  

 //在类模板外部定义各种类成员的方法，  
15. //typeid(变量名).name()的作用是提取变量名的类型，如int a，则cout<<typeid(a).name()将输出int  
16. template<class T>   A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法  
17. template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员  
18. template<class T1,class T2>  void B<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}  
19. //在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致  
20. template<class T1,int a>     void Ci<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;}  
21. template<class T1,int &a>    void Cip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;}   
22. //在类外部定义类的成员时，template后的模板形参应与要定义的类的模板形参一致  
23. template<class T1,A<int> *m> void Cc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;}  
24. template<class T1,double* a> void Cd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;}  

25. //带有默认类型形参的模板类，在类的外部定义成员的方法。  
26. //在类外部定义类的成员时，template的形参表中默认值应省略  
27. template<class T1,class T2>  void D<T1,T2>::g(){cout<<"class D g()"<<endl;}  
28. //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误，在类模板外部定义带有默认类型的形  
29. 参时，在template的形参表中默认值应省略。  
30. //定义一些全局变量。  
31. int e=2;  double ed=2.2; double *pe=&ed;  
32. A<int> mw; A<int> *pec=&mw; E me;  
33. //main函数开始  
34. int main()  
35. { // template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。  
36. //A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。  
37. //类模板调用实例  
38. A<int> ma; //输出"class A goucao int"创建int型的类模板A的对象ma。  
39. B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb，并把类型形参T1和T2设计为int  
40. //非类型形参的调用  
41. //调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部  
42. 变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能  
43. 用作非类型模板形参的实参。  
44. //全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。  
45. //调用整型int型非类型形参的方法为名为Ci，声明形式为template<class T1,int a> class Ci  
46. Ci<int,GHIJKLMJKLNOPQMII//正确，数值R是一个int型常量，输出"class Ci g() int"  
47. const int a2=SMITLUint,a2> mci1; mci1.g(); //正确，因为a2在这里是const型的常量。输出"class Ci g() int"  
48. //Ci<int,a> mci; //错误，int型变量a是局部变量，不是一个常量表达式。  
49. //Ci<int,e> mci; //错误，全局int型变量e也不是一个常量表达式。  
50. //调用int&型非类型形参的方法类名为Cip，声明形式为template<class T1,int &a>class Cip  
51. Cip<int,e> mcip;  //正确，对全局变量的引用或地址是常量表达式。  
52. //Cip<int,a> mcip1; //错误，局部变量的引用或地址不是常量表达式。  
53. //调用double*类型的非类形形参类名为Cd，声明形式为template<class T1,double *a>class Cd  
54. Cd<int,&ed> mcd; //正确，全局变量的引用或地址是常量表达式。  
55. //Cd<int,pe> mcd1; //错误，全局变量指针不是常量表达式。  
56. //double dd=aNGMIITbULcdefbbHIJKbgMIhh错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参  
57. //Cd<int,&e> mcd;  //错误，非类型形参虽允许一些转换，但这个转换不能实现。  
58. //调用模板类型形参对象A<int> *的方法类名为Cc，声名形式为template<class T1,A<int>* m> class Cc  
59. Cc<int,&mw> mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式  
60. //Cc<int,&ma> mcc;  //错误，局部变量的地址或引用不是常量表达式。  
61. //Cc<int,pec> mcc2;  //错误，全局对象的指针不是常量表达式。  
62. //调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template<class T1,E &m> class Ce  
63. E me1; //Ce<int,me1> mce1; //错误，局部对象不是常量表达式  
64. Ce<int,me> mce;  //正确，全局对象的指针或引用是常量表达式。  
65. //非类型形参的转换示例，类名为Ci  
66. //非类型形参允许从数组到指针，从函数到指针的转换，const修饰符的转换，提升转换，整值转换，常规转换。  
67. const short s=„M Ci<int,s> mci…MI†//正确，虽然short型和int不完全匹配，但这里可以将short型转换为int型 
 
 
Cpp代码    
1. //函数模板实参推演示例。  
2. // h(int); //错误，对于函数模板而言不存在h(int,int)这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用  
3. 应使用实参推演来进行，即只能进行h(2,©Q这样的调用，或者int a, b; h(a,b)。  
4. //h函数形式为：template<class T>void h(T a)  
5. h(2);//输出"hansu h() int"使用函数模板推演，在这里数值2为int型，所以把类型形参T推演为int型。  
6. h(2.¬QMI//输出"hansu h() double"，因为2.®为double型，所以将函数模板的类型形参推演为double型  
7. //k函数形式为：template<class T>void k(T a,T b)  
8. k(2,°QMI//输出"hansu k() int"  
9. //k(2,±N¬QMIhh错误，模板形参T的类型不明确，因为k()函数第一个参数类型为int，第二个为double型，两个形参类型不一致。  
10. //f函数的形式为：template<class T1,class T2> void f(T1 a, T2 b)  
11. f(¶e…N¬QMI//输出"hansu f() int,double"，这里不存在模板形参推演错误的问题，因为模板函数有两个类型形参T1和T2。在这里将T1推  
12. 演为int，将T2推演为double。  
13. int a=¼Mdouble b=½M  
14. f(a,b); //输出同上，这里用变量名实现推板实参的推演。  
15. //模板函数推演允许的转换示例，g函数的形式为template<class T> void g(const T* a)  
16. int a1ÁÂÃÄÅge†M g(a1); //输出"hansu g() int"，数组的地址和形参const T*不完全匹配，所以将a1的地址T &转换为const T*，而a1  
17. 是int型的，所以最后T推演为int。  
18. g(&b); //输出"hansu g() double",这里和上面的一样，只是把类型T转换为double型。  
19. h(&b); }//输出"hansu h() double *"这里把模参类型T推演为double *类型。 
 
Cpp代码    
1. <SPAN style="WHITE-SPACE: normal">  
2. </SPAN>