基于链表的队列实现

//--------------LQueue.h------------------
#include<iostream>

#ifndef DQUEUE
#define DQUEUE

typedef int QueueElement;

class Queue
{
public:
	Queue();
	Queue(const Queue & original);
	~Queue();
    const Queue & operator=(const Queue & rightHandSide);
	bool empty() const;
	void enqueue(const QueueElement & value);
	void display(ostream & out) const;
	QueueElement front() const;
	void dequeue();
private:
	class Node
	{
	public:
		QueueElement data;
		Node *next;
		Node(QueueElement value,Node *link=0)
		:data(value),next(link)
		{}
	};

	typedef Node *NodePointer;
	NodePointer myFront,
	           myBack;
};
#endif

//-------------LQueue.cpp-------------------
#include<iostream>
#include<new>
using namespace std;

#include"LQueue.h"

Queue::Queue()
:myFront(0),myBack(0)
{}

Queue::Queue(const Queue & original)
{
	myFront=myBack=0;
	if(!original.empty())
	{
		Queue::NodePointer origPtr=original.myFront->next;
		while(origPtr!=0)
		{
			myBack->next=new Queue::Node(origPtr->data);
			myBack=myBack->next;
			origPtr=origPtr->next;
		}
	}
}

Queue::~Queue()
{
	Queue::NodePointer prev=myFront,
		               ptr;
	while(prev!=0)
	{
		ptr=prev->next;
		delete prev;
		prev=ptr;
	}
}

const Queue & Queue::operator=(const Queue & rightHandSide)
{
	if(this!=&rightHandSide)
	{
		this->~Queue();
		if(rightHandSide.empty())
			myFront=myBack=0;
	}
		else
		{
			myFront=myBack=new Queue::Node(rightHandSide.front());
			Queue::NodePointer rhsPtr=rightHandSide.myFront->next;
			while(rhsPtr!=0)
			{
				myBack->next=new Queue::Node(rhsPtr->data);
				myBack=myBack->next;
				rhsPtr=rhsPtr->next;
			}
		}
	return *this;
}


bool Queue::empty() const
{
	return (myFront==0);
}

void Queue::enqueue(const QueueElement & value)
{
	Queue::NodePointer newPtr=new Queue::Node(value);
	if(empty())
	   myFront=myBack=newPtr;
	else
	{
		myBack->next=newPtr;
		myBack=newPtr;
	}
}

void Queue::display(ostream & out) const
{
	Queue::NodePointer ptr;
	for(ptr=myFront;ptr!=0;ptr=ptr->next)
		out<<ptr->data<<" ";
	out<<endl;
}

QueueElement Queue::front() const
{
	if(!empty())
	    return (myFront->data);
	else
	{
		cerr<<"***The queue is empty--returning a garbage value***\n";
		QueueElement *temp=new(QueueElement);
		QueueElement garbage=*temp;
		delete temp;
		return garbage;
	}
}

void Queue::dequeue()
{
	if(!empty())
	{
		Queue::NodePointer ptr=myFront;
		myFront=myFront->next;
		delete ptr;
		if(myFront==0)
			myBack=0;
	}
	else
	{
		cerr<<"***The queue is empty,can't remove a value.***\n";		
	}
}

//-----------LQueue_main.cpp--------------
#include<iostream>
using namespace std;

#include"LQueue.h"

void print(Queue q)
{ q.display(cout); }

int main()
{
	Queue q1;
	cout<<"Queue created. Empty?"<<boolalpha<<q1.empty()<<endl;

	cout<<"How many elements to add to the queue? ";
	int numItems;
	cin>>numItems;
	for(int i=1;i<numItems;i++)
		q1.enqueue(100*i);

	cout<<"Contents of queue q1 (via print):\n";
	print(q1); cout<<endl;

	Queue q2;
	q2=q1;
	cout<<"Contents of queue q2 after q2 (via print):\n";
	print(q2); cout<<endl;

	cout<<"Queue q2 empty? "<<q2.empty()<<endl;

	cout<<"Front value in q2: "<<q2.front()<<endl;

	while(!q2.empty())
	{
		cout<<"Remove front -- Queue contents: ";
		q2.dequeue();
		q2.display(cout);
	}
	cout<<"Queue q2 empty? "<<q2.empty()<<endl;
	cout<<"Front value in q2?"<<endl<<q2.front()<<endl;
	cout<<"Trying to remove front of q2: "<<endl;
	q2.dequeue();
}
//无法执行？