多项式加法的实现（链表版）

/*作业内容：
利用C++标准模板库的list实现多项式加法，可参考课本(P526-533)
求以下两个多项式的和：
F(x)=8x7+7x4+3x2+5    G(x)=9x6+2x5+5x4+x+2
作业要求：
     1. 要求采用类的设计思路;
     2. 要求采用多文件的方式，包括类的头文件(.h文件)，
	 类的实现文件(.cpp文件)和main函数文件(.cpp);*/
//----------------------------Polynomial.h------------------------------------
#include<iostream>
#include<list>

#ifndef POLYNOMIAL
#define POLYNOMIAL

class Polynomial//定义一个Polynomial类
{
//--------------------内部定义一个Teams类-------------------------
private:
	class Team//定义一个Teams类
	{
     public:
		 int coef;//多项式项的系数
		 int expo;//多项式项的幂

	Team(int co=0,int ex=0)//Team类的构造函数 
	:coef(co),expo(ex)
	{}

	};
	typedef Team *TeamPointer;
//--------------------成员函数以及成员变量-------------------------
public:
	Polynomial();//构造函数
	~Polynomial();//析构函数
	Polynomial(const Polynomial & origPolynomial);//复制构造函数  
    const Polynomial & operator=(const Polynomial & rightHandSide);//赋值构造函数  
    bool empty() const;//判空函数
	int degree() const;//返回最高次幂函数
	void push_back(int co,int ex);//尾部添加元素函数
	void input(int *a,int n);//输入函数  
	const Polynomial addition(const Polynomial & secondPoly);//多项式加法函数
	const Polynomial operator+(const Polynomial & secondPoly) const;//重载“+”操作符
	void display(ostream & out) const;//输出函数

private:
	list<Team>aList;
	int myDegree;
};
ostream & operator<<(ostream & out,const Polynomial & polynomial);//重载输出操作符
#endif

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

#include"Polynomial.h"

Polynomial::Polynomial()//构造函数------------------------------
{
	int myDegree=0;//最高次幂
}

Polynomial::~Polynomial()//析构函数----------------------------------
{
	aList.clear();//清空链表内的元素
	myDegree=0;//最高次幂置为0
}
	
Polynomial::Polynomial(const Polynomial & original)//复制构造函数---------------------------
{
	if(!original.empty())//多项式非空
	{
		aList=original.aList;//复制传进来的链表
		myDegree=original.myDegree;//复制最高次幂
	}
	else//提示并退出程序
	{
		cerr<<"***Polynomial is empty, exit this program***\n";  
        exit(1);//退出程序
	}
}

const Polynomial & Polynomial::operator=(const Polynomial & rightHandSide)//赋值构造函数-----------
{
	if(this!=&rightHandSide)//确认不是自我赋值  
    {  
        if(rightHandSide.empty())//参数(多项式)非空  
        {  
            cerr<<"***List is empty, exit this program***\n";  
            exit(1);  
        }
		aList=rightHandSide.aList;//复制传进来的链表
		myDegree=rightHandSide.myDegree;//复制最高次幂
	}
	return *this;//返回新的多项式对象
}
 
bool Polynomial::empty() const//判空函数-------------------------------------
{
	return aList.empty();
}

int Polynomial::degree() const//返回最高次幂函数------------------------------
{
	return myDegree;
}

void Polynomial::push_back(int co,int ex)//尾部添加元素函数---------------------------------
{
	if(co!=0)//若某一个项系数非0
	{
		myDegree=(ex>myDegree)? ex:myDegree;//更新最高次幂
		TeamPointer it=new Team(co,ex);//初始化一个新的Team元素
        aList.push_back(*it);//将新的Team元素添加到链表尾部
	}
}

void Polynomial::input(int *a,int n)//输入函数-------------------------------   
{
	TeamPointer it;//定义一个链表指针
	for(int i=0;i<n/2;i++)
	{  
		it=new Team(a[2*i],a[2*i+1]);//初始化一个新的Team元素 
        aList.push_back(*it);//将新的Team元素添加到链表尾部
	}
} 

const Polynomial Polynomial::addition(const Polynomial & polynomial)//多项式加法函数-------------------------
{
	return (*this)+polynomial;//调用重载“+”操作符函数
}

const Polynomial Polynomial::operator+(const Polynomial & secondPoly) const//重载“+”操作符---------------
{
	Polynomial poly;//定义一个多项式对象
	list<Team>::const_iterator ptra=aList.begin(), alast=aList.end(),
	 //定义一个迭代器指向第一个多项式头部，另一个迭代器指向第一个多项式尾部（最后一个项的后一个位置）     
		                       ptrb=secondPoly.aList.begin(),blast=secondPoly.aList.end();
	 //定义一个迭代器指向第二个多项式头部，另一个迭代器指向第二个多项式尾部（最后一个项的后一个位置）
	TeamPointer ptrc;//定义一个链表指针
	while(ptra!=alast||ptrb!=blast)//某个多项式中还有节点
	{
		if((ptrb==blast)||(ptra!=alast&&ptra->expo>ptrb->expo))//从第一个多项式中复制
		{
			ptrc=new Team(ptra->coef,ptra->expo);//复制第一个多项式中链表的一个元素
			poly.aList.push_back(*ptrc);//将该元素添加到新的多项式的链表尾部
			ptra++;//第一个多项式的链表指针后移一位
		}
		else if((ptra==alast)||(ptrb!=blast&&ptrb->expo>ptra->expo))//从第二个多项式中复制
		{
			ptrc=new Team(ptrb->coef,ptrb->expo);//复制第二个多项式中链表的一个元素
			poly.aList.push_back(*ptrc);//将该元素添加到新的多项式的链表尾部
			ptrb++;//第二个多项式的链表指针后移一位
		}
		else//此时，第一个多项式的某项与第二个多项式的某项的幂相等
		{
			ptrc=new Team(ptra->coef+ptrb->coef,ptra->expo);//将第一个多项式的某项与第二个多项式的某项的系数相加
			poly.aList.push_back(*ptrc);//将相加后的新元素添加到新的多项式的链表尾部
			ptra++;//第一个多项式的链表指针后移一位
			ptrb++;//第二个多项式的链表指针后移一位
		}
	}
	poly.myDegree=(myDegree>secondPoly.myDegree)?myDegree:secondPoly.myDegree;//更新最高次幂
	return poly;//返回新的多项式
}

void Polynomial::display(ostream & out) const//输出函数-----------------------------
{
	out<<"f(x)=";
	for(list<Team>::const_iterator it=aList.begin();it!=aList.end();it++)//将每个项进行输出
	{
		if(it==aList.begin())//若输出的是第一个项
		{
			if(it->expo==0)//判断幂是否为0
			{
				if(it->coef==1)  out<<"1";
				else if(it->coef==-1) out<<"-1";
				else
			       out<<it->coef;
			}
			else if(it->expo==1)//判断幂是否为1
			{
				if(it->coef==1)  out<<"x";
				else if(it->coef==-1) out<<"-x";
				else
				   out<<it->coef<<"x";
			}
			else //幂为非0非1的整数
			{
				if(it->coef==1)  out<<"x^"<<it->expo;
				else if(it->coef==-1) out<<"-x^"<<it->expo;
				else
				out<<it->coef<<"x^"<<it->expo;//系数不需要显示正号
			}
		}
		else//若输出的不是第一个项
		{
			if(it->expo==0)//判断幂是否为0
			{
				if(it->coef==1)  out<<"+1";
				else if(it->coef==-1) out<<"-1";
				else
			       out<<showpos<<it->coef<<noshowpos;//系数需要显示正号
			}
			else if(it->expo==1)//判断幂是否为1
			{
				if(it->coef==1)  out<<"+x";
				else if(it->coef==-1) out<<"-x";
				else
				   out<<showpos<<it->coef<<"x"<<noshowpos;//系数需要显示正号
			}
			else //幂为非0非1的整数
			{
				if(it->coef==1)  out<<"+x^"<<it->expo;
				else if(it->coef==-1) out<<"-x^"<<it->expo;
				else
				out<<showpos<<it->coef<<"x^"<<noshowpos<<it->expo;//系数需要显示正号
			}
		}		
	}
	out<<endl;//进行换行
}

ostream & operator<<(ostream & out,const Polynomial & polynomial)//重载输出操作符----------------
{
	polynomial.display(out);//调用display（）成员函数
	return out;
}

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

#include"Polynomial.h"

int main()
{
	cout<<"----------------------The program test is begin---------------------"<<endl;
	cout<<endl;
	//验证多项式F(x)=8x7+7x4+3x2+5与多项式G(x)=9x6+2x5+5x4+x+2相加
	cout<<"Constructing polynomial aPoly1 and aPoly2\n";
	Polynomial aPoly1,aPoly2;//定义两个多项式对象
	cout<<"aPoly1 is empty? "<<boolalpha<<aPoly1.empty()<<endl;//测试判空函数
	cout<<"aPoly2 is empty? "<<boolalpha<<aPoly2.empty()<<endl;//测试判空函数

	cout<<"There are two polynomial now:";
	cout<<"  F(x)=8x7+7x4+3x2+5 and G(x)=9x6+2x5+5x4+x+2"<<endl;
	cout<<"---------------------------------------------------------------------"<<endl;
	int poly1[]={8,7,7,4,3,2,5,0};//将F(x)的系数与幂导入数组中
	int poly2[]={9,6,2,5,5,4,1,1,2,0};//将G(x)的系数与幂导入数组中
	aPoly1.input(poly1,8);//测试输入函数
	aPoly2.input(poly2,10);//测试输入函数

	cout<<"After importing the data from the array to the standard linked list"<<endl;
	cout<<"aPoly1 :"<<endl; aPoly1.display(cout);//显示多项式aPoly1,测试输出函数
	cout<<"aPoly2 :"<<endl; aPoly2.display(cout);//显示多项式aPoly2,测试输出函数

	cout<<"After adding two polynomials"<<endl;
	Polynomial aPoly=aPoly1+aPoly2;//将aPoly1与aPoly2相加，测试重载“+”操作符函数
	cout<<"aPoly :"<<endl;
	aPoly.display(cout);//显示多项式aPoly,测试输出函数

	cout<<"After the addition of two polynomials using another method"<<endl;
	Polynomial aPoly3=aPoly1.addition(aPoly2);//测试多项式加法函数
	cout<<"aPoly3 :"<<endl;
	aPoly3.display(cout);//显示多项式aPoly3,测试输出函数
	cout<<"---------------------------------------------------------------------"<<endl;
	Polynomial aPoly4,aPoly5;//定义两个多项式对象
	cout<<"There are two polynomial now:";
	cout<<"  F(x)=-7x7+x6+8x4+4x and G(x)=-23x6+x3+2"<<endl;
	aPoly4.push_back(-7,7);//将系数与幂导入多项式aPoly4
	aPoly4.push_back(1,6);//测试尾部添加元素函数
	aPoly4.push_back(8,4);
	aPoly4.push_back(4,1);
	
	aPoly5.push_back(-23,6);//将系数与幂导入多项式aPoly5
	aPoly5.push_back(1,3);//测试尾部添加元素函数
	aPoly5.push_back(2,0);

	cout<<"After importing the data from the array to the standard linked list"<<endl;
	cout<<"aPoly4 :"<<endl; aPoly4.display(cout);//显示多项式aPoly1,测试输出函数
	cout<<"aPoly5 :"<<endl; aPoly5.display(cout);//显示多项式aPoly2,测试输出函数

	cout<<"Test whether polynomials can be added continuously"<<endl;
	cout<<"aPoly6=aPoly1+aPoly2+aPoly4+aPoly5"<<endl;
	Polynomial aPoly6=aPoly1+aPoly2+aPoly4+aPoly5;//测试是否可以连续加
	cout<<"aPoly6 :"<<endl; aPoly6.display(cout);//输出连续加之后的结果
	cout<<"---------------------------------------------------------------------"<<endl;
	cout<<"Test copy constructor,aPoly7=aPoly6;"<<endl;
	Polynomial aPoly7=aPoly6;//测试复制构造函数
	cout<<"aPoly7 :"<<endl; aPoly7.display(cout);//输出复制后的多项式
	cout<<"aPoly7 is empty? "<<boolalpha<<aPoly7.empty()<<endl;//再次测试判空函数
	cout<<"aPoly7's degree is : " <<aPoly7.degree()<<endl; //测试最高次幂函数
     
	cout<<"Test assignment constructor, Polynomial aPoly8; aPoly8=aPoly7;"<<endl;
	Polynomial aPoly8;
	aPoly8=aPoly7;//测试赋值构造函数 
	cout<<"aPoly8 :"<<endl; aPoly8.display(cout);//输出赋值后的多项式
	cout<<"aPoly8 is empty? "<<boolalpha<<aPoly8.empty()<<endl;//再次测试判空函数
	cout<<"aPoly8's degree is ? " <<aPoly8.degree()<<endl; //测试最高次幂函数
     
	cout<<"----------------------The program test is end--------------------------"<<endl;
	system("pause");
}