介面卡

概述

介面卡模式將一個類的介面轉換成客戶希望的另外一個介面，使得原本由於介面不相容而不能一起工作的那些類可以一起工作。

用介面卡配出棧和佇列

 用順序表和連結串列適配出棧和佇列。
用介面卡適配出棧

template <class T,class Container> //普通模板引數

class Stack
{
public:
    void StackPush(const T& s){_con.PushBack(s);} //入棧
    void StackPop(){_con.PopBack();}//出棧
    T& StackTop(){return
 
 _con.Back();}//取得棧頂元素
    bool StackEmpty(){return _con.Empty();}//判斷棧是否為空
protected:
    Container _con; //普通模板引數
};

測試

void StackTest()
{
    Stack<int,Vector<int>> s;
    s.StackPush(1);
    s.StackPush(2);
    s.StackPush(3);
    s.StackPush(4);
    s.StackPush(5);

    while (!s.StackEmpty())
    {
        cout
 
<<s.StackTop()<<" ";
        s.StackPop();
    }
    cout<<endl;

    Stack<string,List<string>> s1;
    s1.StackPush("hello");
    s1.StackPush("world");
    s1.StackPush("welcome");
    s1.StackPush("you");
    s1.StackPush("!");

    while (!s1.StackEmpty())
    {
        cout
 
<<s1.StackTop()<<" ";
        s1.StackPop();
    }
    cout<<endl;
}

這樣我們就很輕鬆的利用順序表和連結串列適配出了棧
用介面卡適配出佇列

template<class T,class Container>
class Queue
{
public:
    void PushBack(const T& q){_con.PushBack(q);}//入隊
    void PopFront(){_con.PopFront();}//出隊
    T& Front(){return _con.Front();}//取隊頭元素
    int Size(){return _con.Size();}//求佇列大小
    bool Empty(){return _con.Empty();}//判斷佇列是否為空
protected:
    Container _con;
};

測試

void QueueTest()
{
    Queue<int,Vector<int>> q;
    q.PushBack(1);
    q.PushBack(2);
    q.PushBack(3);
    q.PushBack(4);
    q.PushBack(5);

    while (!q.Empty())
    {
        cout<<q.Front()<<" ";
        q.PopFront();
    }
    cout<<endl;

    Queue<string,List<string>> q1;
    q1.PushBack("change");
    q1.PushBack("my");
    q1.PushBack("world");
    q1.PushBack("come");
    q1.PushBack("on !");

    while (!q1.Empty())
    {
        cout<<q1.Front()<<" ";
        q1.PopFront();
    }
    cout<<endl;
}

這樣我們就很輕鬆的利用順序表和連結串列適配出了佇列

模板的模板引數

上面看起來已經解決了問題，但是如果我不小心這樣寫了這樣的程式碼：

void QueueTest()
{
    Queue<int,Vector<char>> q; //兩個型別不一樣
    Queue<string,List<int>> q1; //兩個型別不一樣

}

這樣的話是不是就會很坑，妥妥的錯。為了防止你寫出這樣的程式碼，有一種模板引數的方式就杜絕了這種不必要的麻煩。

template <class T,template<class> class Container> //模板的模板引數
class Stack
{
public:
    void StackPush(const T& s){_con.PushBack(s);} //入棧
    void StackPop(){_con.PopBack();}//出棧
    T& StackTop(){return _con.Back();}//取得棧頂元素
    bool StackEmpty(){return _con.Empty();}//判斷棧是否為空
protected:
    Container<T> _con; //模板的模板引數
};

如果這樣寫就很好解決了防止你把型別傳的不一樣而導致不必要的錯誤。

模板的非型別引數

非型別類模板引數

舉個例子，假如你要實現動態陣列，而且在一個函式裡面要用到不同型別的陣列，那我們就可以這樣。直接看程式碼：

template<class T,size_t N>
class Array
{
protected:
    T array[N];
};

非型別函式模板引數

template<class T,size_t N>
T Add（const T& x）
{
    return x+N;
}

非型別模板引數的限制

• 它可以是常整數（包括enum列舉型別）或者指向外部連結物件的指標。
• 浮點數和類物件（class-type）不允許作為非型別模板引數
• 非型別模板引數可以是指標，但該指標必須指向外部連結物件