C++实现队列（数组)

描述

最近发现自己越来越菜，然后翻了一下数据结构的书，然后又想起自己的C++语法太菜了，决定写一下基本的数据结构来练一下手.然后我就对队列下手了，是利用数组来实现的。流下没有技术的眼泪！T_T

代码

#pragma once
#ifndef MYQUEUE_H
#define MYQUEUE_H

#include <assert.h>
#include <cstring>

namespace stl
{
    template <typename Object>
    class Queue
    {
    public:
        /*
        @method QueueBase
        */
        Queue()
            :m_front(0)
            , m_rear(0)
            , m_size(0)
            , m_capacity(MAX_SIZE)
        {
            m_pElements = new Object[MAX_SIZE];
        }
        /*
        @method ~QueueBase
        */
        ~Queue()
        {
            assert(m_pElements);
            delete[] m_pElements;
        }
        /*
        @method  push
        @param T 是插入的元素
        */
        void push(Object object)
        {
            // 队列后就追加空间
            if (full())
            {
                // 分配一个更大的空间
                Object *tmpp = new Object[m_capacity + MAX_ADD_SIZE];
                // 如果分配不成功，就抛出异常
                if (tmpp == NULL) throw;
                // 分配成功就将原有的数据拷贝到新空间
                // 如果队列满了，只有一种情况，就是m_front == m_rear
                memcpy(tmpp, m_pElements + m_front, (m_size - m_rear) * sizeof(Object));
                memcpy(tmpp + m_size - m_rear, m_pElements, m_rear * sizeof(Object));           
                // 释放原空间
                delete[] m_pElements;
                // 将新空间的地址赋予m_pElements
                m_pElements = tmpp;
                // Queue容器大小更新
                m_capacity += MAX_ADD_SIZE;
                // m_front m_rear更新
                m_front = 0;
                m_rear = m_size;
            }
            m_pElements[m_rear] = object;
            m_rear = (++m_rear) % m_capacity;
            ++m_size;
        }
        /*
        @method pop
        */      
        void pop()
        {
            // 如果队列为空
            if (empty())
            {
                // 直接抛出异常
                throw;
            }
            // 如果不为空，头索引加一
            m_front = (++m_front) % m_capacity;
            // 元素数减一
            --m_size;
        }
        /*
        @method front
        @return 返回一个类型T对象
        */
        Object front()
        {
            // 返回队首的
            return m_pElements[m_front % m_capacity];
        }
        /*
        @method empty
        @return 返回一个布尔值，用于表示队列是否为空，true为空
        */
        bool empty()
        {
            return m_size == 0;
        }
        /*
        @method full
        @return 返回一个布尔值，用于表示队列是否满队列，true为已满
        */
        bool full()
        {
            return m_size == m_capacity;
        }
        /*
        @method size
        @return 返回队列元素个数
        */
        int size()
        {
            return m_size;
        }
    private:
        const static int MAX_SIZE = 100;
        const static int MAX_ADD_SIZE = 25;
        int m_front;                        // 队列队首
        int m_rear;                         // 队列队尾
        int m_capacity;                     // 该容器大小
        int m_size;                         // 存入元素个数
        Object *m_pElements;                // 队列容器
    };

}


#endif // !MYQUEUE_H