typedef Term Queue_entry;

class Queue
{
public:
	Queue();
	bool empty()const;
	Error_code append(const Queue_entry &item);
	Error_code serve();
	Error_code retireve(Queue_entry &item)const;
	~Queue();
	Queue(const Queue &original);
	void operator=(const Queue &original);
protected:
	Node *front, *rear;
};

class Extended_queue: public Queue
{
public:
	//bool full()const;
	int size()const;
	void clear();
	Error_code serve_and_retrieve(Queue_entry &item);
};

Queue::Queue()
{
	front=rear=NULL;
}

bool Queue::empty()const{
	if(front==NULL)
		return true;
	else
		return false;
}
Error_code Queue::append(const Queue_entry &item)
{
	Node *new_rear = new Node(item);
	if(new_rear==NULL)return overflow;
	if(rear==NULL)front=rear=new_rear;
	else{
		rear->next=new_rear;
		rear=new_rear;
	}
	return success;
}

Error_code Queue::serve()
{
	if(front==NULL)
		return underflow;
	Node *old_front=front;
	front=old_front->next;
	if(front==NULL)
		rear=NULL;
	delete old_front;
	return success;
}

Error_code Queue::retireve(Queue_entry &item)const{
	if(empty())
		return underflow;
	else{
		item=front->entry;
		return success;
	}
}


Queue:: ~Queue()
{
	while(!empty())
		serve();
}

void Queue::operator =(const Queue &original)
{
	Node *new_rear,*new_front,*new_copy,*original_node=original.front;
	if(original_node==NULL){
		new_front=new_rear=NULL;
	}
	else{
		new_copy=new_front=new Node(original_node->entry);
		while(original_node->next!=NULL){
			original_node=original_node->next;
			new_copy->next=new Node(original_node->entry);
			new_copy=new_copy->next;
		}
		original_node=original.rear;
		new_rear=new Node(original_node->entry);
		new_rear->next=NULL;
	}
	while(!empty())
		serve();
	front=new_front;
	rear=new_rear;
}

Queue::Queue(const Queue &original)
{
	Node *new_copy,*original_node=original.front;
	if(original_node==NULL)                              
		front=rear=NULL;
	else{
		front=new_copy=new Node(original_node->entry);
		while(original_node->next!=NULL){
			original_node=original_node->next;
			new_copy->next=new Node(original_node->entry);
			new_copy=new_copy->next;
		}
		original_node=original.rear;
		rear=new_copy=new Node(original_node->entry);
	}
}


int Extended_queue::size()const
{
	Node *window=front;
	int count=0;
	while(window != NULL){
		window=window->next;
		count++;
	}
	
	return count;
}

void Extended_queue::clear()
{
	while(!empty())
		serve();
}
Error_code Extended_queue::serve_and_retrieve(Queue_entry &item)
{
	if(front==NULL)
		return underflow;
	Node *old_front=front;
	front=old_front->next;
	item=old_front->entry;
	if(front==NULL)rear=NULL;
	delete old_front;
	return success;
}

class Polynomial: private Extended_queue
{
public:
	void read();
	void print()const;
	void equals_sum(Polynomial p,Polynomial q);
	void equals_difference(Polynomial p,Polynomial q);
	//void equals_product(Polynomial p,Polynomial q);
	//Error_code equals_quotient(Polynomial p,Polynomial q);
	int degree()const;
private:
	//void mult_term(Polynomial p,Term t);
};

void Polynomial::print() const
{
	Node *print_node=front;
	bool first_term=true;
	while(print_node != NULL){
		Term &print_term=print_node->entry;
		if(first_term){
			first_term=false;
			if(print_term.coefficient<0)
				cout<<" - ";
		}
		else if(print_term.coefficient<0)
			cout<<" - ";
		else
			cout<<" + ";
		double r=(print_term.coefficient>=0)
			?print_term.coefficient:-(print_term.coefficient);
		if(r!=1)
			cout<<r;
		if(print_term.degree>1)
			cout<<"X^"<<print_term.degree;
		if(print_term.degree==1)
			cout<<"X";
		if(r==1 && print_term.degree==0)
			cout<<"1";
		print_node=print_node->next;
	}
	if(first_term)
		cout<<"0";
	cout<<endl;
}

void Polynomial::read()
{
	clear();
	double coefficient;
	int last_exponent,exponent;
	bool first_term=true;
	cout<<"Enter the coffiecients and exponents for the polynomial,"
		<<"one pair per line. Exponents must be in descending order."<<endl
		<<"Enter a coefficient of 0 or exponent of 0 to termnimante."<<endl;
	do{
		cout<<"coefficient?"<<flush;
		cin>>coefficient;
		if(coefficient!=0.0){
			cout<<"exponent?"<<flush;
			cin>>exponent;
			if((!first_term&&exponent>=last_exponent)||exponent<0){
				exponent=0;
				cout<<"Bad exponent: Polynomial terminates without its last term."
					<<endl;
			}
			else{
				Term new_term(exponent,coefficient);
				append(new_term);
				first_term=false;
			}
			last_exponent=exponent;
		}
	}while(coefficient!=0.0&&exponent!=0);
}

void Polynomial::equals_sum(Polynomial p, Polynomial q)
{
	clear();
	while(!p.empty()||!q.empty()){
		Term p_term,q_term;
		if(p.degree()>q.degree()){
			p.serve_and_retrieve(p_term);
			append(p_term);
		}
		else if(q.degree()>p.degree()){
			q.serve_and_retrieve(q_term);
			append(q_term);
		}
		else{
			p.serve_and_retrieve(p_term);
			q.serve_and_retrieve(q_term);
			if(p_term.coefficient+q_term.coefficient!=0){
				Term answer_term(p_term.degree,
					p_term.coefficient+q_term.coefficient);
				append(answer_term);
			}
		}
	}
}
void Polynomial::equals_difference(Polynomial p,Polynomial q)
{
	Polynomial neg_q;
	while(!q.empty()){
		Term temp;
		q.serve_and_retrieve(temp);
		temp.coefficient=-1*temp.coefficient;
		neg_q.append(temp);
	}
	equals_sum(p,neg_q);
}

int Polynomial::degree()const
{
	if(empty())
		return -1;
	Term lead;
	retireve(lead);
	return lead.degree;
}

【过程记录】

【结果分析】