已经下架了，同学

初始化队列是实例化一个队列类，而创建队列就是使用实例的成员函数进行修改队列。

想要通过用户输入创建队列，可以自己写一个成员函数，实现。

楼主解决了吗，我用的是m_iQueueCapacity

原来是自己傻X了，我佛了

“MyQueeue.h”中多了个字母e，跟“Myqueue”后面不一致

Q_SQueue[i%GQueue]//应改成 Q——SQueue[i%m_iQueueCapacity],m_iQueueCapacity为数组的最大长度

注意堆中定义的格式以及释放内存的书写方式

循环队列中，新的元素插入是在当前队尾后面插入，并且新元素成为新的队尾，队列每个元素不需要向后移动

忽略，已解决

应该是判断是否出队入队成功

引用就是元素的首地址，你删元素，不就是在队列里面删除它存在的地址吗？有了地址，队列就知道你要 删除哪个了

表示这个函数是只读的，判空是判断一种状态只需要读结果，所以const只读

描述再仔细些

DeQueue(e)意思是：删除队头元素，并用e返回其值。

所以定义e是为了接收删除的队头元素，e的初始值可以随便赋值。

虽然存在，但遍历时不输出，计算长度时又不算所以没关系的~

???

p->DeQueue(e)是取出的值，e是返回取出的是什么值，然后用cout<<e<<endl;打印出来

    假设一种情况，一个m_iQueueCapacity=4的队列，经过一系列入队和出对操作，此时m_iHead=3，而m_tail=2，此时在3,0,1位置都有元素。

    此时m_iQueueLen=3。如果是循环是for (int i = m_iHead; i < m_iQueueLen ; i++)，循环次数m_iQueueLen-m_iHead=0，很明显循环不能执行。因为我们要循环的次数是m_iQueueLen，也就是3。所以循环次数应该是（m_iQueueLen + m_iHead）-m_iHead=3，也就是i < m_iQueueLen + m_iHead。

    至于i % m_iQueueCapacity，在假设中，我们首先访问3位置元素，接下要访问0位置元素了，而i++后此时m_pQueue[i]会访问4位置元素，而在 m_iQueueCapacity=4队列里只有0,1,2,3,这几个位置，所以我们要对i%m_iQueueCapacity取余数，使得我们访问的位置在m_pQueue[ ]的范围内，这个余数也是我们访问完3位置元素的下一个位置0。

    画一下图更清楚（这里是顺时针队列）。

    拙见，见笑。

请发完整代码

首先，要说应该是先给队尾赋值，再移动队尾指针，也就是说，队尾的位置此时应该是空的，以便后续有元素的入队。看你和楼上的对话中，发现你没弄清队尾的位置问题，一旦赋值完成，队尾指针就会移动，移到下一个位置，以便后续操作。再给你个小小的建议，类名、函数名首字母大写，变量小写，约定俗成的规定，毕竟程序是给程序员看的。希望可以帮到你(✿◡‿◡)

检查一下是不是某个函数只声明未定义

容量已经规定为4，在没有元素出队的情况下，插入反而不对了吧。我们之所以为一些函数设置了const，不也就是不希望出现改变队列，以致程序混乱的情况吗。现在还只是4个元素，数量不多，如果是TB级的数量，不断的去扩充其队列容量，代价太高了。更何况环形队列与普通队列的处理方式上本身就是不同的，没有必要去不断申请内存。这是我的理解，有不对的地方，恳请大佬们指正(✿◡‿◡)

你执行出队操作，应该是对队列头进行操作对吧，因为队列是FIFO模型，但是你的代码中为什么写成了Elem=m_Queue[m_Tail];这是将队尾，要入队的元素赋值给ele？

因为iHead是队列的头部嘛，所以要从头部开始遍历i就要等于iHead

找出来问题了，鉴于没有人回答，就把自己怎么解决的说一下啦

直接把MyQueue.cpp里的内容放到MyQueue.h变成一个整合的文件就可以了

以下MyQueue.h代码

#ifndef MYQUEUE_H
#define MYQUEUE_H
#include <iostream>
using namespace std;
class MyQueue
{
	public:
		MyQueue(int queueCapacity);
		virtual ~MyQueue();
		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;
};
MyQueue::MyQueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_pQueue = new int[m_iQueueCapacity];
	ClearQueue();
}

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

void MyQueue::ClearQueue()
{
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
}

bool MyQueue::QueueEmpty() const
{
	return m_iQueueLen == 0 ? true:false;
}

int MyQueue::QueueLength() const
{
	return m_iQueueLen;
}

bool MyQueue::QueueFull() const
{
	if(m_iQueueLen == m_iQueueCapacity) return true;
	else return false;
}

bool MyQueue::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 MyQueue::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 MyQueue::QueueTraverse()
{
	
	cout<<endl<<"以下遍历队列："<<endl;
	for(int i = m_iHead;i < m_iQueueLen;i++)
	{
		i = i % m_iQueueCapacity;
		cout<<m_pQueue[i]<<endl;
	}
	cout<<endl;
}
#endif