Question

我正在编写一个实现稀疏多项式的程序，其中两个全局结构定义如下：

//Global structs to represent a polynomial
struct Term {
   int coeff;
   int degree;
};

struct Node {
   Term *term;
   Node *next;
};

该课程有私人Node *poly;

我正在重载*运算符以获得两个多项式的乘积。

此文件的头文件包含以下定义：

//Returns a polynomial that is the product of polynomial a and b
friend const Polynomial operator *(const Polynomial &a, const Polynomial &b);

并且对于函数，我迭代遍历表示多项式（a＆amp; b）的每个链表，直到达到nullptr，添加度，并乘以系数，创建新项，将其插入临时多项式，并使用我的重载加法运算符将临时多项式添加到返回的多项式。我已经测试了重载的加法运算符并且没有收到这个问题所以我认为这不会导致这个问题。问题是在某些时候我得到了正确答案，在示例输出中，第一次运行是正确的，另一次运行产生一些术语和一些地址：

>PolynomialTester
Enter numbebr of terms of the polynomial: 3
    coefficient degree
Enter term 1:   3 0
Enter term 2:   2 1
Enter term 3:   1 2

3 + 2*x^1 + 1*x^2

Enter numbebr of terms of the polynomial: 3
    coefficient degree
Enter term 1:   3 0
Enter term 2:   2 1
Enter term 3:   1 2

3 + 2*x^1 + 1*x^2
9 + 12*x^1 + 7*x^2 + 6*x^3 + 1*x^4 //Correct
>Exit code: 0    Time: 33.22
>PolynomialTester
Enter numbebr of terms of the polynomial: 3
    coefficient degree
Enter term 1:   3 0
Enter term 2:   2 1
Enter term 3:   1 2

3 + 2*x^1 + 1*x^2

Enter numbebr of terms of the polynomial: 3
    coefficient degree
Enter term 1:   3 0
Enter term 2:   2 1
Enter term 3:   1 2

3 + 2*x^1 + 1*x^2
4109104 + 9 + 12*x^1 + 3*x^2 + 2*x^3 + 1*x^4 + 4108992*x^4108944 + 4109392*x^4109136 //Nope
>Exit code: 0    Time: 19.54

我用于重载*的函数是：

const Polynomial operator *(const Polynomial &a, const Polynomial &b) {
//Computes the sum of two polynomials a + b
//Overloaded + operator

   //The new polynomial that will be returned
   Polynomial polyProduct;

   Polynomial tempPoly;
   //Temporary nodes to process
   Node *tempA = a.poly;
   Node *tempB;

   while(tempA != nullptr) {
      tempB = b.poly;
      while(tempB != nullptr) {

         int degree = tempA->term->degree + tempB->term->degree;
         int coeff = tempA->term->coeff * tempB->term->coeff;
         tempPoly.insert(Polynomial::newTerm(coeff, degree));
         tempB = tempB->next;
      }
      polyProduct = polyProduct + tempPoly;
      tempPoly.deletePoly();
      tempA = tempA->next;
   }

   return polyProduct;
}

PS。 deletePoly（）遍历多项式并首先删除该项，然后删除该节点，直到它为nullptr。

默认构造函数：

Term* Polynomial::newTerm(int c, int d) {
//Creates a new term
   Term *newTerm = new Term;
   newTerm->coeff = c;
   newTerm->degree = d;
   return newTerm;
}

Node* Polynomial::cons(Term *t, Node *p) {
//Creates a new node
   Node *newNode = new Node;
   newNode->term = t;
   newNode->next = p;
   return newNode;
}

Polynomial::Polynomial() {
//Creates the zero polynomial
   poly = cons(newTerm(0, 0), nullptr);
}

PolynomialTester：

   int main() {
   Polynomial newPoly;
   Polynomial newPoly2;
   Polynomial newPoly3;

   newPoly.readPoly();
   cout << "\n";
   newPoly.printPoly();

   cout << "\n";

   newPoly2.readPoly();
   cout << "\n";
   newPoly2.printPoly();

   newPoly3 = newPoly * newPoly2;
   newPoly3.printPoly();
   newPoly3.deletePoly();
   newPoly2.deletePoly();
   newPoly.deletePoly();
}

操作员+

const Polynomial operator +(const Polynomial &a, const Polynomial &b) {
//Computes the sum of two polynomials a + b
//Overloaded + operator

   //The new polynomial that will be returned
   Polynomial polySum;
   //Temporary nodes to process
   Node *tempA = a.poly;
   Node *tempB = b.poly;

   //While neither node A or B is equal to the nullptr
   while(tempA != nullptr && tempB != nullptr) {

      int degreeA = tempA->term->degree;
      int degreeB = tempB->term->degree;

      if(degreeA < degreeB) {
         polySum.insert(tempA->term);
         tempA = tempA->next;
      }

      else if(degreeA > degreeB) {
         polySum.insert(tempB->term);
         tempB = tempB->next;
      }

      else {
         int coeff = tempA->term->coeff + tempB->term->coeff;
         int degree = degreeA;
         polySum.insert(Polynomial::newTerm(coeff, degree));
         tempA = tempA->next;
         tempB = tempB->next;
      }
   }
   //Incase one of the polynomials still has remaining terms
   while(tempA != nullptr) {
      polySum.insert(tempA->term);
      tempA = tempA->next;
   }
   //Incase one of the polynomials still has remaining terms
   while(tempB != nullptr) {
      polySum.insert(tempB->term);
      tempB = tempB->next;
   }
   //Removes any zero coeffiecient terms
   //Possibly due to a positive and negative coefficient being added
   polySum.remZeroCoeff();
   return polySum;
}

复制构造函数：

Polynomial::Polynomial(const Polynomial& oP) {
//Constructs a deep copy of the Polynomial being passed

   poly = nullptr;
   //The list to copy
   Node *toCopy = oP.poly;

   while(toCopy != nullptr) {
      insert(toCopy->term);
      poly->next = toCopy->next;
      toCopy = toCopy->next;
   }
}

重载的赋值运算符，但是我的代码中目前已将其注释掉，因为它似乎只会使事情变得更糟

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

   //Check to see if it's passing itself
   if(this == &a) {
      return *this;
   }

   //Delete current polynomial  
   deletePoly();

   //The poly to copy
   Node *toCopy = a.poly;

   while(toCopy != nullptr) {
      poly = cons(toCopy->term, poly);
      toCopy = toCopy->next;
   }

   //Return a reference to itself
   return *this;
}

任何人都可以帮助我理解为什么我会在某些时候获得地址作为结果吗？

Answer 1

行tempPoly.deletePoly（）;导致这个问题，所以为了提高效率并解决问题，我在插入函数中添加了一个条件，检查传递的术语度是否等于当前多项式中的术语度，如果是，则只需添加该术语的系数，并在不需要之后删除该术语。这消除了在重载*函数中进行任何删除或重载添加的需要，并且提高了效率。

C ++多项式输出精度为50％，内存地址为50％

1 个答案: