数据结构----双端队列（Deque，顺序存储）C++模板

继承Queue得到

enum class Error_code
{
    success,
    underflow,
    overflow
};

const int maxqueue = 10;

template <typename Queue_entry>
class Queue
{
public:
    Queue();
    bool empty() const;
    Error_code serve();
    Error_code append(const Queue_entry &item);
    Error_code retrieve(Queue_entry &item) const;
    bool full() const;
    int size() const;
    void clear();
    Error_code serve_and_retrieve(Queue_entry &item);

protected:
    int count;
    int front, rear;
    Queue_entry entry[maxqueue];
};

template <typename Queue_entry>
Queue<Queue_entry>::Queue()
{
    this->count = 0;
    this->rear = maxqueue - 1;
    this->front = 0;
}

template <typename Queue_entry>
bool Queue<Queue_entry>::empty() const
{
    return this->count == 0;
}

template <typename Queue_entry>
Error_code Queue<Queue_entry>::serve()
{
    if (this->count <= 0)
        return Error_code::underflow;
    --this->count;
    this->front = ((this->front + 1) == maxqueue) ? 0 : (this->front + 1);
    return Error_code::success;
}

template <typename Queue_entry>
Error_code Queue<Queue_entry>::append(const Queue_entry &item)
{
    if (this->count >= maxqueue)
        return Error_code::overflow;
    ++this->count;
    this->rear = ((this->rear + 1) == maxqueue) ? 0 : (this->rear + 1);
    this->entry[this->rear] = item;
    return Error_code::success;
}

template <typename Queue_entry>
Error_code Queue<Queue_entry>::retrieve(Queue_entry &item) const
{
    if (this->count <= 0)
        return Error_code::underflow;
    item = this->entry[this->front];
    return Error_code::success;
}

template <typename Queue_entry>
bool Queue<Queue_entry>::full() const
{
    return this->count == maxqueue;
}

template <typename Queue_entry>
void Queue<Queue_entry>::clear()
{
    this->count = 0;
    this->front = 0;
    this->rear = maxqueue - 1;
}

template <typename Queue_entry>
int Queue<Queue_entry>::size() const
{
    return this->count;
}

template <typename Queue_entry>
Error_code Queue<Queue_entry>::serve_and_retrieve(Queue_entry &item)
{
    if (this->count <= 0)
        return Error_code::underflow;
    --this->count;
    item = this->entry[this->front];
    this->front = ((this->front + 1) == maxqueue) ? 0 : (this->front + 1);
    return Error_code::success;
}

template <typename Deque_entry>
class Deque : private Queue<Deque_entry>
{
public:
    Deque();
    bool empty() const;
    Error_code serve_front();
    Error_code serve_rear();
    Error_code append_front(const Deque_entry &item);
    Error_code append_rear(const Deque_entry &item);
    Error_code retrieve_front(Deque_entry &item) const;
    Error_code retrieve_rear(Deque_entry &item) const;
};

template <typename Deque_entry>
Deque<Deque_entry>::Deque()
{
    Queue<Deque_entry>::Queue();
}

template <typename Deque_entry>
bool Deque<Deque_entry>::empty() const
{
    return this->count <= 0;
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::append_front(const Deque_entry &item)
{
    if (this->count >= maxqueue)
        return Error_code::overflow;
    this->front = (this->front + maxqueue - 1) % maxqueue;
    this->entry[this->front] = item;
    ++this->count;
    return Error_code::success;
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::serve_front()
{
    return this->serve();
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::retrieve_front(Deque_entry &item) const
{
    return this->retrieve(item);
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::append_rear(const Deque_entry &item)
{
    return this->append(item);
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::serve_rear()
{
    if (this->count <= 0)
        return Error_code::underflow;
    this->rear = (this->rear + maxqueue - 1) % maxqueue;
    --this->count;
    return Error_code::success;
}

template <typename Deque_entry>
Error_code Deque<Deque_entry>::retrieve_rear(Deque_entry &item) const
{
    if (this->count <= 0)
        return Error_code::underflow;
    item = this->entry[this->rear];
    return Error_code::success;
}