我有这个代码中的错误，所以请解决这个问题并解释 [英] i have bug in this code so please fix this any and also explain

问题描述

#include< iostream>

#include< cctype>

#include< cstdlib>

#include< vector> ;

#include< list> #include< algorithm>

使用命名空间std;



class变量{

public：

char id;

int exp;

Variable（）{//由< vector>;

}

变量（char c，int i）{

id = c; exp = i;

}

bool operator ==（const Variable& v）const {

return id == v.id& &安培; exp == v.exp;

}

bool运算符< （const Variable& v）const {//由sort（）使用;

返回id< v.id;

}

};

class Term {

public：

Term（）{

coeff = 0;

}

int coeff;

vector< variable> vars;

bool operator ==（const Term&）const;

bool operator！=（const Term& term）const {//由< list>返回！（* this == term）;

}

bool operator< （const Term&）const;

bool运算符> （const术语和术语）const {//需要< list> return * this！= term&& （* this< term）;

}

int min（int n，int m）const {

return（n< m ）？ n：m;

}

};

类多项式{

public：

多项式（）{

}

多项式运算符+（const多项式&）const;

void error（char * s）{

cerr<< s<< ENDL;退出（1）;

}

私人：

list< term>条款;

朋友istream&运营商GT;> （istream&，Polynomial&）;

朋友ostream&运营商LT;< （ostream&，const Polynomial&）;

};



bool Term :: operator ==（const Term& term）const {

int i;

for（int i = 0; i< min（vars.size（），term.vars.size（））&& vars [i] == term.vars [i]; i ++）;

返回i == vars.size（）&& vars.size（）== term.vars.size（）;

}

bool Term :: operator< （const Term& term2）const {//由sort（）使用;

if（vars.size（）== 0）

返回false; // *这只是一个系数;

else if（term2.vars.size（）== 0）

返回true; // term2只是一个系数;

for（int i = 0; i< min（vars.size（），term2.vars.size（））; i ++）

if（vars [i] .id< term2.vars [i] .id）

返回true; // *这在term2之前;

else if（term2.vars [i] .id< vars [i] .id）

返回false; // term2在* this之前;

else if（vars [i] .exp< term2.vars [i] .exp）

返回true; // *这在term2之前;

else if（term2.vars [i] .exp< vars [i] .exp）

返回false; // term2在* this之前;

return（（int）vars.size（） - （int）term2.vars.size（）< 0）？ true：false;

}

多项式多项式::运算符+（const多项式和多项式2）const {

多项式结果;

list< term> :: iterator p1，p2;

bool擦除;

for（p1 = terms.begin（）; p1！= terms.end（ ）; p1 ++）//创建一个新的
result.terms.push_back（* p1）; //来自

//的副本* this

for（p1 = polyn2.terms.begin; p1！= polyn2.terms.end（）; p1 ++）

result.terms.push_back（* p1）; //和poly2;

for（p1 = result.terms.begin（）; p1！= result.terms.end（）;）{

for（p2 = p1，p2 ++，erased = false; p2！= result.terms.end（）;

p2 ++）

if（* p1 == * p2）{// if两个术语相等（除了

p1-> coeff + = p2-> coeff; //系数），添加

result.terms.erase（ P2）; //两个系数并擦除

if（p1-> coeff == 0）//冗余项;如果

result.terms.erase（p1）; //系数保留

erased = true; // term是零，break;

//也删除这个词;

}

if（擦除）//重启处理开头

p1 = result.terms.begin（）; //如果任何节点被删除;

其他p1 ++;

}

result.terms.sort（）;

返回结果;

}

istream&运营商GT;> （istream& in，Polynomial& polyn）{

char ch，sign，coeffUsed，id;

int exp;

术语; < >>中的
ch;

while（true）{

coeffUsed = 0;

if（！isalnum（ch）&& ch！=' ;'&& ch！=' - '&& ch！='+'）

poly.error（错误的字符输入2）;

sign = 1;

while（ch ==' - '|| ch =='+'）{//首先得到期限的标志

if（ ch ==' - '）

sign * = -1;

ch = in.get（）;

if（isspace（ch） ））>>中的
ch;

}

if（isdigit（ch））{//然后是它的系数;

in.putback（ch）; < >>中的
term.coeff;

ch = in.get（）;

term.coeff * = sign;

coeffUsed = 1;

}

else term.coeff = sign;

for（int i = 0; isalnum（ch）; i ++）{//处理这个术语：

id = ch; //获取变量名

ch = in.get（）;

if（isdigit（ch））{//和指数（如果有的话）;

in.putback（ch）;

in>> exp>> ch;

}

else exp = 1;

term.vars.push_back（变量（id，exp））;

}

polyn.terms.push_back（term）; //并将其包含在链表中;

term.vars.resize（0）;

if（isspace（ch））

in>> ch;

if（ch ==';'）//如果输入分号则结束;

if（coeffUsed || i> 0）

休息;

其他是poly.error（期限丢失）; //例如，2x - ;或者

//只是';'

否则if（ch！=' - '&& ch！='+'）//例如，2x 4y;

poly.error（输入错误字符）;

}

for（list< term> :: iterator i = polyn.terms .begin（）;

i！= num.terms.end（）; i ++）

if（i-> vars.size（）> 1）

sort（i-> vars.begin（），i-> vars.end（））;

返回;

}

ostream&运营商LT;< （ostream& out，const Polynomial& poly）{

int afterFirstTerm = 0，i;

for（list< term> :: iterator pol = polyn.terms.begin （）;

pol！= poly.terms.end（）; pol ++）{

out.put（''）;

if （pol-> coeff< 0）//在多项式之前加上' - '
out.put（' - '）; //和术语之间（如果需要

//）;

否则if（afterFirstTerm）//不要在'/'前加上'+'
out.put（'+'）; //多项式;

afterFirstTerm ++;

if（abs（pol-> coeff）！= 1）//打印系数

out << ''<< ABS（POL->系数_）; //如果它不是1或-1，或

else if（pol-> vars.size（）== 0）//该术语只有一个

//系数

out<< 1;

else out.put（''）;

for（i = 1; i< = pol-> vars.size（）; i ++ ）{

out<< POL->乏[I-1] .ID; //打印一个变量名

if（pol-> vars [i-1] .exp！= 1）//和一个指数，只有

out< < POL->乏[I-1] .EXP; //如果不是1;

}

}

out<<结束;

退出;

}

int main（）{

多项式poly1，poly2;

cout<< 输入两个多项式，每个以分号结尾：\ n;

cin>> poly1>> poly2;

cout<< 结果是：\ n<< poly1 + poly2;

返回0;

}

#include <iostream>
#include <cctype>
#include <cstdlib>
#include <vector>
#include <list>#include <algorithm>
using namespace std;

class Variable {
public:
char id;
int exp;
Variable() { // required by <vector>;
}
Variable(char c, int i) {
id = c; exp = i;
}
bool operator== (const Variable& v) const {
return id == v.id && exp == v.exp;
}
bool operator< (const Variable& v) const { // used by sort();
return id < v.id;
}
};
class Term {
public:
Term() {
coeff = 0;
}
int coeff;
vector<variable> vars;
bool operator== (const Term&) const;
bool operator!= (const Term& term) const { // required by <list>return !(*this == term);
}
bool operator< (const Term&) const;
bool operator> (const Term& term) const { // required by <list>return *this != term && (*this < term);
}
int min(int n, int m) const {
return (n < m) ? n : m;
}
};
class Polynomial {
public:
Polynomial() {
}
Polynomial operator+ (const Polynomial&) const;
void error(char *s) {
cerr << s << endl; exit(1);
}
private:
list<term> terms;
friend istream& operator>> (istream&, Polynomial&);
friend ostream& operator<< (ostream&, const Polynomial&);
};

bool Term::operator== (const Term& term) const {
int i;
for (int i = 0; i < min(vars.size(),term.vars.size()) &&vars[i] == term.vars[i]; i++);
return i == vars.size() && vars.size() == term.vars.size();
}
bool Term::operator< (const Term& term2) const { // used by sort();
if (vars.size() == 0)
return false; // *this is just a coefficient;
else if (term2.vars.size() == 0)
return true; // term2 is just a coefficient;
for (int i = 0; i < min(vars.size(),term2.vars.size()); i++)
if (vars[i].id < term2.vars[i].id)
return true; // *this precedes term2;
else if (term2.vars[i].id < vars[i].id)
return false; // term2 precedes *this;
else if (vars[i].exp < term2.vars[i].exp)
return true; // *this precedes term2;
else if (term2.vars[i].exp < vars[i].exp)
return false; // term2 precedes *this;
return ((int)vars.size()-(int)term2.vars.size() < 0) ? true : false;
}
Polynomial Polynomial::operator+ (const Polynomial& polyn2) const {
Polynomial result;
list<term>::iterator p1, p2;
bool erased;
for (p1 = terms.begin(); p1 != terms.end(); p1++) // create a new
result.terms.push_back(*p1); // polyn from
// copies of *this
for (p1 = polyn2.terms.begin; p1 != polyn2.terms.end(); p1++)
result.terms.push_back(*p1); // and polyn2;
for (p1 = result.terms.begin(); p1 != result.terms.end(); ) {
for (p2 = p1, p2++, erased = false; p2 != result.terms.end();
p2++)
if (*p1 == *p2) { // if two terms are equal (except
p1->coeff += p2->coeff; // for the coefficient), add the
result.terms.erase(p2); // two coefficients and erase
if (p1->coeff == 0) // a redundant term; if the
result.terms.erase(p1); // coefficient in retained
erased = true; // term is zero, break;
// erase the term as well;
}
if (erased) // restart processing from the beginning
p1 = result.terms.begin(); // if any node was erased;
else p1++;
}
result.terms.sort();
return result;
}
istream& operator>> (istream& in, Polynomial& polyn) {
char ch, sign, coeffUsed, id;
int exp;
Term term;
in >> ch;
while (true) {
coeffUsed = 0;
if (!isalnum(ch) && ch != ';' && ch != '-' && ch != '+')
polyn.error("Wrong character entered2");
sign = 1;
while (ch == '-' || ch == '+') { // first get sign(s) of Term
if (ch == '-')
sign *= -1;
ch = in.get();
if (isspace(ch))
in >> ch;
}
if (isdigit(ch)) { // and then its coefficient;
in.putback(ch);
in >> term.coeff;
ch = in.get();
term.coeff *= sign;
coeffUsed = 1;
}
else term.coeff = sign;
for (int i = 0; isalnum(ch); i++) { // process this term:
id = ch; // get a variable name
ch = in.get();
if (isdigit(ch)) { // and an exponent (if any);
in.putback(ch);
in >> exp >> ch;
}
else exp = 1;
term.vars.push_back(Variable(id,exp));
}
polyn.terms.push_back(term);// and include it in the linked list;
term.vars.resize(0);
if (isspace(ch))
in >> ch;
if (ch == ';') // finish if a semicolon is entered;
if (coeffUsed || i > 0)
break;
else polyn.error("Term is missing"); // e.g., 2x - ; or
// just ';'
else if (ch != '-' && ch != '+') // e.g., 2x 4y;
polyn.error("wrong character entered");
}
for (list<term>::iterator i = polyn.terms.begin();
i != polyn.terms.end(); i++)
if (i->vars.size() > 1)
sort(i->vars.begin(),i->vars.end());
return in;
}
ostream& operator<< (ostream& out, const Polynomial& polyn) {
int afterFirstTerm = 0, i;
for (list<term>::iterator pol = polyn.terms.begin();
pol != polyn.terms.end(); pol++) {
out.put(' ');
if (pol->coeff < 0) // put '-' before polynomial
out.put('-'); // and between terms (if
// needed);
else if (afterFirstTerm) // don’t put '+' in front of
out.put('+'); // polynomial;
afterFirstTerm++;
if (abs(pol->coeff) != 1) // print a coefficient
out << ' ' << abs(pol->coeff); // if it is not 1 nor -1, or
else if (pol->vars.size() == 0) // the term has only a
// coefficient
out << " 1";
else out.put(' ');
for (i = 1; i <= pol->vars.size(); i++) {
out << pol->vars[i-1].id; // print a variable name
if (pol->vars[i-1].exp != 1) // and an exponent, only
out << pol->vars[i-1].exp; // if it is not 1;
}
}
out << endl;
return out;
}
int main() {
Polynomial polyn1, polyn2;
cout << "Enter two polynomials, each ended with a semicolon:\n";
cin >> polyn1 >> polyn2;
cout << "The result is:\n" << polyn1 + polyn2;
return 0;
}

推荐答案

否。

我们不是来做你的工作，也不是你的家庭作业。

你想趟过那堆评论不好的代码并解决你发现的问题吗？



请记住，我们不知道它应该做什么，更不用说你认为它做错了。



因此启动调试器并学会使用它：它是一种技能（并且是一种非常有价值的技能，影响你在现实世界中的思考方式），只有在你使用它时才会发展。

所以这是一个完美的开始时间。

No.
We are not here to do your work, or your homework either.
Would you want to wade through that pile of poorly commented code and work out wht the problem you have found is?

And bear in mind we have no idea what it is supposed to do, much less what you think it is doing wrong.

So fire up the debugger, and learn to use it: it's a skill (and a very valuable one that influences how you think in the real world) which you will only develop when you use it.
So this is a perfect time to start.

这篇关于我有这个代码中的错误，所以请解决这个问题并解释的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！