c++实现多项式类定义

 c++实现多项式类的定义，可进行+、-、*、赋值运算，可显示已存储几个多项式对象，可计算任意x值下多项式的值。

/ }//构造函数
	~Node() {  }														//析构函数 
	inline Node* Add_Node(float c, int e);														//当前结点后添加结点 
	void Clear_Node();																			//清理结点
	friend Polynomial operator+(const Polynomial& a, const Polynomial& b);						//重载"+"运算符
	friend Polynomial operator-(const Polynomial& a, const Polynomial& b);						//重载"-"运算符
	friend Polynomial operator*(const Polynomial& a, const Polynomial& b);						//重载"*"运算符
};
inline Node* Node::Add_Node(float c, int e) {
	Node* n = new Node(c, e);
	this->next = n;
	return n;
}





class Polynomial {						//多项式类 
private:
	static int count;
	Node* head;
public:
	Polynomial() { Node* p = new Node(0, 0); head = p; count++; }									//重载无参构造函数
	Polynomial(Node* l) :head(l) {  count++; }	//构造函数
	Polynomial(const Polynomial& o);																//拷贝构造函数
	~Polynomial() {  count--; }					//析构函数
	inline void set(Node* p);									//后期修改函数
	inline void clear();						//清理函数
	friend inline void print_count();			//输出多项式总数
	void print()const;							//输出函数
	float compute(float x)const;				//计算函数
	int seek_max()const;						//寻找最高次数
	friend Polynomial operator+(const Polynomial& a, const Polynomial& b);						//重载"+"运算符
	friend Polynomial operator-(const Polynomial& a, const Polynomial& b);						//重载"-"运算符
	friend Polynomial operator*(const Polynomial& a, const Polynomial& b);						//重载"*"运算符
	Polynomial& operator=(const Polynomial& that);												//重载"="运算符
};
inline void Polynomial::set(Node* p) {
	this->head = p;
}
inline void Polynomial::clear() {
	this->head->Clear_Node();
}



inline void print_count() {
	cout << "共存储" << Polynomial::count << "个多项式" << endl;
}

 以下为具体功能实现

/
}

void Polynomial::print() const {
	Node* p = this->head;
	bool flag = false;
	while (p) {
		if (p->coe != 0) {
			if (p->coe > 0) {
				if(flag)
				cout << "+";
			}
			if (p->exp == 0)cout << p->coe;
			else if (p->exp == 1) {
				if (p->coe == 1);
				else if (p->coe == -1)cout << "-";
				else cout << p->coe;
				cout << "x";
			}
			else {
				if (p->coe == 1);
				else if (p->coe == -1)cout << "-";
				else cout << p->coe;
				cout  << "x^" << p->exp;
			}
		}
		p = p->next;
		flag = true;
	}
	cout << endl;
}

float Polynomial::compute(float x)const {
	float result=0;
	Node* p = this->head;
	while (p) {
		result = result + p->coe * pow(x, p->exp);
		p = p->next;
	}
	return result;
}

int Polynomial::seek_max()const {
	Node* p = this->head;
	int max = p->exp;
	while (p) {
		if (p->exp > max)max = p->exp;
		p = p->next;
	}
	return max; 
}

Polynomial operator+(const Polynomial& a, const Polynomial& b) {
	Node* p = a.head;
	Node* q = b.head;
	Node* h = NULL;
	Node* s = NULL;
	int max = 0;
	float x = 0;
	int A = a.seek_max();
	int B = b.seek_max();
	max = A > B ? A : B;
	for (int i = 0; i <= max; i++){
		while (p) {
			if (p->exp == i) {
				x = x + p->coe;
			}
			p = p->next;
		}
		while (q) {
			if (q->exp == i) {
				x = x + q->coe;
			}
			q = q->next;
		}
		if (x) {
			if (h) s = s->Add_Node(x, i);
			else {
				h = new Node(x, i);
				s = h;
			}
		}
		x = 0;
		p = a.head;
		q = b.head;
	}
	Polynomial C(h);
	return C;
}

Polynomial operator-(const Polynomial& a, const Polynomial& b) {
	Node* p = a.head;
	Node* q = b.head;
	Node* h = NULL;
	Node* s = NULL;
	int max = 0;
	float x = 0;
	max = a.seek_max() > b.seek_max() ? a.seek_max() : b.seek_max();
	for (int i = 0; i <= max; i++) {
		while (p) {
			if (p->exp == i) {
				x = x + p->coe;
			}
			p = p->next;
		}
		while (q) {
			if (q->exp == i) {
				x = x - q->coe;
			}
			q = q->next;
		}
		if (x) {
			if (h) s = s->Add_Node(x, i);
			else {
				h = new Node(x, i);
				s = h;
			}
		}
		x = 0;
		p = a.head;
		q = b.head;
	}
	Polynomial C(h);
	return C;
}

Polynomial operator*(const Polynomial& a, const Polynomial& b) {
	Node* p = a.head;
	Node* q = b.head;
	Node* h = NULL;
	Node* s = NULL;
	Polynomial C;
	Polynomial P;
	while (p) {
		while (q) {
			if (h) s = s->Add_Node(p->coe * q->coe, p->exp + q->exp);
			else {
				h = new Node(p->coe * q->coe, p->exp + q->exp);
				s = h;
			}
			q = q->next;
		}
		p = p->next;
		q = b.head;
		P.set(h);
		h = NULL;
		s = NULL;
		C = C + P;
	}
	return C;
}

Polynomial& Polynomial::operator=(const Polynomial& that) {
	Node* q = that.head;
	Node* p = this->head;
	Node* s = p;
	Node* h = NULL;
	while (q) {
		if (p) {
			p->coe = q->coe;
			p->exp = q->exp;
			s = p;
			p = p->next;
		}
		else {
			h = new Node(q->coe, q->exp);
			p = h;
			s->next = p;
			s = p;
			p = p->next;
		}
		q = q->next;
	}
	return *this;
}

以下为测试代码

//********************************************************************
//main.cpp
//********************************************************************
#include"polynomial.h"

int Polynomial::count = 0;

int main() {
	Node* a = new Node(5, 0);
	a->Add_Node(-1,1)->Add_Node(4, 2)->Add_Node(2.1, 3)->Add_Node(-9, 4);
	Node* b = new Node(7, 1);
	b->Add_Node(8.2, 4)->Add_Node(6, 2)->Add_Node(4, 5)->Add_Node(-3, 3);
	Polynomial A(a);
	A.print();
	print_count();
	Polynomial B(b);
	B.print();
	print_count();
	cout << "A(x = 3) = " << A.compute(3) << endl;
	cout << "B(x = 2) = " << B.compute(2) << endl;
	Polynomial C;
	C = A + B;
	cout << "A + B = ";
	C.print();
	C = A - B;
	cout << "A - B = ";
	C.print();
	C = B - A;
	cout << "B - A = ";
	C.print();
	C = A * B;
	cout << "A * B = ";
	C.print();
	print_count();
	Polynomial D(A);
	D.print();
	D = B;
	D.print();
	print_count();
	system("pause");
	A.clear();
	B.clear();
	C.clear();
	D.clear();
	return 0;
}

测试结果如下：

5-x+4x^2+2.1x^3-9x^4
共存储1个多项式
7x+8.2x^4+6x^2+4x^5-3x^3
共存储2个多项式
A(x = 3) = -634.3
B(x = 2) = 273.2
A + B = 5+6x+10x^2-0.9x^3-0.8x^4+4x^5
A - B = 5-8x-2x^2+5.1x^3-17.2x^4-4x^5
B - A = -5+8x+2x^2-5.1x^3+17.2x^4+4x^5
A * B = 35x+23x^2+7x^3+82.7x^4-50.6x^5-31.5x^6+60.22x^7-65.4x^8-36x^9
共存储3个多项式
5-x+4x^2+2.1x^3-9x^4
7x+8.2x^4+6x^2+4x^5-3x^3
共存储4个多项式