数据结构与算法-循环队列

template<class T>
class MyCircularQueue {
public:
    MyCircularQueue(int nQueueSize);
    ~MyCircularQueue();

    bool empty() const;
    int size() const;
    void pop();
    T front() const;
    T back() const;
    bool push(T const&);

protected:
    T* m_pArrayQueue;
    int m_nQueueSize;
    int m_nHead;
    int m_nTail;
    int m_nNumSize;
};

template<class T>
MyCircularQueue<T>::MyCircularQueue(int nQueueSize) {
    m_nQueueSize = nQueueSize;
    m_pArrayQueue = new T[nQueueSize];
    m_nHead = 0;
    m_nTail = 0;
    m_nNumSize = 0;
}

template<class T>
MyCircularQueue<T>::~MyCircularQueue() {
    delete[] m_pArrayQueue;
}

template<class T>
bool MyCircularQueue<T>::empty() const {
    if(m_nHead == m_nTail) {
        return true;
    }
    return false;
}

template<class T>
int MyCircularQueue<T>::size() const {
    return m_nNumSize;
}

template<class T>
void MyCircularQueue<T>::pop() {
    if(m_nHead == m_nTail) {
        return ;
    }
    m_nHead = (m_nHead + 1) % m_nQueueSize;
    m_nNumSize--;
}

template<class T>
T MyCircularQueue<T>::front() const {
    return m_pArrayQueue[m_nHead];
}

template<class T>
T MyCircularQueue<T>::back() const {
    return m_pArrayQueue[(m_nHead + m_nNumSize - 1) % m_nQueueSize];
}

template<class T>
bool MyCircularQueue<T>::push(T const& param) {
    if((m_nTail + 1) % m_nQueueSize == m_nHead) {
        return false;
    }
    m_pArrayQueue[m_nTail] = param;
    m_nTail = (m_nTail + 1) % m_nQueueSize;
    m_nNumSize++;
    return true;
}