一个比较实用的循环队列

最近任务比较繁重，没什么时间写博客，只能勉强附上之前写的一个还算比较实用的循环队列，工程上可以用得上，敬请笑纳

#pragma once
#include <string>
using namespace std;
#include "Mutex.h"


#define CirQueueSize 1000;
template <class ELEMENT_TYPE>   //循环队列模板类
class CirQueue
{
public:
	CirQueue(void)  //默认大小：CirQueueSize
	{
		Array=NULL;
		MAXSIZE = CirQueueSize;
		Array = new ELEMENT_TYPE[MAXSIZE];
		front = 0;
		rear  = front;
		if(Array == NULL)
			lastError="开辟内存空间失败!";
		else
			lastError="";
	}
	CirQueue(unsigned int size)
	{
		Array=NULL;
		MAXSIZE = size;
		Array = new ELEMENT_TYPE[size];
		front = 0;
		rear  = front;
		if(Array == NULL)
			lastError="开辟内存空间失败!";
		else
			lastError="";
	}
	~CirQueue(void)
	{
		if(Array!=NULL)
			delete[] Array;
	}
	int Length()//循环队形长度
	{
		return (rear + MAXSIZE - front)%MAXSIZE;
	}
	bool isEmpty()//循环队形是否空
	{
		Mutex::Lock lock(_mutex);

		return front == rear;
	}
	bool isFull()//循环队形是否满
	{
		return Length() == MAXSIZE - 1;
	}
	void clear()//循环队形清空
	{
		Mutex::Lock lock(_mutex);

		front=rear;
	}
	ELEMENT_TYPE& operator[](int index)
	{
		return Array[index];
	}

	bool enQueue(const ELEMENT_TYPE& element)//入队
	{
		Mutex::Lock lock(_mutex);

		if(isFull())
		{
			lastError="队列数据已满，插入数据失败!";
			return false;
		}
		Array[rear] = element;             //深复制
		rear = (rear + 1) % MAXSIZE;
		return true;
	}
	bool deQueue(ELEMENT_TYPE& element)     //出队
	{
		Mutex::Lock lock(_mutex);

		if(front == rear)
		{
			lastError="队列为空，读取数据失败!";
			return false;
		}
		element = Array[front];             //深复制	
		front = (front+1) % MAXSIZE;
		return true;
	}
	std::string lastError;

private:
	int front; //头 
	int rear;  //尾
	int MAXSIZE;//元素总数
	ELEMENT_TYPE * Array;
	Mutex _mutex;//互斥变量
};

关于互斥变量Mutex类是使用Qt库封装的互斥类，可以考虑使用其他的如boost库或标准库来实现。