polynn.h

用从c++语言实现多项式的输入及计算

#ifndef POLYN_H
#define POLYN_H
//多项式类。未用有序表实现。
#include <iostream.h>
#include <math.h>
#include "linklist.h"
class term                        //项类
{
public:
	term(int c=0,int p=0);
	term(const term& r);
   term operator *(const term& r) ;
   term operator +(const term& r) ;// power相同才可用
   int operator ==(const term& r) ;
   double evalAt(double x) const;
   term operator -() const;
private:
   int coefficient;
   int power;   //删除const ,才能用=
   friend class polynomial;
   friend ostream& operator << (ostream& , const term& );
   friend ostream& operator << (ostream& out, polynomial& p);
   friend bool divided(const polynomial&,polynomial&,polynomial&,polynomial&);
};
term::term(int c,int p):coefficient(c),power(p)
{
}
term::term(const term& r):coefficient(r.coefficient),power(r.power)
{}
term term::operator*(const term& r)
{
	return term(coefficient*r.coefficient,power+r.power);
}
term term::operator+(const term& r)
{
	assert(power=r.power);
	return term(coefficient+r.coefficient,power);
}
term term::operator -() const
{
	return term(-coefficient,power);
}
int term::operator==(const term& r)
{
	return(coefficient==r.coefficient)&&(power==r.power);
}
double term::evalAt(double x) const
{
	return coefficient*pow(x,power);
}
ostream&operator<<(ostream & out,const term& val)
{
	if(val.coefficient==0)
		return out;
	out<<val.coefficient;
	switch(val.power){
	case 0:
		break;
	//case 1:
	//	cout<<"X";             加上这一句则输入1*x^1时，输出为1XX^1. ??
	default:
		if(val.power ==1)         //为使输出为1X,加上这一句。
			out<<"X";
		else
		    out<<"X^"<<val.power;
		break;
	}
	return out;
}




///////////////////////////////////////////////////////////////////////////////////////
class polynomial
{
public:
	polynomial();
   //polynomial(const polynomial& p); //list<T>已经深拷贝，这里可略
   polynomial(term& t);
   polynomial(int c);                     //增加0次式
   polynomial(int l,int c);               //    1次式
   polynomial(int q,int l,int c);         //    2次式
   //polynomial& operator =( const polynomial& r); //可略
   void operator +=( polynomial& r);
   polynomial operator -( );
   void operator -=( polynomial& r);
   void operator *=(const term& t);
   double poly(double x);
   //删除+成员函数，改为普通函数
private:
	list<term> exp;
   friend ostream& operator << (ostream& out, polynomial& p);
   friend istream& operator >> (istream& in,  polynomial& p);
   friend polynomial operator *(  polynomial& p ,const polynomial& q);
   friend polynomial operator*(const polynomial& p,const term & t);
   friend bool divided(const polynomial&,polynomial&,polynomial&,polynomial&);
};




polynomial::polynomial()
{}

polynomial::polynomial(term& t)
{
	exp.add(t);                         //插入一项。
}

polynomial::polynomial(int c)
{
	exp.add(term(c,0));                //构造一项式。
}

polynomial::polynomial(int c,int l)
{
	exp.add(term(c,0));                  //构造二项式。
	exp.add(term(l,1));
}

polynomial::polynomial(int c,int l,int q)
{
	exp.add(term(c,0));
	exp.add(term(l,1));                //构造三相项式。
	exp.add(term(q,2));
}

void polynomial::operator+=(polynomial& r)
{
	listIterator<term>  litr(exp);
	listIterator<term>  ritr(r.exp);
	for(litr.init(),ritr.init();!litr&&!ritr;++litr)
	{
		while(!ritr&&(litr().power<ritr().power)){
			litr.addBefore(ritr());
			++ritr;
		}
		if(!ritr&&ritr().power==litr().power){
			litr=litr()+ritr();
			++ritr;
		}
	}
	while(!ritr){
		litr.addBefore(ritr());
		++ritr;
	}
}

polynomial operator+(const polynomial& p, polynomial& q)
{                                                          //多项式相加。
	polynomial result(p);
	result+=q;
	return result;
}

polynomial operator - (const polynomial& p,polynomial& q)
{
	polynomial temp(p);                                 //多项式相减。
	temp+=(-q);
	return temp;
}

polynomial polynomial::operator - (  )
{                                              //多项式求反。
	listIterator<term> lit(exp);
	polynomial temp;
	for(lit.init();!lit;++lit)
	{
		temp+=polynomial(-lit());
	}
	return temp;
}

void polynomial::operator -= (polynomial& r)
{
	*this+=-r;
}

polynomial operator*(polynomial & p,const polynomial & q)
{
	polynomial result;                                       // 多项式相乘即把各项依次相乘。
	listIterator<term>  itr(p.exp);
	for(itr.init();!itr;++itr)
		result+=q*itr();
	return result;
}

polynomial operator*(const polynomial& p,const term & t)
{
	polynomial result(p);                                 //多项式与某一单项式相乘。利用下面重载
	result*=t;                                            //的"+="运算符。
	return result;
}

void polynomial::operator*=(const term & t)
{
	listIterator<term>  itr(exp);                   //多项式与单项式乘相即把单项式与多项式各项依次相乘。
	for(itr.init();!itr;++itr)
		itr=itr()*t;
}

double polynomial::poly(double x)                   //计算多项式的结果
{
	double result=0; 
	listIterator<term> lit(exp);
	for(lit.init();!lit;++lit)
	{
		result+=lit().evalAt(x);
	}
	return result;
}

ostream&operator<<(ostream &out,polynomial &p)         //输出运算符"<<"的重载
{
	
	int first=1;
	listIterator<term>   itr(p.exp);
	for(itr.init();!itr;++itr)
	{
		if(itr().coefficient<0)
			out<<itr();
		else{
			if(!first)out<<"+";
		first=0;
		out<<itr();
		}
	}
	return out;
}

istream& operator >> (istream& in ,polynomial& p)         //输入运输符">>"的重载。
{
	char end=' ';
	int coe,pow;
	while(end!='#')                                //当输入为"#"时，说明多项式输入结束。
	{
		in>>end;
		switch(end)                               //输入一个字符，当为"*"、"x"、"+"时跳出，
		{                                         //  当为"^"时，输入幂，多项式加上一项
			case '*':                             //   当输入不为以上字符时，返回前一个字符，将它 
				break;                            //作为系数读入。
			case 'x':
				break;
			case '^':
				in>>pow;
				p+=polynomial(term(coe,pow));
				break;
			case '+':
				break;

			default:
				in.putback(end);
				in>>coe;
				break;
		}
	}
	return in;
}

#endif