一个简单的队列

一、类中的成员变量：
1、队列数组指针
2、队列元素个数
3、队列元素容量
4、队列头序数
5、队列为序数

二、类中的成员函数
1、建立队列 函数
2、清空队列 函数
3、销毁队列 函数
4、判空队列 函数
5、判满队列 函数
6、新元素入队 函数
7、首元素出队 函数
8、浏览队列 函数
9、**队列长度 函数

//queue.h

#ifndef QUEUE_H
#define QUEUE_H
class queue{
    public:
    queue(int queueCapacity);   //建立队列 
    ~queue();                   //销毁队列 
    void clearQueue();          //清空队列 
    bool queueEmpty()const;     //判空队列 
    bool queueFull()const;      //判满队列 
    int  queueLength()const;     //队列长度 
    bool enQueue(int element);  //新元素入队 
    bool deQueue(int &element); //首元素出队 
    void queueTraverse();       //遍历队列 
    private:
    int *m_pQueue;              //队列数组指针 
    int m_iQueueLen;            //队列元素个数 
    int m_iQueueCapacity;       //队列元素容量 
    int m_iHead;
    int m_iTail;
};

#endif

//queue.cpp

#include"queue.h"
#include<iostream>

using namespace std;    

queue::queue(int queueCapacity){
     m_iQueueCapacity=queueCapacity;
     m_iHead=0;
     m_iTail=0;
     m_iQueueLen=0;
     m_pQueue=new int[queueCapacity];
     }

queue::~queue(){
    delete[] m_pQueue;
    m_pQueue=NULL;
}    

void queue::clearQueue(){
     m_iHead=0;
     m_iTail=0;
     m_iQueueLen=0;
}

bool queue::queueEmpty()const
{
    return m_iQueueLen==0?true:false;
}

int queue::queueLength()const{
    return m_iQueueLen;
}

bool queue::queueFull()const
{
    if(m_iQueueLen==m_iQueueCapacity)
    {
        cout<<"error"<<endl;
        return true;
    }
    else
    {
        return false;
    }
}

bool queue::enQueue(int element)
{
    if(queueFull())
    {
        return false;
    }
    else
    {
    m_pQueue[m_iTail]=element;
    m_iTail++;
    m_iTail=m_iTail%m_iQueueCapacity;
    m_iQueueLen++;
    return true;
    }
}

bool queue::deQueue(int &element)
{
    if(queueEmpty())
    {
        return false;
    }
    else
    {
        element=m_pQueue[m_iHead];//出队就是向外界读取一个元素，所以必须是引用 
        m_iHead++;
        m_iHead=m_iHead%m_iQueueCapacity;
        m_iQueueLen--;
        return true;
    }
}

void queue::queueTraverse()
{
    for(int i=m_iHead;i<m_iQueueLen+m_iHead;i++)//队列长度指挥遍历的次数 
    {

        cout<<m_pQueue[i%m_iQueueCapacity]<<endl;//控制i在0~3之间循环，对n求余，就在0~n-1之间循环 
    } 
}

//main.cpp

#include"queue.h"
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(void)
{
    queue *p=new queue(4);//并非由创建对象，而是申请了一个该类的空间，用p指向它 
    p->enQueue(10);
    p->enQueue(12);
    p->enQueue(14);
    p->enQueue(16);
    p->enQueue(18);
    p->queueTraverse();
    int e=0;
    p->deQueue(e);
    cout<<endl;
    cout<<e<<endl;

    p->deQueue(e);
    cout<<endl;
    cout<<e<<endl;

    cout<<endl;
    p->queueTraverse();

    cout<<endl;
    p->clearQueue(); 
    delete p;
    p=NULL;

    system("pause");
    return 0;

    }