数据结构之队列（C++）

//MyQueue.h

#ifndef MYQUEUE_H
#define MYQUEUE_H
#include "Customer.h"
/******************************************/
/*环形队列C++实现 2018.1.30 by Gjp */
/******************************************/

class MyQueue
{
    public:
        MyQueue(int queueCapacity);
        virtual ~MyQueue();
        void ClearQueue();
        bool QueueEmpty() const;
        bool QueueFull() const;
        int QueueLength() const;
        bool EnQueue(Customer element);
        bool DeQueue(Customer &element);
        void QueueTravers();
    private:
        Customer *m_pQueue;
        int m_iQueueLen;
        int m_iQueueCapacity;
        int m_iHead;
        int m_iTail;
};

#endif // MYQUEUE_H
//MyQueue.cpp

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

using namespace std;
/*****************************************/
/*环形队列C++实现 2018.1.30 by Gjp        */
/******************************************/
MyQueue::MyQueue(int queueCapacity)
{
    m_iQueueCapacity = queueCapacity;
    m_iHead = 0;
    m_iTail = 0;
    m_iQueueLen = 0;
    m_pQueue = new Customer[m_iQueueCapacity];
}

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

void MyQueue::ClearQueue()
{
    m_iHead = 0;
    m_iTail = 0;
    m_iQueueLen = 0;
}
bool MyQueue::QueueEmpty() const
{
    if(m_iQueueLen==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
int MyQueue::QueueLength() const
{
    return m_iQueueLen;
}
bool MyQueue::QueueFull() const
{
    if(m_iQueueLen == m_iQueueCapacity)
    {
        return true;
    }
    return false;
}
bool MyQueue::EnQueue(Customer element)
{
    if(QueueFull())
    {
        return false;
    }
    else
    {
        m_pQueue[m_iTail] = element;
        m_iTail++;
        m_iTail = m_iTail%m_iQueueCapacity;
        m_iQueueLen++;
        return true;
    }
}
bool MyQueue::DeQueue(Customer &element)
{
    if(QueueEmpty())
    {
        return false;
    }
    else{
    element = m_pQueue[m_iHead];
    m_iHead++;
    m_iHead = m_iHead%m_iQueueCapacity;
    m_iQueueLen--;
    return true;
    }
}

void MyQueue::QueueTravers()
{
    for(int i = m_iHead;i<m_iQueueLen+m_iHead;i++)
    {
        m_pQueue[i%m_iQueueCapacity].printInfo();
        cout<<"前面还有"<<(i-m_iHead)<<endl;
    }
    cout<<endl;
}

//Customer.h

#ifndef CUSTOMER_H
#define CUSTOMER_H
#include <string>
using namespace std;

class Customer
{
    public:
        Customer(string name = "",int age=0);
        void printInfo() const;

    private:
        string m_strName;
        int m_iAge;
};

#endif // CUSTOMER_H
//Customer.cpp

#include "Customer.h"
#include <iostream>
using namespace std;

Customer::Customer(string name,int age)
{
    m_strName = name;
    m_iAge = age;
}

void Customer::printInfo() const
{
    cout<<"姓名:"<<m_strName<<endl;
    cout<<"年龄:"<<m_iAge<<endl;
    cout<<endl;
}

//main.cpp

#include <iostream>
#include "MyQueue.h"
#include "Customer.h"
using namespace std;

int main()
{
   /* MyQueue *p = new MyQueue(4);
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(16);
    p->EnQueue(18);
    //p->EnQueue(13);
    p->QueueTravers();

    int e = 0;
    p->DeQueue(e);
    cout<<endl;
    cout<<e<<endl;

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

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

    p->ClearQueue();
    p->QueueTravers();

    p->EnQueue(21);
    p->EnQueue(22);
    p->QueueTravers();
    delete p;
    p=NULL;*/

    MyQueue *p = new MyQueue(4);
    Customer c1("zhangsan",20);
    Customer c2("lisi",22);
    Customer c3("wangwu",23);

    p->EnQueue(c1);
    p->EnQueue(c2);
    p->EnQueue(c3);

    p->QueueTravers();

    Customer c4("",0);

    p->DeQueue(c4);
    cout<<"删除的元素:"<<endl;
    c4.printInfo();
    cout<<"删除后遍历的元素:"<<endl;
    p->QueueTravers();
    return 0;
}