C++ 模板詳解（一）

時間  2020-06-15
標籤 c++ 模板 詳解 欄目 C&C++ 简体版
原文   原文鏈接

C++模板

　　模板是C++支持參數化多態的工具，使用模板可使用戶爲類或者函數聲明一種通常模式，使得類中的某些數據成員或者成員函數的參數、返回值取得任意類型。ios

　　模板是一種對類型進行參數化的工具；程序員

　　一般有兩種形式：函數模板和類模板；數組

　　函數模板針對僅參數類型不一樣的函數；函數

　　類模板針對僅數據成員和成員函數類型不一樣的類。工具

　　使用模板的目的就是可以讓程序員編寫與類型無關的代碼。好比編寫了一個交換兩個整型int 類型的swap函數，這個函數就只能實現int 型，對double，字符這些類型沒法實現，要實現這些類型的交換就要從新編寫另外一個swap函數。使用模板的目的就是要讓這程序的實現與類型無關，好比一個swap模板函數，便可以實現int 型，又能夠實現double型的交換。模板能夠應用於函數和類。下面分別介紹。測試

　　注意：模板的聲明或定義只能在全局，命名空間或類範圍內進行。即不能在局部範圍，函數內進行，好比不能在main函數中聲明或定義一個模板。spa

 

 1、函數模板通式

一、函數模板的格式：指針

　　　　template <class 形參名，class 形參名，......> 返回類型 函數名(參數列表)code

　　　{對象

　　　　　　函數體

　　　}

　　其中template和class是關見字，class能夠用typename 關見字代替，在這裏typename 和class沒區別，<>括號中的參數叫模板形參，模板形參和函數形參很相像，模板形參不能爲空。一但聲明瞭模板函數就能夠用模板函數的形參名聲明類中的成員變量和成員函數，便可以在該函數中使用內置類型的地方均可以使用模板形參名。模板形參須要調用該模板函數時提供的模板實參來初始化模板形參，一旦編譯器肯定了實際的模板實參類型就稱他實例化了函數模板的一個實例。好比swap的模板函數形式爲

　　　　　　template <class T> void swap(T& a, T& b){}，

當調用這樣的模板函數時類型T就會被被調用時的類型所代替，好比swap(a,b)其中a和b是int 型，這時模板函數swap中的形參T就會被int 所代替，模板函數就變爲swap(int &a, int &b)。而當swap(c,d)其中c和d是double類型時，模板函數會被替換爲swap(double &a, double &b)，這樣就實現了函數的實現與類型無關的代碼。

　　二、注意：對於函數模板而言不存在 h(int,int) 這樣的調用，不能在函數調用的參數中指定模板形參的類型，對函數模板的調用應使用實參推演來進行，即只能進行 h(2,3) 這樣的調用，或者int a, b; h(a,b)。

　　函數模板的示例演示將在下文中涉及！

2、類模板通式

　　一、類模板的格式爲：

　　　　template<class  形參名，class 形參名，…>   class 類名

　　　　{ ... };

　　類模板和函數模板都是以template開始後接模板形參列表組成，模板形參不能爲空，一但聲明瞭類模板就能夠用類模板的形參名聲明類中的成員變量和成員函數，便可以在類中使用內置類型的地方均可以使用模板形參名來聲明。好比

　　　　template<class T> class A{public: T a; T b; T hy(T c, T &d);};

在類A中聲明瞭兩個類型爲T的成員變量a和b，還聲明瞭一個返回類型爲T帶兩個參數類型爲T的函數hy。

　　二、類模板對象的建立：好比一個模板類A，則使用類模板建立對象的方法爲A<int> m;在類A後面跟上一個<>尖括號並在裏面填上相應的類型，這樣的話類A中凡是用到模板形參的地方都會被int 所代替。當類模板有兩個模板形參時建立對象的方法爲A<int, double> m;類型之間用逗號隔開。

　　三、對於類模板，模板形參的類型必須在類名後的尖括號中明確指定。好比A<2> m;用這種方法把模板形參設置爲int是錯誤的（編譯錯誤：error C2079: 'a' uses undefined class 'A<int>'），類模板形參不存在實參推演的問題。也就是說不能把整型值2推演爲int 型傳遞給模板形參。要把類模板形參調置爲int 型必須這樣指定A<int> m。

　　四、在類模板外部定義成員函數的方法爲：

　　　　template<模板形參列表> 函數返回類型 類名<模板形參名>::函數名(參數列表){函數體}，

好比有兩個模板形參T1，T2的類A中含有一個void h()函數，則定義該函數的語法爲：

　　　　template<class T1,class T2> void A<T1,T2>::h(){}。

注意：當在類外面定義類的成員時template後面的模板形參應與要定義的類的模板形參一致。

　　五、再次提醒注意：模板的聲明或定義只能在全局，命名空間或類範圍內進行。即不能在局部範圍，函數內進行，好比不能在main函數中聲明或定義一個模板。

 

3、模板的形參

有三種類型的模板形參：類型形參，非類型形參和模板形參。

　　一、類型形參

　　　　1.1 、類型模板形參：類型形參由關見字class或typename後接說明符構成，如template<class T> void h(T a){};其中T就是一個類型形參，類型形參的名字由用戶自已肯定。模板形參表示的是一個未知的類型。模板類型形參可做爲類型說明符用在模板中的任何地方，與內置類型說明符或類類型說明符的使用方式徹底相同，便可以用於指定返回類型，變量聲明等。

　　　　做者原版：1.二、 不能爲同一個模板類型形參指定兩種不一樣的類型，好比template<class T>void h(T a, T b){}，語句調用h(2, 3.2)將出錯，由於該語句給同一模板形參T指定了兩種類型，第一個實參2把模板形參T指定爲int，而第二個實參3.2把模板形參指定爲double，兩種類型的形參不一致，會出錯。（針對函數模板）

　　　　做者原版：1.2針對函數模板是正確的，可是忽略了類模板。下面將對類模板的狀況進行補充。

　　　　本人添加1.2補充版（針對於類模板）、當咱們聲明類對象爲：A<int> a，好比template<class T>T g(T a, T b){}，語句調用a.g(2, 3.2)在編譯時不會出錯，但會有警告，由於在聲明類對象的時候已經將T轉換爲int類型，而第二個實參3.2把模板形參指定爲double，在運行時，會對3.2進行強制類型轉換爲3。當咱們聲明類的對象爲：A<double> a,此時就不會有上述的警告，由於從int到double是自動類型轉換。

演示示例１：

　　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     int> a; 12     2,3.2)<<endl; 13 }
複製代碼

　　編譯結果：

複製代碼 
1 --------------------Configuration: TemplateDemo - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo.cpp
4 G:\C++\CDaima\TemplateDemo\TemplateDemo.cpp(12) : warning C4244: 'argument' : conversion from 'const double' to 'int', possible loss of data
5 
6 TemplateDemo.obj - 0 error(s), 1 warning(s)
複製代碼

　　運行結果：　　　　　　5　　

　　咱們從上面的測試示例中能夠看出，並不是做者原做中的那麼嚴密！此處僅是本人跟人測試結果！請你們本着實事求是的態度，自行驗證！

 

　　二、非類型形參

　　　　2.1 、非類型模板形參：模板的非類型形參也就是內置類型形參，如template<class T, int a> class B{};其中int a就是非類型的模板形參。

　　　　2.二、 非類型形參在模板定義的內部是常量值，也就是說非類型形參在模板的內部是常量。

　　　　2.三、 非類型模板的形參只能是整型，指針和引用，像double，String, String **這樣的類型是不容許的。可是double &，double *，對象的引用或指針是正確的。

　　　　2.四、 調用非類型模板形參的實參必須是一個常量表達式，即他必須能在編譯時計算出結果。

　　　　2.5 、注意：任何局部對象，局部變量，局部對象的地址，局部變量的地址都不是一個常量表達式，都不能用做非類型模板形參的實參。全局指針類型，全局變量，全局對象也不是一個常量表達式，不能用做非類型模板形參的實參。

　　　　2.六、 全局變量的地址或引用，全局對象的地址或引用const類型變量是常量表達式，能夠用做非類型模板形參的實參。

　　　　2.7 、sizeof表達式的結果是一個常量表達式，也能用做非類型模板形參的實參。

　　　　2.8 、當模板的形參是整型時調用該模板時的實參必須是整型的，且在編譯期間是常量，好比template <class T, int a> class A{};若是有int b，這時A<int, b> m;將出錯，由於b不是常量，若是const int b，這時A<int, b> m;就是正確的，由於這時b是常量。

　　　　2.9 、非類型形參通常不該用於函數模板中，好比有函數模板template<class T, int a> void h(T b){}，若使用h(2)調用會出現沒法爲非類型形參a推演出參數的錯誤，對這種模板函數能夠用顯示模板實參來解決，如用h<int, 3>(2)這樣就把非類型形參a設置爲整數3。顯示模板實參在後面介紹。

　　　　2.十、 非類型模板形參的形參和實參間所容許的轉換
　　　　　　一、容許從數組到指針，從函數到指針的轉換。如：template <int *a> class A{}; int b[1]; A<b> m;即數組到指針的轉換
　　　　　　二、const修飾符的轉換。如：template<const int *a> class A{}; int b; A<&b> m;   即從int *到const int *的轉換。
　　　　　　三、提高轉換。如：template<int a> class A{}; const short b=2; A<b> m; 即從short到int 的提高轉換
　　　　　　四、整值轉換。如：template<unsigned int a> class A{};   A<3> m; 即從int 到unsigned int的轉換。
　　　　　　五、常規轉換。

非類型形參演示示例1：

　　由用戶本身親自指定棧的大小，並實現棧的相關操做。

　　TemplateDemo.h

複製代碼 
 1 #ifndef TEMPLATE_DEMO_HXX
 2 #define TEMPLATE_DEMO_HXX
 3 
 4 template<class T,int MAXSIZE> class Stack{//MAXSIZE由用戶建立對象時自行設置
 5     private:
 6         T elems[MAXSIZE];    // 包含元素的數組
 7         int numElems;    // 元素的當前總個數
 8     public:
 9         Stack();    //構造函數
10         void push(T const&);    //壓入元素
11         void pop();        //彈出元素
12         T top() const;    //返回棧頂元素
13         bool empty() const{     // 返回棧是否爲空
14             return numElems == 0;
15         }
16         bool full() const{    // 返回棧是否已滿
17             return numElems == MAXSIZE;
18         }
19 };
20 
21 template <class T,int MAXSIZE> 
22 Stack<T,MAXSIZE>::Stack():numElems(0){     // 初始時棧不含元素
23     // 不作任何事情
24 }
25 
26 template <class T,int MAXSIZE>
27 void Stack<T, MAXSIZE>::push(T const& elem){
28     if(numElems == MAXSIZE){
29         throw std::out_of_range("Stack<>::push(): stack is full");
30     }
31     elems[numElems] = elem;   // 附加元素
32     ++numElems;               // 增長元素的個數
33 }
34 
35 template<class T,int MAXSIZE>
36 void Stack<T,MAXSIZE>::pop(){
37     if (numElems <= 0) {
38         throw std::out_of_range("Stack<>::pop(): empty stack");
39     }
40     --numElems;               // 減小元素的個數
41 }
42 
43 template <class T,int MAXSIZE>
44 T Stack<T,MAXSIZE>::top()const{
45     if (numElems <= 0) {
46         throw std::out_of_range("Stack<>::top(): empty stack");
47     }
48     return elems[numElems-1];  // 返回最後一個元素
49 }
50 
51 #endif
複製代碼

　　TemplateDemo.cpp

複製代碼 
 1 #include<iostream.h>
 2 #include <iostream>
 3 #include <string>
 4 #include <cstdlib>
 5 #include "TemplateDemo.h"
 6 
 7 int main(){
 8     try {
 9         Stack<int,20>  int20Stack;  // 能夠存儲20個int元素的棧
10         Stack<int,40>  int40Stack;  // 能夠存儲40個int元素的棧
11         Stack<std::string,40> stringStack; // 可存儲40個string元素的棧
12 
13         // 使用可存儲20個int元素的棧
14         int20Stack.push(7);
15         std::cout << int20Stack.top() << std::endl;    //7
16         int20Stack.pop();
17 
18         // 使用可存儲40個string的棧
19         stringStack.push("hello");
20         std::cout << stringStack.top() << std::endl;    //hello
21         stringStack.pop();    
22         stringStack.pop();    //Exception: Stack<>::pop<>: empty stack
23         return 0;
24     }
25     catch (std::exception const& ex) {
26         std::cerr << "Exception: " << ex.what() << std::endl;
27         return EXIT_FAILURE;  // 退出程序且有ERROR標記
28     }
29 }
複製代碼

　　運行結果：

　　　　

 非類型形參演示示例2：

　　TemplateDemo01.h

複製代碼 
 1 #ifndef TEMPLATE_DEMO_O1
 2 #define TEMPLATE_DEMO_01
 3 
 4 template<typename T> class CompareDemo{
 5     public:
 6         int compare(const T&, const T&);
 7 };
 8 
 9 template<typename T> 
10 int CompareDemo<T>::compare(const T& a,const T& b){
11     if((a-b)>0)
12         return 1;
13     else if((a-b)<0)
14         return -1;
15     else
16         return 0;
17 }
18 
19 #endif
複製代碼

　　TemplateDemo01.cpp

複製代碼 
1 #include<iostream.h>
2 #include "TemplateDemo01.h"
3 
4 void main(){
5     int> cd;
6     2,3)<<endl; 7 }
複製代碼

　　運行結果：　　　　　-1　

複製代碼 
1 #include<iostream.h>
2 #include "TemplateDemo01.h"
3 
4 void main(){
5     double> cd;
6     3.2,3.1)<<endl; 7 }
複製代碼

　　運行結果：　　　　class CompareDemo{ 5 public: 6 int ); 7 }; 8 9 template<typename T> 10 int CompareDemo<T>:: b){ 11 if((a-b)>0) 12 return 1; 13 else if((a-b)<0) 14 return -1; 15 else 16 return 0; 17 } 18 19 #endif

複製代碼

　　TempalteDemo01.cpp

複製代碼 
1 #include<iostream.h>
2 #include "TemplateDemo01.h"
3 
4 void main(){
5     CompareDemo<int> cd;
6     int a=2,b=3;
7     cout<<cd.compare(a,b)<<endl;
8 }
複製代碼

 

 非類型形參演示示例3：

　　TemplateDemo02.cpp

複製代碼 
 1 #include<iostream.h>
 2 
 3 template<typename T>
 4 const T& max(const T& a,const T& b){
 5     return a>b ? a:b;
 6 }
 7 
 8 void main(){
 9     cout<<//模板實參被隱式推演成double
10     cout<<double>(2.1,2.2)<<endl;//顯示指定模板參數。 11 cout<<int>(2.1,2.2)<<endl;//顯示指定的模板參數，會將函數函數直接轉換爲int。 12 }
複製代碼

　　運行結果：

　　　　　　　

cout<<int>(2.1,2.2)<<endl;//顯示指定的模板參數，會將函數函數直接轉換爲int。此語句會出現警告：
複製代碼 
1 --------------------Configuration: TemplateDemo02 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo02.cpp
4 G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) : 　　warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data
5 G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) : 　　warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data
6 
7 TemplateDemo02.obj - 0 error(s), 2 warning(s)
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程