用顺序存储结构和链式存储结构分别实现队列

#include<iostream>
#ifndef _Queue
#define _Queue
#define QueueMaxSize 100
template<typename T>
class SqQueueClass{
	private:
		T *data;
		int front, rear;
	public:
	    SqQueueClass();
	    ~SqQueueClass();
	    bool QueueEmpty();
	    bool enQueue(const T& e);
	    bool deQueue(T& e);
};
template<typename T>
class SqQueueClass1{
	private:
	    T *data;
		int front, rear;
	public:
	    SqQueueClass1();
		~SqQueueClass1();
		bool QueueEmpty1();
		bool enQueue1(const T& e) ;
		bool deQueue1(T& e);
};
template<typename T>
struct LinkNode{
	T data;
	LinkNode *next;
};
template<typename T>
struct LinkQueue{
	LinkNode<T> *front, *rear;
}; 
template<typename T>
class LinkQueueClass{
	private:
		LinkQueue<T> *Q;
	public:
		LinkQueueClass();
		~LinkQueueClass();
		bool QueueEmpty();
		bool enQueue(const T& e) ;
		bool deQueue(T& e); 
};
template<typename T>
SqQueueClass<T>::SqQueueClass()
{
	data = new T[QueueMaxSize];
	front = rear = -1;
}
template<typename T>
SqQueueClass<T>::~SqQueueClass()
{
	delete []data;
}
template<typename T>
bool SqQueueClass<T>::QueueEmpty()
{
	return (front == rear);
}
template<typename T>
bool SqQueueClass<T>::enQueue(const T& e)
{
	if(rear == QueueMaxSize-1)return false;
	rear++;
	data[rear] = e;
	return true;
}
template<typename T>
bool SqQueueClass<T>::deQueue(T& e)
{
	if(front == rear) return false;
	e = data[front];
	front++;
	return true;
}
template<typename T>
SqQueueClass1<T>::SqQueueClass1()
{
	data = new T[QueueMaxSize];
	front = rear = -1;
}
template<typename T>
SqQueueClass1<T>::~SqQueueClass1()
{
	delete []data;
}
template<typename T>
bool SqQueueClass1<T>::QueueEmpty1()
{
	return (front == rear);
}
template<typename T>
bool SqQueueClass1<T>::enQueue1(const T& e) 
{
	if((front+QueueMaxSize-rear)%QueueMaxSize == 1)
	    return false;
	rear++;
	data[rear] = e;
}
template<typename T>
bool SqQueueClass1<T>::deQueue1(T& e)
{
	if(rear == front) return false;
	e = data[front];
	front++;
}
template<typename T>
LinkQueueClass<T>::LinkQueueClass()
{
	Q = new LinkQueue<T>();
	Q->front = Q->rear = NULL;
}
template<typename T>
LinkQueueClass<T>::~LinkQueueClass()
{
	LinkNode<T> *p;
	if(Q->front != NULL)
	{
		while(Q->front != Q->rear)
		{
			p = Q->front->next;
			delete Q->front;
			Q->front = p;
		}
		delete Q->front;
	}
	delete Q;
}
template<typename T>
bool LinkQueueClass<T>::QueueEmpty()
{
	return (Q->rear == NULL);
}
template<typename T>
bool LinkQueueClass<T>::enQueue(const T& e) 
{
	LinkNode<T>* p = new LinkNode<T>();
	p->data = e;
	p->next = NULL;
	Q->rear->next = p;
}
template<typename T>
bool LinkQueueClass<T>::deQueue(T& e)
{
	if(Q->rear == NULL) return false;
	if(Q->front == Q->rear)
	{
		e = Q->front->data;
		delete Q->front;
		Q->front = Q->rear = NULL;
		return true;
	}
	LinkNode<T>* p;
	p = Q->front->next;
	delete Q->front;
	Q->front = p;
	return true;
}

#endif

int main()
{
	return 0;
}