适配器queue---deque/List做空间配置器实现

用deque(双端链表)实现queue，
源代码：

#pragma once

#include<stdio.h>
#include<deque>
#include<iostream>
using namespace std;
//用双端队列做空间配置器来实现队列
template<class T,class Con = deque<T> >
class Queue
{
public:
    typedef size_t SizeType;
    typedef T ValueType;
public:
    Queue()
    {}

    void Push(const ValueType data)
    {
        _con.push_back(data);
    }

    void Pop()
    {
        _con.pop_front();
    }

    bool Empty()
    {
        return _con.empty();
    }

    SizeType Size()
    {
        return _con.size();
    }

    ValueType& Front()
    {
        return _con.front();
    }

    const ValueType& Front()const
    {
        return _con.front();
    }
    ValueType& Back()
    {
        return _con.back();
    }
    const ValueType& Back()const
    {
        return _con.Back();
    }

private:
    Con _con;
};

用List做空间配置器实现queue
源代码：

template<class T>
struct ListNode
{
    ListNode(const T& data = T())
        : _prev(0)
        , _next(0)
        , _data(data)
    {}

    ListNode<T>* _prev;
    ListNode<T>* _next;
    T _data;
};


template<class T, class Ref, class Ptr>
class __ListIterator__
{
    typedef __ListIterator__<T, T&, T*> Iterator;
    typedef __ListIterator__<T, const T&, const T*> ConstIterator;
    typedef __ListIterator__<T, Ref, Ptr> Self;
    typedef ListNode<T>* LinkType;
    typedef Ref Reference;
    typedef Ptr Pointer;

public:
    __ListIterator__(LinkType x = 0)
        :_node(x)
    {}

    __ListIterator__(const Iterator& x)
    {
        _node = x._node;
    }

    bool operator==(const Iterator& x)
    {
        return _node == x._node;
    }

    bool operator!=(const Iterator& x)
    {
        return _node != x._node;
    }

    Reference operator*()
    {
        return (*_node)._data;
    }

    Pointer operator->()
    {
        return &(operator*());
    }

    Self& operator++()
    {
        _node = _node->_next;
        return *this;
    }
    Self operator++(int)
    {
        Self pTemp(*this);
        _node = _node->_next;
        return pTemp;
    }
    Self& operator--()
    {
        _node = _node->_prev;
        return *this;
    }
    Self operator--(int)
    {
        Self pTemp(*this);
        _node = _node->_prev;
        return pTemp;
    }
public:
    LinkType _node;
};

//空间配置器List类模板
template<class T>
class List
{
public:
    typedef ListNode<T> Node;
    typedef T ValueType;
    typedef ValueType& Reference;
    typedef const ValueType& ConstReference;
    typedef ValueType* Pointer;
    typedef const ValueType* ConstPointer;
    typedef Node* LinkType;
    typedef size_t SizeType;
    typedef __ListIterator__<T, T&, T*> Iterator;
    typedef __ListIterator__<T, const T&, const T*> ConstIterator;

public:
    //构造函数
    List()
    {
        EmptyInit();
    }
    List(SizeType n, const T& data)
    {
        EmptyInit();
        for(size_t idx=0; idx<n; ++idx)
        {
            PushBack(data);
        }
    }

    //拷贝构造函数
    List(const List<T>& l)
    {
        EmptyInit();
        Iterator it = l._node->_next;
        for(SizeType idx=0; idx<l.Size(); ++idx)
        {
            PushBack(it._node->_data);
            it++;
        }
    }

    //析构函数
    ~List()
    {
        /*Iterator it = End();
        --it;
        while(it!=_node)
        {
            delete it._node;
            --it;
        }*/
        Clear();

        delete _node;
    }
    //赋值运算符重载
    //List<T>& operator=(const List<T>& l)
    //{
    //  List<T> pTempList(l);
    //  if(this != &l)
    //  {
    //      Iterator it = --End();
    //      while(it != _node)
    //      {
    //          it = Erase(it);
    //      }
    //      //Clear();//错误
    //      delete _node;
    //      _node = pTempList._node;
    //  }
    //  return *this;
    //}

    //
    Iterator Begin()
    {
        return _node->_next;
    }
    ConstIterator Begin()const
    {
        return _node->_next;
    }
    Iterator End()
    {
        return _node;
    }
    ConstIterator End()const
    {
        return _node;
    }
    bool Empty()
    {
        return _node==_node->_next;
    }
    SizeType Size()const
    {
        Iterator it = _node->_next;
        SizeType count = 0;
        while(it != _node)
        {
            count = count+1;
            it++;
        }
        return count;
    }

    SizeType MaxSize()const
    {
        return SizeType(-1);
    }
    Reference Front()
    {
        return *(Begin());
    }
    ConstReference Front()const
    {
        return *(Begin());
    }
    Reference Back()
    {
        return *(--End());
    }
    ConstReference Back()const
    {
        return *(--End());
    }
    Iterator Insert(Iterator pos, const T& x = T())
    {
        LinkType temp = new Node(x);
        temp->_next = pos._node;
        temp->_prev = pos._node->_prev;
        pos._node->_prev->_next = temp;
        pos._node->_prev = temp;
        return temp;
    }
    void PushFront(const T& x)
    {
        Insert(Begin(),x);
    }

    void PushBack(const T& x)
    {
        Iterator it = End();
        Insert(it,x);
    }
    //任意位置删除
    Iterator Erase(Iterator pos)
    {
        Iterator pRemNode = pos._node->_next;
        pos._node->_prev->_next= pos._node->_next;
        pos._node->_next->_prev = pos._node->_prev;

        pos._node->_next = pos._node->_prev = NULL;
        delete pos ._node;
        return pRemNode;
    }
    void PopFront()
    {
        Erase(Begin());
    }
    void PopBack()
    {
        Erase(--End());
    }
    void ReSize(SizeType n, const T& data)
    {
        if(Size() >= n)
            {
                SizeType size1 = Size()-n; 
                while(size1--)
                {
                    PopBack();
                }
            }
            else
            {
                SizeType size2 = n-Size();
                while(size2--)
                {
                    PushBack(data);
                }
            }
    }
    void Assign(SizeType n, const T& data)
    {
        Iterator pTemp = _node->_next;
        if(Size()>=n)
        {
            for(size_t idx=0;idx<n; ++idx)
            {
                pTemp._node->_data = data;
                ++pTemp;
            }
            for(size_t idx = 0; idx<Size()-n; ++idx)
            {
                PopBack();
            }
        }
        else
        {
            pTemp = _node->_next;
            size_t size = Size();
            for(size_t idx=0; idx<size; ++idx)
            {
                pTemp._node->_data = data;
                ++pTemp;
            }
            for(size_t idx = 0;idx<n-size; ++idx)
            {
                PushBack(data);
            }
        }
    }
    void Clear()
    {
        Iterator it = --End();
        while(it != _node)
        {
            it = Erase(it);
        }
        _node->_next = _node;
        _node->_prev = _node;
    }
private:
    void EmptyInit()
    {
        _node = new Node;
        _node->_data = 0;
        _node->_next = _node ;
        _node->_prev = _node;
    }
protected:
    LinkType _node;
};
//Queue的模板类
template<class T,class Con = List<T> >
class Queue
{
public:
    typedef size_t SizeType;
    typedef T ValueType;
public:
    Queue()
    {}
    void Push(const ValueType data)
    {
        _con.PushBack(data);
    }
    void Pop()
    {
        _con.PopFront();
    }
    bool Empty()
    {
        return _con.Empty();
    }
    SizeType Size()const
    {
        return _con.Size();
    }
    ValueType& Front()
    {
        return _con.Front();
    }
    const ValueType& Front()const
    {
        return _con.Front();
    }
    ValueType& Back()
    {
        return _con.Back();
    }
    const ValueType& Back()const
    {
        return _con.Back();
    }
private:
    Con _con;
};