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. 也不例外。
14. //在類模板外部定義各種類成員的方法，
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>
摘自 jiangwenfeng762
