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的指数域 
}; 

ostream & operator << (ostream & os,const CNode & cp){
	if(cp._coef!=0 && cp._expn!=1)
		os<<cp._coef<<"x^"<<cp._expn;
	else if(cp._coef!=0 && cp._expn==1)
		os<<cp._coef<<"x";

	return os;
}

bool expnComp(const CNode & A,const CNode & B){
	if(A.expn()>B.expn())	return true;
	else return false;
}

/*************************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; 
};
int find_pos(const vector<int>& expn_vec, int val);
//用系数向量和指数向量构造多项式 
CPolynomial::CPolynomial(const vector<double>& coef, const vector<int>& expn){
	for(unsigned int i=0;i<expn.size();i++){
		double dval=coef[i];
		int val=expn[i]; 
		unsigned int temp=expn.size();
		for(unsigned int n=0;n<expn.size();n++){
			if(n=temp)  continue;
			int pos=find_pos(expn,val);
			if(pos!=i && pos!=expn.size()){
				dval=dval+coef[pos];
				temp=pos;
			}
		}
		CNode tempnode(coef[i],expn[i]);

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

int find_pos(const vector<int>& expn_vec, int val){
	int pos=expn_vec.size();
	for(unsigned int i=0;i<expn_vec.size();++i){
		if(expn_vec[i]==val){
			pos=i;
			return pos;
		}
	}
	return pos;
}


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

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

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

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

	while(iter!=_polyList.end()){
		result+=iter->coef() * pow(x, iter->expn());
		iter++;
	}

	return result;
}

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

	while(iter_r!=iter_re){
		CNode tempnode(iter_r->coef(), iter_r->expn());

		(*this)._polyList.push_back(tempnode);
		iter_r++;
	}

	return (*this);
}

//重载多项式加法操作符
CPolynomial operator+( const CPolynomial& A, const CPolynomial& B ){
	double coef;
	int expn;
	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()){
			coef=iter_A->coef();
			expn=iter_A->expn();
			CNode newnode(coef,expn);

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

			CPSum._polyList.push_back(newnode);
			iter_B++;
		}
		else{
			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){
			coef=iter_A->coef();
			expn=iter_A->expn();
			CNode newnode(coef,expn);

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

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

	return CPSum;
}

ostream& operator <<( ostream& os , const CPolynomial& P){
	if(P._polyList.empty())
		cout<<"多项式不存在！";
	else{
		//定义遍历链表迭代子
		list<CNode>::const_iterator iter_P=P._polyList.begin();
		list<CNode>::const_iterator iter_Pe=P._polyList.end();

		for(unsigned int i=0;i<P._polyList.size();i++){
			os<<(*iter_P);	//由于CNode中已重载了“<<”输出多项式的项
											//此处无需再重复构建
			++iter_P;		//指向下一项
			if(i!=(P._polyList.size()-1) &&  iter_P->coef()>=0)	os<<"+";	
																				//如果此项不是最后一项
																				//判断并输出符号
		}
		os<<endl;
	}

	return os;
}