簡單隊列的實現（基於數組）

用C++實現一個簡單的隊列，基於數組來實現。

#ifndef _ARRAYQUEUE_
#define _ARRAYQUEUE_

#include <iostream>
#include <stdexcept>
using namespace std;

template <class T>
class ArrayQueue
{
public:
	explicit ArrayQueue(int maxSize = 100) : _size(0),_maxSize(maxSize),_front(-1),_rear(-1)
	{
		_values = new T[_maxSize];
	}

	~ArrayQueue()
	{
		delete [] _values;
	}

	ArrayQueue(const ArrayQueue& rhs) : _values(NULL)
	{
		operator=(rhs);
	}

	const ArrayQueue& operator= (const ArrayQueue& rhs)
	{
		if( this != &rhs )
		{
			this->_size = rhs._size;
			this->_maxSize = rhs._maxSize;
			this->_front = rhs._front;
			this->_rear = rhs._rear;

			delete [] _values;
			_values = new T[_maxSize];

			if(_size > 0)
			{
				for(int temp = _front; temp != _rear; temp = (temp+1)%_maxSize)
				{
					_values[temp] = rhs._values[temp];
				}
				_values[_rear] = rhs._values[_rear];
			}
		}

		return *this;
	}

	bool IsEmpty() const
	{
		return _size == 0;
	}

	bool IsFull() const
	{
		return _size == _maxSize;
	}

	int Size() const
	{
		return _size;
	}

	void Clear()
	{
		_size = 0;
		_front = -1;
		_rear = -1;
	}

	void Print() const
	{
		cout << "Size=" << _size << endl;
		cout << "MaxSize=" << _maxSize << endl;
		cout << "Front=" << _front << endl;
		cout << "Rear=" << _rear << endl;
		cout << "IsEmpty=" << IsEmpty() << endl;
		cout << "IsFull=" << IsFull() << endl;

		for(int i=0;i<_maxSize;++i)
		{
			cout << _values[i] << ",";
		}
		cout << endl;
	}

	void Enqueue(const T& value);
	T Dequeue();
	T& Peek() const;

private:
	int _size;
	int _maxSize;
	int _front;
	int _rear;
	T* _values;
};

template <typename T>
void ArrayQueue<T>::Enqueue(const T& value)
{
	if(IsFull())
		throw logic_error("Queue is full");

	if(_size == 0)
	{
		_front = _rear = 0;
	}
	else
	{
		_rear = (_rear + 1) % _maxSize;
	}

	_values[_rear] = value;
	++_size;
}

template <typename T>
T ArrayQueue<T>::Dequeue()
{
	if(IsEmpty())
		throw logic_error("Queue is empty");

	T value;
	if(_size == 1)
	{
		value = _values[_front];
		_front = _rear = -1;
	}
	else
	{
		value = _values[_front];
		_front = (_front + 1) % _maxSize;
	}

	--_size;
	return value;
}

template <typename T>
T& ArrayQueue<T>::Peek() const
{
	if(IsEmpty())
		throw logic_error("Queue is empty");

	return _values[_front];
}
#endif

如下是測試代碼：

#include "ArrayQueue.cpp"

void ArrayQueueTest1();
void Test( void (*fp)() );

int main(int argc, char** argv)
{
	Test(ArrayQueueTest1);
	return 0;
}

void ArrayQueueTest1()
{
	ArrayQueue<int> q = ArrayQueue<int>(5);

	q.Print();

	q.Enqueue(1);
	q.Enqueue(2);
	q.Enqueue(3);
	q.Enqueue(4);
	q.Enqueue(5);
	q.Print();

	cout << "Peek=" << q.Peek() << endl;
	cout << "Dequeue=" << q.Dequeue() << endl;
	q.Print();

	q.Enqueue(6);
	q.Print();

	q.Dequeue();
	q.Dequeue();
	q.Print();

	ArrayQueue<int> q1 = q;
	cout<< "q1 content" << endl;
	q1.Print();

	cout << q1.Dequeue() << endl;
	cout << q1.Dequeue() << endl;
	cout << q1.Dequeue() << endl;
	q1.Print();
}

void Test( void (*fp)() )
{
	try
	{
		fp();
	}
	catch(out_of_range e)
	{
		cout<< "Catch Exception:" << e.what() << endl;
	}
	catch(overflow_error e)
	{
		cout<< "Catch Exception:" << e.what() << endl;
	}
	catch(logic_error e)
	{
		cout<< "Catch Exception:" << e.what() << endl;
	}
}