C++ 模板詳解（二）

轉載：http://www.cnblogs.com/gw811/archive/2012/10/25/2736224.html

四、類模板的默認模板類型形參

　　1、可以為類模板的類型形參提供默認值，但不能為函數模板的類型形參提供默認值。函數模板和類模板都可以為模板的非類型形參提供默認值。

　　2、類模板的類型形參默認值形式為：template<class T1, class T2=int> class A{};為第二個模板類型形參T2提供int型的默認值。

　　3、類模板類型形參默認值和函數的默認參數一樣，如果有多個類型形參則從第一個形參設定了默認值之后的所有模板形參都要設定默認值，比如template<class T1=int, class T2>class A{};就是錯誤的，因為T1給出了默認值，而T2沒有設定。

　　4、在類模板的外部定義類中的成員時template?后的形參表應省略默認的形參類型。比如template<class? T1, class T2=int> class A{public: void h();}; 定義方法為template<class T1,class T2> void A<T1,T2>::h(){}。

定義類模板類型形參：

?演示實例1：

　　TemplateDemo.h

 1 #ifndef TEMPLATE_DEMO_HXX
 2 #define TEMPLATE_DEMO_HXX
 3 
 4 template<class T> class A{
 5     public:
 6         T g(T a,T b);
 7         A();
 8 };
 9 
10 #endif

　　TemplateDemo.cpp

 1 #include<iostream.h>
 2 #include "TemplateDemo.h"
 3 
 4 template<class T> A<T>::A(){}
 5 
 6 template<class T> T A<T>::g(T a,T b){
 7     return a+b;
 8 }
 9 
10 void main(){
11     A<int> a;
12     cout<<a.g(2,3)<<endl;
13 }

　　運行結果： ? ? ? 5

?　　類模板的默認模板類型形參示例1：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 //定義帶默認類型形參的類模板。這里把T2默認設置為int型。
 4 template<class T1,class T2=int> class CeilDemo{
 5     public:
 6         int ceil(T1,T2);
 7 };
 8 //在類模板的外部定義類中的成員時template 后的形參表應省略默認的形參類型。
 9 template<class T1,class T2> 
10 int CeilDemo<T1,T2>::ceil(T1 a,T2 b){
11     return a>>b;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int> cd;
6     cout<<cd.ceil(8,2)<<endl;
7 }

　　運行結果：　　　　　　　2　

　　在類模板的外部定義類中的成員時template 后的形參表應省略默認的形參類型，如果沒有省略，不會出現編譯錯誤而是提出警告：

1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo03.cpp
4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
5 warning C4519: default template arguments are only allowed on a class template; ignored
6 
7 TemplateDemo03.obj - 0 error(s), 1 warning(s)

　　原作者：類模板類型形參默認值和函數的默認參數一樣，如果有多個類型形參則從第一個形參設定了默認值之后的所有模板形參都要設定默認值，比如template<class T1=int, class T2>class A{};就是錯誤的，因為T1給出了默認值，而T2沒有設定。

實例測試如下：

　　類模板的默認模板類型形參示例2：

?　　TemplateDemo03.h?

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2,class T3> class CeilDemo{
 5     public:
 6         int ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 int CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp?

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int,int> cd;
6     cout<<cd.ceil(2,3,4)<<endl;
7 }

　　運行結果：　　　　　　　　9　　

　　上例中我們看到，雖然多個類型形參則從第一個形參T1設定了默認值為int類型，但后面的兩個并沒有設定默認值。我們在聲明對象的時候指明了T2和T3的類型都為int類型，編譯、運行沒有任何警告和錯誤。但并不能否定原作者是錯的，這只是一個特例，看下面的示例：

類模板的默認模板類型形參示例3：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2,class T3> class CeilDemo{
 5     public:
 6         double ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<double,double> cd;
6     cout<<cd.ceil(2,3.1,4.1)<<endl;
7 }

　　編譯錯誤：

 1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
 2 Compiling...
 3 TemplateDemo03.cpp
 4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
 5 error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload
 6 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
 7 error C2065: 'cd' : undeclared identifier
 8 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
 9 error C2228: left of '.ceil' must have class/struct/union type
10 Error executing cl.exe.
11 
12 TemplateDemo03.obj - 3 error(s), 0 warning(s)

　　從上面的例子我們可以看出，當我們試圖把T2和T3定義為double類型就會出現錯誤（T1默認定義的是int類型）。那是不是我們按照作者所說把T2和T3也設定為默認值double，是否還會出現錯誤？看下面的示例：

類模板的默認模板類型形參示例4：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2=double,class T3=double> class CeilDemo{
 5     public:
 6         double ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int,double,double> cd;
6     cout<<cd.ceil(2,3.1,4.1)<<endl;
7 }

　　編譯錯誤：

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
Compiling...
TemplateDemo03.cpp
g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload
g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
error C2065: 'cd' : undeclared identifier
g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
error C2228: left of '.ceil' must have class/struct/union type
Error executing cl.exe.TemplateDemo03.obj - 3 error(s), 0 warning(s)

　　從結果我們可以看出，和上例是一樣的錯誤。從實例中我們可以總結如下：類模板如果有多個類型形參，如果使用類型形參默認值則盡量放在參數列表的末尾，而且默認的參數類型必須相同。如果從第一個形參設定了默認值之后的所有模板形參都要設定和第一個形參同類型的默認值。（聲明：本人也是剛接觸C++，以上只是我經過實例演示對原作者提出的一些質疑，可能我的示例有不到之處，還望大神們不吝賜教，共同完善此博客，給像我一樣的菜鳥提供一個學習的平臺！）

　　接下來驗證“不能為函數模板的類型形參提供默認值”：

?類模板的默認模板類型形參示例5：

?　　TemplateDemo04.cpp

 1 #include<iostream.h>
 2 
 3 template<class T1,class T2,class T3>
 4 T1 sum(T1 a,T2 b,T3 c=int){
 5     return a+b+c;
 6 } 
 7 
 8 void main(){
 9     cout<<sum<double,double>(1.1,2.1,3)<<endl;
10 }

　　編譯錯誤：

1 --------------------Configuration: TemplateDemo04 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo04.cpp
4 g:\c++\cdaima\templatedemo04\templatedemo04.cpp(4) : 
5 error C2062: type 'int' unexpected
6 Error executing cl.exe.
7 
8 TemplateDemo04.obj - 1 error(s), 0 warning(s)

　　更改之后的TemplateDemo.cpp

 1 #include<iostream.h>
 2 
 3 template<class T1,class T2,class T3>
 4 T1 sum(T1 a,T2 b,T3 c){
 5     return a+b+c;
 6 } 
 7 
 8 void main(){
 9     cout<<sum<double,short,int>(1.1,3,257)<<endl;
10 }

　　運行結果：　　　261.1　　　　　

　　?原作者演示實例如下：

 1 類模板非類型形參示例
 2 //模板的聲明或定義只能在全局，命名空間或類范圍內進行。即不能在局部范圍，函數內進行，比如不能在main函數中聲明或定義一個模板。
 3 //類模板的定義
 4 template<class T>class A{public:T g(T a, T b); A();};  //定義帶有一個類模板類型形參T的類A
 5 template<class T1,class T2>class B{public:void g();}; //定義帶有兩個類模板類型形參T1，T2的類B
 6 //定義類模板的默認類型形參，默認類型形參不適合于函數模板。
 7 template<class T1,class T2=int> class D{public: voidg();}; //定義帶默認類型形參的類模板。這里把T2默認設置為int型。
 8 //template<class T1=int, class T2>class E{}; //錯誤，為T1設了默認類型形參則T1后面的所有形參都必須設置認默值。
 9 
10 //以下為非類型形參的定義
11 //非類型形參只能是整型，指針和引用，像double，String, String **這樣的類型是不允許的。但是double &，double *對象的引用或指
12 針是正確的。
13 template<class T1,int a> class Ci{public:void g();}; //定義模板的非類型形參，形參為整型
14 template<class T1,int &a>class Cip{public:void g();}; 
15 template<class T1,A<int>* m> class Cc{public:void g();}; //定義模板的模板類型形參，形參為int型的類A的對象的指針。
16 template<class T1,double*a>class Cd{public:void g();};  //定義模板的非類型形參，形參為double類型的引用。
17 class E{}; template<class T1,E &m> class Ce{}; //非類型模板形參為對象的引用。
18 //以下非類型形參的聲明是錯誤的。
19 //template<class T1,A m>class Cc{}; //錯誤，對象不能做為非類型形參，非類型模板形參的類型只能是對象的引用或指針。
20 //template<class T1,double a>class Cc{}; //錯誤，非類型模板的形參不能是double類型，可以是double的引用。
21 //template<class T1,A<int> m>class Cc{}; //錯誤，非類型模板的形參不能是對象，必須是對象的引用或指針。這條規則對于模板型參
22 也不例外。
23 //在類模板外部定義各種類成員的方法，
24 //typeid(變量名).name()的作用是提取變量名的類型，如int a，則cout<<typeid(a).name()將輸出int
25 template<class T>   A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在類模板外部定義類的構造函數的方法
26 template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在類模板外部定義類模板的成員
27 template<class T1,class T2>  voidB<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}
28 //在類外面定義類的成員時template后面的模板形參應與要定義的類的模板形參一致
29 template<class T1,int a>     voidCi<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;}
30 template<class T1,int &a>    voidCip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;} 
31 //在類外部定義類的成員時，template后的模板形參應與要定義的類的模板形參一致
32 template<class T1,A<int> *m> voidCc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;}
33 template<class T1,double* a> voidCd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;}
34 
35 //帶有默認類型形參的模板類，在類的外部定義成員的方法。
36 //在類外部定義類的成員時，template的形參表中默認值應省略
37 template<class T1,class T2>  voidD<T1,T2>::g(){cout<<"class D g()"<<endl;}
38 //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //錯誤，在類模板外部定義帶有默認類型的形
39 參時，在template的形參表中默認值應省略。
40 //定義一些全局變量。
41 int e=2;  doubleed=2.2; double*pe=&ed;
42 A<int> mw; A<int> *pec=&mw; E me;
43 
44 //main函數開始
45 int main()
46 { // template<class T>void h(){} //錯誤，模板的聲明或定義只能在全局，命名空間或類范圍內進行。即不能在局部范圍，函數內進行。
47 //A<2> m; //錯誤，對類模板不存在實參推演問題，類模板必須在尖括號中明確指出其類型。
48 //類模板調用實例
49 A<int> ma; //輸出"class A goucao int"創建int型的類模板A的對象ma。
50 B<int,int> mb; mb.g(); //輸出"class B g() int int"創建類模板B的對象mb，并把類型形參T1和T2設計為int
51 //非類型形參的調用
52 //調用非類型模板形參的實參必須是一個常量表達式，即他必須能在編譯時計算出結果。任何局部對象，局部變量，局部對象的地址，局部
53 變量的地址都不是一個常量表達式，都不能用作非類型模板形參的實參。全局指針類型，全局變量，全局對象也不是一個常量表達式，不能
54 用作非類型模板形參的實參。
55 //全局變量的地址或引用，全局對象的地址或引用const類型變量是常量表達式，可以用作非類型模板形參的實參。
56 //調用整型int型非類型形參的方法為名為Ci，聲明形式為template<class T1,int a> class Ci
57 Ci<int,3>//正確，數值R是一個int型常量，輸出"class Ci g() int"
58 const int a2=3; Ci<int,a2> mci1; mci1.g(); //正確，因為a2在這里是const型的常量。輸出"class Ci g() int"
59 //Ci<int,a> mci; //錯誤，int型變量a是局部變量，不是一個常量表達式。
60 //Ci<int,e> mci; //錯誤，全局int型變量e也不是一個常量表達式。
61 //調用int&型非類型形參的方法類名為Cip，聲明形式為template<class T1,int &a>class Cip
62 Cip<int,e> mcip;  //正確，對全局變量的引用或地址是常量表達式。
63 //Cip<int,a> mcip1; //錯誤，局部變量的引用或地址不是常量表達式。
64 //調用double*類型的非類形形參類名為Cd，聲明形式為template<class T1,double *a>class Cd
65 Cd<int,&ed> mcd; //正確，全局變量的引用或地址是常量表達式。
66 //Cd<int,pe> mcd1; //錯誤，全局變量指針不是常量表達式。
67 //double dd=3.3; //錯誤，局部變量的地址不是常量表達式，不能用作非類型形參的實參
68 //Cd<int,&e> mcd;  //錯誤，非類型形參雖允許一些轉換，但這個轉換不能實現。
69 
70 //調用模板類型形參對象A<int> *的方法類名為Cc，聲名形式為template<class T1,A<int>* m> class Cc
71 Cc<int,&mw> mcc; mcc.g(); //正確，全局對象的地址或者引用是常量表達式
72 //Cc<int,&ma> mcc;  //錯誤，局部變量的地址或引用不是常量表達式。
73 //Cc<int,pec> mcc2;  //錯誤，全局對象的指針不是常量表達式。
74 
75 //調用非類型形參E&對象的引用的方法類名為Ce。聲明形式為template<class T1,E &m> class Ce
76 E me1; //Ce<int,me1> mce1; //錯誤，局部對象不是常量表達式
77 Ce<int,me> mce;  //正確，全局對象的指針或引用是常量表達式。
78 //非類型形參的轉換示例，類名為Ci
79 //非類型形參允許從數組到指針，從函數到指針的轉換，const修飾符的轉換，提升轉換，整值轉換，常規轉換。
80 const short s=3; Ci<int,s> mci4?//正確，雖然short型和int不完全匹配，但這里可以將short型轉換為int型