每日一題22：Deque與Trait

雖然之前寫過一個Deque，但是那個屬於C與C++混合的產品，近來在學習C++模板，所以寫了一個C++版，同時第一次嘗試使用Trait技術。
本來已經寫好的文章，發表之後丟失了，好鬱悶，沒心情再寫了，貼貼代碼吧。

這個Trait是用來決定傳遞參數時是使用值傳遞還是引用傳遞

#ifndef _TYPE_TRAITS_H_
#define _TYPE_TRAITS_H_

namespace MyDataStructure
{
    template<typename T>
    class ParameterTrait
    {
    private:
        template<typename U>
        struct __ParaTrait
        {
            typedef U& ParameterType;
        };

        template<typename U>
        struct __ParaTrait<U*>
        {
            typedef U ParameterType;
        };

        template<typename U>
        struct __ParaTrait<U&>
        {
            typedef typename __ParaTrait<U>::ParameterType ParameterType;
        };

        template<>
        struct __ParaTrait<char>
        {
            typedef char ParameterType;
        };

        template<>
        struct __ParaTrait<unsigned char>
        {
            typedef unsigned char ParameterType;
        };

        template<>
        struct __ParaTrait<int>
        {
            typedef int ParameterType;
        };

        template<>
        struct __ParaTrait<unsigned int>
        {
            typedef unsigned int ParameterType;
        };

    public:
        typedef typename __ParaTrait<T>::ParameterType ParameterType;
    };
}

#endif

模板情況下實現的雙端隊列（其實這個只是雙向鏈表，真正的雙端隊列比這個複雜太多了）：

#ifndef _DEQUE_H_
#define _DEQUE_H_

#include "..\Utilites\type_traits.h"

namespace MyDataStructure
{
    template<typename T>
    class BiDirectionNode
    {
    private:
        typedef typename ParameterTrait<T>::ParameterType ParameterType;
    public:
        BiDirectionNode(const ParameterType value) : value(value),next(nullptr),pre(nullptr) {}
        BiDirectionNode(const BiDirectionNode& n)
        {
            _copy(n);
        }

        BiDirectionNode& operator = (const BiDirectionNode& n)
        {
            _copy(n);
            return *this;
        }
        T Value() const { return value; }
        T& Value() { return value; }
        T* Next() { return next; }
    public:
        void _copy(const BiDirectionNode& n)
        {
            value = n.value;
            next = n.next;
            pre = n.pre;
        }
        T value;
        BiDirectionNode* pre;
        BiDirectionNode* next;
    };

    template<typename T>
    class Deque
    {
    private:
        typedef typename BiDirectionNode<T> NodeType;
        typedef typename ParameterTrait<T>::ParameterType ParameterType;
    public:
        Deque() : size(0), head(nullptr),tail(nullptr){}
        Deque(const Deque& d){ _copy(d); }
        Deque& operator=(const Deque& d){ _destroy(); _copy(d); return *this; }
        ~Deque(){ _destroy(); }
        void Clear() { _destroy(); }
        const int Size() { return size; }
        bool Empty(){ return size == 0; }
        void Push(const ParameterType value)
        {
            NodeType* n = new NodeType(value);
            _push(n);
        }
        void Insert(const ParameterType value)
        {
            NodeType* n = new NodeType(value);
            _insert(n);
        }
        bool Pop(T& value)
        {
            if (size == 0)
                return false;
            value = head->value;
            NodeType* p = head;
            if (size == 1)
            {
                head = tail = nullptr;
            }
            else
            {
                head = head->next;
                head->pre = nullptr;
            }
            --size;
            delete p;
            return true;
        }
        bool Eject(T& value)
        {
            if (size == 0)
                return false;
            value = tail->value;
            NodeType* p = tail;
            if (size == 1)
            {
                head = tail = nullptr;
            }
            else
            {
                tail = tail->pre;
                tail->next = nullptr;
            }

            --size;
            delete p;
            return true;
        }
    private:
        void _push( NodeType* n)
        {
            if (size == 0)
            {
                head = n;
                head->next = nullptr;
                head->pre = nullptr;
                tail = head;
            }
            else
            {
                n->next = head;
                n->pre = nullptr;
                head->pre = n;
                head = n;
            }
            ++size;
        }
        void _insert( NodeType* n)
        {
            if (size == 0)
            {
                head = n;
                head->next = nullptr;
                head->pre = nullptr;
                tail = head;
            }
            else
            {
                tail->next = n;
                n->pre = tail;
                n->next = nullptr;
                tail = n;
            }
            ++size;
        }
        void _copy(const Deque& d)
        {
            NodeType* node = d.head;
            while (node)
            {
                NodeType* newNode = new NodeType(*node);
                _insert(newNode);
                node = node->next;
            }
        }
        void _destroy()
        {
            NodeType* node = head;
            while (node)
            {
                NodeType* p = node->next;
                delete node;
                node = p;
            }
            head = tail = nullptr;
            size = 0;
        }
    private:
        int size;
        NodeType* head;
        NodeType* tail;
    };
}

#endif

測試代碼：

// Deque.cpp : 定義控制檯應用程序的入口點。
//

#include "stdafx.h"
#include "Deque.h"
#include <iostream>
#include <deque>

using namespace std;

using namespace MyDataStructure;

int _tmain(int argc, _TCHAR* argv[])
{
    Deque<int> d;
    for (int i = 0; i < 10; ++i)
    {
        d.Insert(i);
    }
    Deque<int> d2;
    Deque<int> d1 = d2 = d;

    int value;
    for (int i = 0; i < 10; ++i)
    {
        if (d1.Eject(value))
            cout << value << ' ';
    }
    cout << endl;
    for (int i = 0; i < 10; ++i)
    {
        if (d2.Eject(value))
            cout << value << ' ';
    }
    cout << endl;
    for (int i = 0; i < 10; ++i)
    {
        if (d.Eject(value))
            cout << value << ' ';
    }
    cout << endl;
    cout << d.Size() << endl;
    d.Clear();
    d1.Clear();
    d2.Clear();
    return 0;
}

運行結果：

本次寫博客的經驗是：1）以後註釋直接寫在源文件裏，不要到了寫博客的時候才寫在博文裏。2）如果你是寫了一半保存在線上，下次寫完發表時，請先保存一下再發表，不然如果馬上再來修改已經發表的文章的時候，只有之前的一半內容。已被坑死！