2. 程式人生 > >6、【C++】模板

6、【C++】模板

阿新 • • 發佈：2018-11-04

C++ 模板

    模板是泛型程式設計的基礎，泛型程式設計即以一種獨立於任何特定型別的方式編寫程式碼。

1、函式模板
    int swap(int &a, int &b){int temp = a;a = b; b=temp;}
    float swap(float &a, float &b){float temp = a;a = b; b=temp;}
    char swap(char &a, char &b){char temp = a;a = b; b=temp;}

    在這上面三條語句當中，int float char 這三種資料型別，但是他們具體實現的函式是一樣的，所以我們就是想把函式作為引數傳入進去，然後讓計算機幫我們實現這三條語句的編寫。

函式模板關鍵字：template；typename;class

    函式模板可以用來建立一個通用的函式，以支援多種不同的形參，避免過載函式的函式體重複設計。它的最大特點是把函式使用的資料型別作為引數。

函式模板的宣告形式為：

    template<typename 資料型別引數識別符號>
    <返回型別><函式名>(引數表)
    {
	  函式體
    }

【示例】

//method.h
template<typename T> void swap(T& t1, T& t2);

#include "method.cpp"
 


template<typename  T> 
void swap(T& t1, T& t2) {
    T tmpT;
    tmpT = t1;
    t1 = t2;
    t2 = tmpT;
}

//main.cpp
#include <stdio.h>
#include "method.h"
int main() {
    //模板方法 
    int num1 = 1, num2 = 2;
    swap<int>(num1, num2);
    printf("num1:%d, num2:%d\n", num1,
 
 num2);  
    return 0;
}

    這裡使用swap函式，必須包含swap的定義，否則編譯會出錯，這個和一般的函式使用不一樣。所以必須在method.h檔案中加入#include “method.cpp”。

2、類模板

    正如我們定義函式模板一樣，我們也可以定義類模板。泛型類宣告的一般形式如下所示：

template <class type> class class-name 
{
	……
}

    在這裡，type 是佔位符型別名稱，可以在類被例項化的時候進行指定。您可以使用一個逗號分隔的列表來定義多個泛型資料型別。

    考慮我們寫一個簡單的棧的類，這個棧可以支援int型別，long型別，string型別等等，不利用類模板，我們就要寫三個以上的stack類，其中程式碼基本一樣，通過類模板，我們可以定義一個簡單的棧模板，再根據需要例項化為int棧，long棧，string棧。
類模板定義

//類模板定義
//statck.h
template <class T> 
class Stack {
public:
    Stack();//建構函式
    ~Stack();//解構函式
    void push(T t);
    T pop();
    bool isEmpty();
private:
    T *m_pT;        
    int m_maxSize;
    int m_size;
};

//stack.cpp
//建構函式
template <class  T>  
Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
//解構函式
template <class T>  
Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> 
void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> 
T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> 
bool Stack<T>::isEmpty() {
    return m_size == 0;
}

//main.cpp
#include <stdio.h>
#include "stack.h"
int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    
    while (!intStack.isEmpty()) {
        printf("num:%d\n", intStack.pop());
    }
    return 0;
}
3、模板引數

    模板可以有型別引數，也可以有常規的型別引數int，也可以有預設模板引數，例如：

template<class T, T def_val> 
class Stack
{
	...
}

    在類模板的示例中，有一個限制，就是最多隻能支援100個元素，我們可以使用模板引數配置這個棧的最大元素數,如果不配置，就設定預設最大值為100，程式碼如下:

//statck.h
template <class T,int maxsize = 100> 
class Stack {
public:
    Stack();
    ~Stack();
    void push(T t);
    T pop();
    bool isEmpty();
private:
    T *m_pT;        
    int m_maxSize;
    int m_size;
};

//stack.cpp
template <class T,int maxsize> 
Stack<T, maxsize>::Stack(){
   m_maxSize = maxsize;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T,int maxsize>  
Stack<T, maxsize>::~Stack() {
   delete [] m_pT ;
}
        
template <class T,int maxsize> 
void Stack<T, maxsize>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T,int maxsize> 
T Stack<T, maxsize>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T,int maxsize> 
bool Stack<T, maxsize>::isEmpty() {
    return m_size == 0;
}

//main.cpp
#include <stdio.h>
#include "stack.h"
int main() {
    int maxsize = 1024;
    Stack<int,1024> intStack;
    for (int i = 0; i < maxsize; i++) {
        intStack.push(i);
    }
    while (!intStack.isEmpty()) {
        printf("num:%d\n", intStack.pop());
    }
    return 0;
}
4、模板專門化

    當我們要定義模板的不同實現，我們可以使用模板的專門化。例如我們定義的stack類模板，如果是char*型別的棧，我們希望可以複製char的所有資料到stack類中，因為只是儲存char指標，char指標指向的記憶體有可能會失效，stack彈出的堆疊元素char指標，指向的記憶體可能已經無效了。還有我們定義的swap函式模板，在vector或者list等容器型別時，如果容器儲存的物件很大，會佔用大量記憶體，效能下降，因為要產生一個臨時的大物件儲存a，這些都需要模板的專門化才能解決。

（1）函式模板專門化

    假設我們swap函式要處理一個情況，我們有兩個很多元素的vector,在使用原來的swap函式，執行tmpT = t1要拷貝t1的全部元素，佔用大量記憶體，造成效能下降，於是我們系統通過vector.swap函式解決這個問題,程式碼如下:

//method.h
#include "method.cpp"

template<class T> void swap(T& t1, T& t2);

#include <vector>
using namespace std;
template<class T> 
void swap(T& t1, T& t2) {
    T tmpT;
    tmpT = t1;
    t1 = t2;
    t2 = tmpT;
}
//模板專門化
template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}

    template<>字首表示這是一個專門化,描述時不用模板引數，使用示例如下:

//main.cpp
#include <stdio.h>
#include <vector>
#include <string>
#include "method.h"
int main() {
    using namespace std;
    //模板方法 
    string str1 = "1", str2 = "2";
    swap(str1, str2);
    printf("str1:%s, str2:%s\n", str1.c_str(), str2.c_str());  
    
    vector<int> v1, v2;
    v1.push_back(1);
    v2.push_back(2);
    swap(v1, v2);
    for (int i = 0; i < v1.size(); i++) {
        printf("v1[%d]:%d\n", i, v1[i]);
    }
    for (int i = 0; i < v2.size(); i++) {
        printf("v2[%d]:%d\n", i, v2[i]);
    }
    return 0;
}

    vector的swap程式碼還是比較侷限，如果要用模板專門化解決所有vector的swap，該如何做呢，只需要把下面程式碼

template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}

    改為

template<class V> void swap(std::vector<V>& t1, std::vector<V>& t2) {
    t1.swap(t2);
}

    就可以了，其他程式碼不變。

（2）類模板專門化

//compare.h
template <class T>
class compare
{
public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};

#include <iostream>
#include "compare.h"
int main()
{
  using namespace std;
  char str1[] = "Hello";
  char str2[] = "Hello";
  compare<int> c1;
  compare<char *> c2;   
  cout << c1.equal(1, 1) << endl;        //比較兩個int型別的引數
  cout << c2.equal(str1, str2) << endl;   //比較兩個char *型別的引數
  return 0;
}

    在比較兩個整數，compare的equal方法是正確的，但是compare的模板引數是char*時，這個模板就不能工作了，於是修改如下:

//compare.h
#include <string.h>
template <class T>
class compare
{
public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};
   
template<>class compare<char *>  
{
public:
    bool equal(char* t1, char* t2)
    {
        return strcmp(t1, t2) == 0;
    }
};

    main.cpp檔案不變，此程式碼可以正常工作。

5、模板型別轉換

    還記得我們自定義的Stack模板嗎，在我們的程式中，假設我們定義了Shape和Circle類，程式碼如下:

//shape.h
class Shape {

};
class Circle : public Shape {
};

    然後我們希望可以這麼使用:

//main.cpp
#include <stdio.h>
#include "stack.h"
#include "shape.h"
int main() {
    Stack<Circle*> pcircleStack;
    Stack<Shape*> pshapeStack;
    pcircleStack.push(new Circle);
    pshapeStack = pcircleStack;
    return 0;
}

    這裡是無法編譯的，因為Stack<Shape*>不是Stack<Circle*>的父類，然而我們卻希望程式碼可以這麼工作，那我們就要定義轉換運算子了，Stack程式碼如下:

//statck.h
template <class T> 
class Stack {
public:
    Stack();
    ~Stack();
    void push(T t);
    T pop();
    bool isEmpty();
    template<class T2>  operator Stack<T2>();
private:
    T *m_pT;        
    int m_maxSize;
    int m_size;
};

#include "stack.cpp"

template <class  T>  
Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  
Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> 
void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> 
T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> 
bool Stack<T>::isEmpty() {
    return m_size == 0;
}

template <class T> template <class T2>  
Stack<T>::operator Stack<T2>() {
    Stack<T2> StackT2;
    for (int i = 0; i < m_size; i++) {
        StackT2.push((T2)m_pT[m_size - 1]);
    }
    return StackT2;
}

//main.cpp
#include <stdio.h>
#include "stack.h"
#include "shape.h"
int main() {
    Stack<Circle*> pcircleStack;
    Stack<Shape*> pshapeStack;
    pcircleStack.push(new Circle);
    pshapeStack = pcircleStack;
    return 0;
}

    這樣，Stack 或者Stack<Circle*>就可以自動轉換為Stack或者Stack<Shape*>,如果轉換的型別是Stack到Stack，編譯器會報錯。

6、其他

     一個類沒有模板引數，但是成員函式有模板引數，是可行的，程式碼如下:

class Util {
public:
    template <class T> bool equal(T t1, T t2) {
        return t1 == t2;
    }
};

int main() {
    Util util;
    int a = 1, b = 2;
    util.equal<int>(1, 2);
    return 0;
}

     甚至可以把Util的equal宣告為static,程式碼如下:

class Util {
public:
     template <class T> static bool equal(T t1, T t2) {
        return t1 == t2;
    }
};

int main() {
    int a = 1, b = 2;
    Util::equal<int>(1, 2);
    return 0;
}

相關推薦

6、【C++】模板

C++ 模板     模板是泛型程式設計的基礎，泛型程式設計即以一種獨立於任何特定型別的方式編寫程式碼。 1、函式模板 int swap(int &a, int &b){int temp = a;a = b; b=temp;} float swap

15、【C++】C++11新特性：Lamda表示式/可變引數模板

一、Lamda表示式     Lamda表示式是C++11中引入的一項新技術，利用Lamda表示式可以編寫內嵌的匿名函式，用以替換獨立函式或者函式物件，並且使得程式碼更可讀。是一種匿名函式，即沒有函式名的函式；Lamda函式的語法定義如下： [capture] ：捕捉

11、【C++】匈牙利命名法

    對於程式中的變數名稱，有人主張儘量讓變數名簡單易懂。在定義變數時，不僅讓變數名稱易於理解，而且資料型別、屬效能夠一眼看出，這種觀念的命名稱為匈牙利命名。     匈牙利命名法是一種程式設計時的命名規範。這種命名法的出發點是把變數名按：屬性+型別+物件描述的順序組合起來，以使程式設計師

9、【C++】記憶體洩露

記憶體洩露 1、記憶體洩露的定義     一般我們常說的記憶體洩漏是指堆記憶體的洩漏。堆記憶體是指程式從堆中分配的，大小任意的（記憶體塊的大小可以在程式執行期決定），使用完後必須顯示釋放的記憶體。     應用程式一般使用malloc，realloc，new等函式從堆中分配到一塊

8、【C++】記憶體管理

C++記憶體管理 一、記憶體分配方式     在C++中記憶體被分為5個區，分別是：棧區、堆區、自由儲存區、全域性/靜態儲存區和常量儲存區。 1、棧區     在執行函式時，函式內區域性變數的儲存單元都可一在棧上建立，函式執行結束時，這些儲存單元自動被釋放。棧記憶體分配運算內建與

7、【C++】單例模式/工廠模式

一、單例模式     單例模式，可以說設計模式中最常應用的一種模式了，據說也是面試官最喜歡的題目。但是如果沒有學過設計模式的人，可能不會想到要去應用單例模式，面對單例模式適用的情況，可能會優先考慮使用全域性或者靜態變數的方式，這樣比較簡單，也是沒學過設計模式的人所能想到的最簡單的方式了。

5、【C++】指標/引用（指標和引用的區別）

一、指標 int p=12; int *q; int *q=&p;     這裡p為int型別的變數，&p就是p的記憶體地址，*q是一個int型別的變數（是一個值），q為指標是地址，int q=&p;把p的地址賦給了指標q,所以q就

4、【C++】靜態成員變數/靜態成員函式/行內函數/友元函式/友元類/友元成員函式

一、靜態成員     我們可以使用 static 關鍵字來把類成員定義為靜態的。當我們宣告類的成員為靜態時，這意味著無論建立多少個類的物件，靜態成員都只有一個副本。     靜態成員在類的所有物件中是共享的。如果不存在其他的初始化語句，在建立第一個物件時，所有的靜態資料都會被初始化為

3、【C++】繼承/多型

    面向物件的三個基本特徵是：封裝、繼承、多型。其中，封裝可以隱藏實現細節，使得程式碼模組化；繼承可以擴充套件已存在的程式碼模組（類）；它們的目的都是為了——程式碼重用。而多型則是為了實現另一個目的——介面重用！     封裝：將一類事物所共有的屬性和行為方法進行總結，封裝在一個類中

2、【C++】資料抽象/資料封裝/介面（抽象類）

一、C++資料抽象 1、定義     資料抽象是指，只向外界提供關鍵資訊，並隱藏其後臺的實現細節，即只表現必要的資訊而不呈現細節。資料抽象是一種依賴於介面和實現分離的程式設計（設計）技術。     C++類為資料抽象提供了可能。它們向外界提供了大量用於操作物件資料的公共方法，也就

1、【C++】類&物件/建構函式/拷貝建構函式/操作符過載/解構函式

一、C++類 & 物件     C++ 在 C 語言的基礎上增加了面向物件程式設計，C++ 支援面向物件程式設計。類是 C++ 的核心特性，通常被稱為使用者定義的型別。     類用於指定物件的形式，它包含了資料表示法和用於處理資料的方法。類中的資料和方法稱為類的成員。函式在

6、【Python】一些常用模組

python 常用模組 1、Time模組 import time print (time.time())#返回時間戳 print(time.localtime())#返回本地時間 print (time.gmtime()) #返回標準時間（格林威治時間） #將本地時間格式化輸出

10、【C++】前向宣告、巢狀類、區域性類（內部類）

一、前向宣告     在C++中，類需要先定義，而後才能被例項化，但是實際存在一種場景是：兩個類需要相互引用或相互成為類中的子物件成員時，就無法先定義使用，在編譯環節就出現錯誤導致編譯失敗，這時就需要用到前向宣告，此外，前向宣告的類不能被例項化。 【示例】 //

【C++】模板類連結串列

上一篇部落格介紹了模板類順序表，此篇部落格主要是模板類連結串列的實現。 #pragma once #include<iostream> #include<string> using namespace std; template<typena

【C++】模板實現帶頭節點的雙向迴圈連結串列

連結串列分為帶頭節點和不帶頭節點，單鏈表和雙向迴圈連結串列。 帶頭節點的連結串列雖然有頭結點，但是並不儲存資料，雙向迴圈鏈有指向前一個數的指標和指向後一個數的指標。 如下圖： 先來實現一些主要的函式： List的建構函式和解構函式： List() {

【C++】模板函式及模板類

常用模板類的情況#include<iostream> using namespace std; //模板函式，一個模板引數 template<typename T> T fun1(T a,T b){ if(a>b) {

Debug目錄、Release目錄，bin目錄、obj目錄，vshost.exe.config文件、.exe.config文件分析【C#】

修改 .com 重啟 不同 span http ocs 資料 更改 Debug目錄、Release目錄，bin目錄、obj目錄，vshost.exe.config文件、.exe.config文件分析【C#】 2013-10-06 孤風卓影 摘自 csdn博客 閱 5

【C++】最近公共祖先LCA（Tarjan離線算法）&& 洛谷P3379LCA模板

target sizeof add 例題 開始 實現 再看 根節點 strong 1.前言 　　首先我們介紹的算法是LCA問題中的離線算法-Tarjan算法，該算法采用DFS+並查集，再看此算法之前首先你得知道並查集（盡管我相信你如果知道這個的話肯定是知道並查集的），

【C】wchar、char格式化符輸出

div mar class cnblogs ive pos arc 編譯器 align VC、BCB、MinGW Linux下的GCC、C99標準 printf wprintf printf wprintf s char wchar_t char S wc

【C++】遞歸 課後習題3-13、3-14

int serve cnblogs code log eat n) include mark // // main.cpp // 3-13遞歸Fibonacci級數 // // Created by T.P on 2018/3/21. // Copyright ?