队列——顺序存储的循环队列（存储元素为默认类型）

队列头文件（MyQueue.h）

#pragma
class MyQueue
{
public:
MyQueue(int queueCapacity);//InitQueue(&Q)  创建队列
virtual ~MyQueue();   //DestroyQueue(&Q)销毁队列
void ClearQueue();    //ClearQueue(&Q)清空队列
bool QueueEmpty() const;  //QueueEmpty(Q) 判空
bool QueueFull() const;    //判断队满操作
int QueueLength() const;   //QueueLength(Q)队列长度
bool EnQueue(int element);  //EnQueue(&Q,element)新元素入队
bool DeQueue(int &element);  //DeQueue(&Q,&element)首元素出队
void QueueTraverse();    //QueueTraverse(Q,visit())遍历队列

private:
int *m_pQueue;   //队列数组指针
int m_iQueueLen;   //队列元素个数
int m_iQueueCapacity;  //队列数组容量
int m_iHead;
int m_Tail;
};

队列的实现文件（MyQueue.cpp）

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

//构造函数
MyQueue::MyQueue(int queueCapacity)
{
m_pQueue = new int[queueCapacity];
m_iQueueCapacity = queueCapacity;
ClearQueue();
}
//虚构函数
MyQueue::~MyQueue()
{
delete[] m_pQueue;
m_pQueue = NULL;
}
//队列清空操作
void MyQueue::ClearQueue()
{
m_iQueueLen = 0;
m_iHead = 0;
m_Tail = 0;
}
//队列判空操作
bool MyQueue::QueueEmpty() const
{
return (m_iQueueLen == 0 ? true : false);
}
//队列判满操作
bool MyQueue::QueueFull() const
{
return m_iQueueCapacity == m_iQueueLen ? true : false;
}
//求队列的长度
int MyQueue::QueueLength() const
{
return m_iQueueLen;
}
//队列入队操作
bool MyQueue::EnQueue(int element)
{
if (QueueFull())
{
return false;
}
else
{
m_pQueue[m_Tail++] = element;
m_Tail = m_Tail % m_iQueueCapacity;
m_iQueueLen++;
return true;
}
}
//队列出队操作
bool MyQueue::DeQueue(int &element)
{
if (QueueEmpty())
{
return false;
}
else
{
element = m_pQueue[m_iHead++];
m_iHead = m_iHead % m_iQueueCapacity;
m_iQueueLen--;
return true;
}
}
//遍历队列操作
void MyQueue::QueueTraverse()
{
for (int i = m_iHead;i < m_iQueueLen+ m_iHead;i++)
{
m_pQueue[i%m_iQueueCapacity].printInfo();
}
}

测试函数

#include<iostream>
#include<stdlib.h>
#include"Queue.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(20);
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();
p->QueueTraverse();

p->EnQueue(20);
p->EnQueue(32);
cout << endl;
p->QueueTraverse();

delete p;
p = NULL;
system("pause");

return 0;
}