queue.h

用矩阵表示的迷宫

#pragma once
#define INVALID_SIZE	  1
#define NO_MEMORY		  2
#define INDEX_OVER_BOUNDS 3

template<class T>
class Queue
{
public:
	Queue(int MaxSize = 10);
	~Queue(){delete[]t;};
public:
	bool IsEmpty(){return front == rear;}
	bool IsFull(){return (rear+1)%MaxSize == front;}
	Queue<T>&Add(const T&);
	Queue<T>&Delete(T&);
	T GetFirst();
	T GetLast();
	int GetMaxSize(){return MaxSize-1;}
	int GetSize();
private:
	int front;
	int rear;
	int MaxSize;
	T*t;
};
/////////////////////////////////////////////////////////
template<class T>
Queue<T>::Queue(int MaxSize)
{
	front = rear = 0;
	if(MaxSize<2)throw INVALID_SIZE;
	this->MaxSize = MaxSize+1;
	t = new T[this->MaxSize];
	if(t == NULL)throw NO_MEMORY;
}

template<class T>
Queue<T>&Queue<T>::Add(const T&t)
{
	if(this->IsFull())throw NO_MEMORY;
	rear = (rear+1)%MaxSize;
	this->t[rear] = t;
	return *this;
}
	
template<class T>
Queue<T>&Queue<T>::Delete(T&t)
{
	if(this->IsEmpty())throw INDEX_OVER_BOUNDS;
	front = (front+1)%MaxSize;
	t = this->t[front];
	return *this;
}

template<class T>
T Queue<T>::GetFirst()
{
	if(this->IsEmpty())throw INDEX_OVER_BOUNDS;
	return t[(front+1)%MaxSize];
}

template<class T>
T Queue<T>::GetLast()
{
	if(this->IsEmpty())throw INDEX_OVER_BOUNDS;
	return t[rear];
}

template<class T>
int Queue<T>::GetSize()
{
	int count = rear-front;
	if(count<0)
		count+=MaxSize;
	return count;
}