cpolynomial.h

多项式的运算,有符号重载方法实现 visual stdio2005编译通过

#include<iostream>
#include<vector>
#include<list>
#include<string>
#include<cmath>
using namespace std;

/*************************class CNode declaration*************************/ 
class CNode{ 
	/*把CNode的内容输出到os--友元、操作符重载*/
	friend ostream & operator << (ostream &os, const CNode& );
	/*CPolynomial的排序标准*/
	friend bool expnComp(const CNode & A,const CNode & B);
public: 
	/*缺省构造函数*/
	CNode(){_coef = 0.0; _expn = 0;}; 
	CNode(double c, int e): _coef(c), _expn(e){ }; 
	~CNode(){}; 

	int expn() const {return _expn;}; 
	double coef() const {return _coef;}; 
private: 
	double _coef;	//多项式item的系数域 
	int _expn;	//多项式item的指数域 
}; 

/*************************class CPolynomial declaration*************************/ 
class CPolynomial { 
	/*2个多项式的+法*/ 
	friend CPolynomial operator+( const CPolynomial& A, const CPolynomial& B ); 
	/*按照项的指数递减顺序输出一元稀疏多项式到os*/ 
	friend ostream& operator <<( ostream& os , const CPolynomial& ); 
public: 
	/*多项式对象的缺省构造函数*/ 
	CPolynomial(){}; 
	/*用系数向量和指数向量构造多项式*/ 
	CPolynomial(const vector<double>& , const vector<int>& ); 
	/*多项式的copy构造函数*/ 
	CPolynomial(const CPolynomial& rpln); 
	/*释放一元多项式占用的存储空间*/ 
	~CPolynomial(); 
	/*将值代入多项式,计算多项式的值*/ 
	double operator()(double x) const; 
	/*多项式的赋值操作*/ 
	CPolynomial& operator=(const CPolynomial& rpln); 
	/*输出一元稀疏多项式(实则它并没有存在的必要）*/
	void print();  
private: 
	list<CNode> _polyList; 
};

/**************************接口函数的实现****************************/
//把CNode的内容输出到os,即输出一元多项式的项
ostream & operator << (ostream & os,const CNode & CPoly){
	//系数不为0,指数不为0、1，输出项形如 ”ax^b”
	if(CPoly._coef!=0 && CPoly._expn!=1 && CPoly._expn!=0)
		os<<CPoly._coef<<"x^"<<CPoly._expn;
	//系数不为0，同时指数为1，输出项形如”ax”
	if(CPoly._coef!=0 && CPoly._expn==1)
		os<<CPoly._coef<<"x";
	//系数不为0，同时指数为0，输出项形如 ”a”
	if(CPoly._coef!=0 && CPoly._expn==0) 
		os<<CPoly._coef;
	//否则，系数为0，整项为0，输出空白

	return os;
}

//构造CPolynomial的排序标准－指数递减
bool CompByExpn(const CNode & A,const CNode & B){
	if(A.expn()>B.expn())	return true;
	else return false;
}

//重载多项式加法操作符
CPolynomial operator+( const CPolynomial& A, const CPolynomial& B ){
	CPolynomial CPSum;

	//定义遍历链表迭代子
	list<CNode>::const_iterator iter_A=A._polyList.begin();
	list<CNode>::const_iterator iter_Ae=A._polyList.end();
	list<CNode>::const_iterator iter_B=B._polyList.begin();
	list<CNode>::const_iterator iter_Be=B._polyList.end();
	
	while((iter_A!=iter_Ae) && (iter_B!=iter_Be)){
		if(iter_A->expn() > iter_B->expn()){
			CNode newnode(iter_A->coef(),iter_A->expn());

			CPSum._polyList.push_back(newnode);
			iter_A++;
		}
		else if(iter_A->expn() < iter_B->expn()){
			CNode newnode(iter_B->coef(),iter_B->expn());

			CPSum._polyList.push_back(newnode);
			iter_B++;
		}
		else{
			double coef;	int expn;
			coef=iter_A->coef()+iter_B->coef();
			expn=iter_A->expn();
			CNode newnode(coef,expn);

			CPSum._polyList.push_back(newnode);
			iter_A++;	iter_B++;
		}
	}
	//A链表还有剩余节点，直接接到结果链表后面
	while(iter_A!=iter_Ae){
		CNode newnode(iter_A->coef(),iter_A->expn());

		CPSum._polyList.push_back(newnode);
		iter_A++;
	}
	//B链表还有剩余节点，直接接到结果链表后面
	while(iter_B!=iter_Be){
		CNode newnode(iter_B->coef(),iter_B->expn());

		CPSum._polyList.push_back(newnode);
		iter_B++;
	}

	return CPSum;
}

//输出一元稀疏多项式--重载输出流操作符“<<”
ostream& operator <<( ostream& os , const CPolynomial& CPloy){
	if(CPloy._polyList.empty()){
		os<<0<<"  该多项式不存在！"<<endl;
		
		return os;
	}
	else{
		//定义遍历链表迭代子
		list<CNode>::const_iterator iter_CP=CPloy._polyList.begin();

		for(unsigned int i=0;i<CPloy._polyList.size();i++){
			os<<(*iter_CP);	//CNode中已重载了“<<”输出多项式的项
							//此处无需再重复构建
			if(iter_CP->coef()!=0 && i!=(CPloy._polyList.size()-1)){
				++iter_CP;		//指向下一项
				if(iter_CP->coef()>0) os<<"+";
			}	//如果此项不是最后一项,且它和它的前一项不为0，输出加号
			else ++iter_CP;
		}
		os<<endl;

		return os;
	}
}

//用系数向量和指数向量构造多项式 
CPolynomial::CPolynomial(const vector<double>& coef, const vector<int>& expn){
	for(unsigned int i=0;i<expn.size();i++){
		CNode tempNode(coef[i],expn[i]);

		//将新生成的节点从链表头部插入
		this->_polyList.push_back(tempNode);
		
		//将生成的一元多项式链表按指数进行排序
		this->_polyList.sort(CompByExpn);
	}
}

//释放一元多项式占用的存储空间
CPolynomial::~CPolynomial(){}; 

//多项式的copy构造函数
CPolynomial::CPolynomial(const CPolynomial & rpln){
	//定义遍历链表迭代子
	list<CNode>::const_iterator iter_rp=rpln._polyList.begin();
	list<CNode>::const_iterator iter_rpe=rpln._polyList.end();

	//使用List赋值函数assign(begin(),end())对链表进行拷贝
	this->_polyList.assign(iter_rp, iter_rpe);
}

//将值代入多项式,计算多项式的值
double CPolynomial::operator ()(double x) const{
	double result=0;
	//定义遍历链表迭代子
	list<CNode>::const_iterator it=(*this)._polyList.begin();
	list<CNode>::const_iterator it_end=(*this)._polyList.end();

	while(it!=it_end){
		result+=it->coef() * pow(x, it->expn());
		it++;
	}

	return result;
}

//多项式的赋值操作--重载赋值操作“=”
CPolynomial& CPolynomial:: operator = (const CPolynomial &  rpln){
	//定义遍历链表迭代子
	list<CNode>::const_iterator it = rpln._polyList.begin();
	list<CNode>::const_iterator it_end = rpln._polyList.end();

	while(it!=it_end){
		CNode tempnode(it->coef(), it->expn());

		this->_polyList.push_back(tempnode);
		it++;
	}

	return (*this);
}

//多项式的输出函数，考虑使用已重载的多项式输出操作符“<<”
void CPolynomial::print(){
	cout<<(*this);
	cout<<endl;
}