c++版队列实现

写在前面：小生纯业余选手，开此博仅仅是为了积累，纯当笔记来用。如有看官光临小生博客，请不要相信我的代码就是正确的。如果您发现了错误也恳请耽误您一点时间，请您在下面指出来，不胜感激！

关于队列的解释与数据结构课本一样，在实现的时候运用到了相关设计模式与模板技术，同时对于队列有些操作的实现模式比较清晰，有助于学习STL！

#ifndef QUENE_H
#define QUENE_H
#include <iostream>
#include <assert.h>
#include "list.h"

using namespace std;

template<typename E>
class Queue
{
private:
	void operator=(const Queue&){}
	Queue(const Queue&){}
public:
	Queue(){}
	virtual ~Queue(){}
	virtual void clear() = 0;
	virtual void enqueue(const E&) = 0;
	virtual E dequeue() = 0;
	virtual const E& frontValue()const = 0;
	virtual int length()const = 0;
};

template<typename E>
class AQueue : public Queue<E>
{
private:
	int maxSize;
	int front;
	int rear;
	E* listArray;
public:
	AQueue(int size = 0)
	{
		maxSize = size+1;
		rear = 0;
		front = 1;
		listArray = new E[maxSize];
	}
	~AQueue()
	{
		delete[] listArray;
	}
	void clear()
	{
		rear = 0;
		front = 1;
	}
	void enqueue(const E& it)
	{
		assert(((rear+2)%maxSize) != front);
		rear = (rear+1)%maxSize;
		listArray[rear]= it;
	}

	E dequeue()
	{
		assert(length() != 0);
		E it = listArray[front];
		front = (front+1)%maxSize;
		return it;
	}

	const E& frontValue()const
	{
		assert(length()!=0);
		return listArray[front];
	}

	virtual int length()const
	{
		return ((rear+maxSize)-front+1)%maxSize;
	}
};

template <typename E>
class Link
{
public:
	E element;
	Link* next;

	Link(const E& elemval,Link* nextval = NULL)
	{
		element = elemval;
		next = nextval;
	}
	Link(Link* nextval = NULL)
	{
		next = nextval;
	}
};
template <typename E>
class LQueue : public Queue<E>
{
private:
	Link<E>* front;
	Link<E> *rear;
	int size;

public:
	LQueue(int sz = 0)
	{
		front = rear = new Link<E>();
		size = 0;
	}
	~LQueue()
	{
		clear();
		delete front;
	}
	void clear()
	{
		while(front->next != NULL)
		{
			rear = front;
			delete rear;
		}
		rear = front;
		size = 0;
	}
	void enqueue(const E& it)
	{
		rear->next = new Link<E>(it,NULL);
		rear = rear->next;
		size++;
	}
	E dequeue()
	{
		assert(size != 0);
		E it = front->next->element;
		Link<E>* ltemp = front->next;
		front->next = ltemp->next;
		if(rear == ltemp)
		{
			rear == front;
		}
		delete ltemp;
		size--;
		return it;
	}

	const E& frontValue()const
	{
			assert(size != 0);
			return front->next->element;
	}

	virtual int length()const
	{
		return size;
	}
};