问个简单的关于输入符重载的问题，明眼人应该一看就知道。

[tommyxdf]

初学者， 帮我看看这个程序是怎么回事，之前都没问题，刚刚就是加了个输入符重载的方法，连接时就报错，谢谢了。
还有，我是这个论坛的新手，没什么经验和技术，如何才能赚分。

头文件：
#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H

#include <iostream>
using std::ostream;
using std::istream;

class Polynomial
{


private:
struct NumberElement
{
int coefficient;
int exponent;
struct NumberElement *next;
};
NumberElement *head;

public:
Polynomial()
{
head = NULL;
}
Polynomial(const Polynomial &);
~Polynomial();

const Polynomial &operator=( const Polynomial &);
Polynomial operator+(const Polynomial &);
bool operator==( const Polynomial &right);

void insertElement(int, int);
void deleteElement(int);
void display(ostream &) const;
void read(istream &);
};
istream &operator>>( istream &, const Polynomial &);
ostream &operator<<( ostream &, const Polynomial &);

#endif


类CPP：
// Member-function definitions for class Polynomial
#include <iostream>
using std::cerr;
using std::cout;
using std::cin;
using std::endl;

#include "Polynomial.h"

Polynomial::Polynomial(const Polynomial &polyCopy)
{
NumberElement *elementPtr;

elementPtr = polyCopy.head;
NumberElement *nm=new NumberElement;
head=nm;
NumberElement *np=polyCopy.head;
nm->coefficient=np->coefficient;
nm->exponent=np->exponent;
while(np->next!=0)
{
nm->next = new NumberElement;
nm=nm->next; np=np->next;
nm->coefficient=np->coefficient;
nm->exponent=np->exponent;
}
nm->next = NULL;
}


void Polynomial::insertElement(int a, int b)
{
NumberElement *newElement;
NumberElement *elementPtr;
NumberElement *previousElement = NULL;

newElement = new NumberElement;
newElement->coefficient = a;
newElement->exponent = b;

if(!head)
{
head = newElement;
newElement->next = NULL;
}

else
{
elementPtr = head;
previousElement = NULL;

while(elementPtr!=NULL&&newElement->exponent<elementPtr->exponent)
{
previousElement = elementPtr;
elementPtr = elementPtr->next;
}

if(previousElement==NULL)
{
head = newElement;
newElement->next = elementPtr;
}

else
{
if(elementPtr==NULL)
{
previousElement->next = newElement;
newElement->next = NULL;
}
else
{
previousElement->next = newElement;
newElement->next = elementPtr;
}
}

}
}

void Polynomial::deleteElement(int n)
{
NumberElement *elementPtr;
NumberElement *previousElement;

if(!head)
return;

if(head->exponent==n)
{
elementPtr = head->next;
delete head;
head = elementPtr;
}
else
{
elementPtr = head;

while(elementPtr!=NULL&&elementPtr->exponent!=n)
{
previousElement = elementPtr;
elementPtr = elementPtr->next;
}

if(elementPtr)
{
previousElement->next = elementPtr->next;
delete elementPtr;
}
}
}

const Polynomial &Polynomial::operator=(const Polynomial &right)
{

NumberElement *p,*q, *r;
head = NULL;
if (!right.head)
return *this;
head = new NumberElement;
head->coefficient = right.head->coefficient;
head->exponent = right.head->exponent;
head->next = NULL;
r=NULL;
p=head;
q=right.head->next;
while(q!=NULL)
{
r = new NumberElement;
r->coefficient = q->coefficient;
r->exponent = q->exponent;
r->next = NULL;
p->next = r;
p = p->next;
q = q->next;
}
return *this;

}

Polynomial Polynomial::operator+(const Polynomial &polyAdd)
{
Polynomial temp;
NumberElement *p, *q;
p = this->head;
q = polyAdd.head;
int coefficient, exponent;

temp.head = new NumberElement;
if (p->exponent==q->exponent)
{
coefficient = p->coefficient + q->coefficient;
exponent = p->exponent;
temp.head->coefficient = coefficient;
temp.head->exponent = exponent;
temp.head->next = NULL;
p = p->next;
q = q->next;
}

while(p!=NULL&&q!=NULL)
{
if(p->exponent>q->exponent)
{
coefficient = p->coefficient;
exponent = p->exponent;
temp.insertElement(coefficient, exponent);
cout<<coefficient<<", "<<exponent<<" copied"<<endl;
p = p->next;
}

else if(p->exponent<q->exponent)
{
coefficient = p->coefficient;
exponent = q->exponent;
temp.insertElement(coefficient, exponent);
cout<<coefficient<<", "<<exponent<<" copied"<<endl;
q = q->next;
}

else
{
coefficient = p->coefficient + q->coefficient;
exponent = p->exponent;
temp.insertElement(coefficient, exponent);
cout<<coefficient<<", "<<exponent<<" copied"<<endl;
p = p->next;
q = q->next;
}
}

while (p!=NULL&&q==NULL)
{
coefficient = p->coefficient;
exponent = p->exponent;
temp.insertElement(coefficient, exponent);
cout<<coefficient<<", "<<exponent<<" copied"<<endl;
p = p->next;
}

while(q!=NULL&&p==NULL)
{
coefficient = q->coefficient;
exponent = q->exponent;
temp.insertElement(coefficient, exponent);
cout<<coefficient<<", "<<exponent<<" copied"<<endl;
q = q->next;
}

cout<<temp<<endl;


//Polynomial temp(polyAdd);

return temp;
}

bool Polynomial::operator== (const Polynomial &right)
{
NumberElement *leftElement = this->head;
NumberElement *rightElement = right.head;
bool boolean = true;

if(leftElement!=NULL&&rightElement==NULL)
{
boolean = false;
return boolean;
}

else if(leftElement==NULL&&rightElement!=NULL)
{
boolean = false;
return boolean;
}

else if(leftElement==NULL&&rightElement==NULL)
{
boolean = true;
return boolean;
}

while(leftElement==rightElement)
{
leftElement = leftElement->next;
rightElement = rightElement->next;
}

if(leftElement!=NULL||rightElement!=NULL)
{
boolean = false;
}

return boolean;
}


void Polynomial::display(ostream &out) const
{
NumberElement *elementPtr = this->head;
while(elementPtr->next!=NULL)
{
out << elementPtr->coefficient << "X^" << elementPtr->exponent << " + ";
elementPtr = elementPtr->next;
}

out << elementPtr->coefficient << "X^" << elementPtr->exponent <<endl;
}

void Polynomial::read(istream &in)
{
NumberElement *inPtr = new NumberElement;
int coefficient = inPtr->coefficient;
int exponent = inPtr->exponent;
in>>coefficient>>exponent;
if(!head)
{
head = inPtr;
head->next = NULL;
}
else
insertElement(coefficient, exponent);
}

Polynomial::~Polynomial()
{
NumberElement *elementPtr;
NumberElement *nextElement;

elementPtr = head;

while (elementPtr != NULL)
{
nextElement = elementPtr->next;

delete elementPtr;

elementPtr = nextElement;
}
}


istream &operator>>(istream &in, Polynomial poly)
{
poly.read(in);
return in;
}




ostream &operator<<(ostream &out, const Polynomial &poly)
{
poly.display(out);

return out;
}

运行CPP：
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

#include "Polynomial.h"

int main()
{
Polynomial poly1;
Polynomial poly2;
Polynomial poly3;


bool end = false;
char choice;
while(!end)
{
cout << "Please input the number element of polynomial one:"<<endl;
cin >> poly1;
cout << "Add more?[Y/N]: ";
cin >> choice;
choice = toupper(choice);
if(choice=='N')
{
end = true;
}
}

cout<<poly1<<endl;
poly2 = poly1;
cout<<poly2<<endl;
//poly3=poly2;cout<<poly3;
cout<<"here"<<endl;
//cout<<poly1+poly2<<endl;
poly3 = poly1 + poly2;
cout<<"here"<<endl;

return 0;
}

[lightnut]

istream &operator>>( istream &, const Polynomial &);
=====>
istream &operator>>( istream &, Polynomial &);

[heartlesstoanyone]

istream& operator>>(istream &, Polynomial &);

[tommyxdf]

哦 谢谢 疏忽了
可是还是有问题啊，我输入两个以上的元素后，就显示乱码， 不知道是怎么回事？

[tommyxdf]

我之前没有输入符重载的时候运行CPP用
int main()
{
Polynomial poly1, poly2, poly3;
int exp, coe;
cout<<"Please input"<<endl;
cin>>coe>>exp;
poly1.insertElement(coe,exp);

cout<<"input again"<<endl;
cin>>coe>>exp;
poly1.insertElement(coe,exp);

cout<<poly1<<endl;
poly2 = poly1;
cout<<poly2<<endl;
poly3 = poly1 + poly2;
cout<<poly3<<endl;
return 0;
}
没有出现这个问题的

[猫已经找不回了]

重载输出的对象不能是const.

[tommyxdf]

istream &operator>>( istream &, Polynomial &);
ostream &operator<<( ostream &, const Polynomial &);
有问题么 我都改过来了 输入数字后还是乱码

[Sco_field]

void Polynomial::read(istream &in) 
{ 
	NumberElement *inPtr = new NumberElement; 
	int &coefficient = inPtr->coefficient;  // 用引用或指针，不能用值，否则读入的数据不会存储到head内
	int &exponent = inPtr->exponent;        // 同上

[Quote=引用 6 楼 tommyxdf 的回复:]
istream &operator>>( istream &, Polynomial &);
ostream &operator < <( ostream &, const Polynomial &);
有问题么 我都改过来了 输入数字后还是乱码
[/Quote]

[Sco_field]

k，居然没有被加粗 - -

int coefficient = inPtr->coefficient; // 用引用或指针，不能用值，否则读入的数据不会存储到head内
int exponent = inPtr->exponent;

-》


int &coefficient = inPtr->coefficient; // 用引用或指针，不能用值，否则读入的数据不会存储到head内
int &exponent = inPtr->exponent;