使用运算符重载的多项式运算

Question

我试图使用运算符重载来定义多项式类的基本运算（+、-、*、/），但是当我运行程序时，它崩溃了，我的计算机冻结了。

更新4

好的。我成功地进行了三个操作，只剩下一个是除法。

这是我得到的：

polinom operator*(const polinom& P) const
{
    polinom Result;
    constIter i, j, lastItem = Result.poly.end();
    Iter it1, it2, first, last;
    int nr_matches;

    for (i = poly.begin() ; i != poly.end(); i++) {
         for (j = P.poly.begin(); j != P.poly.end(); j++)
              Result.insert(i->coef * j->coef, i->pow + j->pow);
    }

    Result.poly.sort(SortDescending());

    lastItem--;

    while (true) {
        nr_matches = 0;

        for (it1 = Result.poly.begin(); it1 != lastItem; it1++) {
             first = it1;
             last = it1;
             first++;
             for (it2 = first; it2 != Result.poly.end(); it2++) { 
                  if (it2->pow == it1->pow) {
                      it1->coef += it2->coef;
                      nr_matches++;
                  }
             }

             nr_matches++;
             do {
                last++;
                nr_matches--;
             } while (nr_matches != 0);

             Result.poly.erase(first, last);
        }   
        if (nr_matches == 0)
            break;
    }     

    return Result;
}

Answer 1

崩溃发生在这一行中。

 if (i->pow > P.i->pow) 

您的代码还存在其他设计和正确性问题，但我认为当 i == poly.end() && 时， Pi != P.End() 或 i != poly.end() && Pi == P.End()。当 i 指向最后一个元素之后时取消引用 i 将会崩溃。

Answer 2

至于让函数正确地累加多项式，我建议使用这个简单的逻辑：

polinom operator+(const polinom& P) const //fixed prototype re. const-correctness
{
    polinom Result;
    std::list<term>::const_iterator //fixed iterator type
        i = poly.begin(), j = P.poly.begin();

    while (i != poly.end() && j != P.poly.end()) {
        //logic while both iterators are valid
    }

    //handle the remaining items in each list
    //note: at least one will be equal to end(), but that loop will simply be skipped

    while (i != poly.end()) {
        Result.insert(i->coef, i->pow);
        ++i;
    }

    while (j != P.poly.end()) {
        Result.insert(j->coef, j->pow);
        ++j;
    }

    return Result;
}

最后一部分可能也可以留给标准库函数

#include <iterator>
#include <algorithm>

//...
    //handle remaining items in either list (if any)
     std::copy(i, poly.end(), std::back_inserter(Result.poly));
     std::copy(j, P.poly.end(), std::back_inserter(Result.poly));

......但使用 list.insert：

     Result.poly.insert(Result.poly.end(), i, poly.end());
     Result.poly.insert(Result.poly.end(), j, P.poly.end());

Answer 3

while (i != poly.end() || P.i != P.End())

我想你需要 &&否则，只有当 i 和 pi 同时到达各自的终点时，循环才会终止。

带有否定的逻辑是很棘手的。可能更简单地将其视为：

while (!(i == poly.end() || j == P.End())) //while neither iterator has reached end

根据布尔算术，它与以下内容相同：

while (!(i == poly.end()) && !(j == P.End()))
while (i != poly.end() && j != P.End())

如果两者相等，您似乎也不会增加迭代器（无限循环导致无限多个内存分配？）。

---

风格问题：最好使用迭代器作为局部变量。如果在方法中开始使用变量之前应该“初始化”变量，则不要将变量设置为类成员，并且在方法完成后它们将变得无用。

也更喜欢通过 const 引用传递参数，如果成员函数不修改当前对象（operator+ 不应该），则标记成员函数 const ：（

 polinom operator+(const polinom& P) const;

这会揭示问题本地使用的迭代器成员 - 您将修改实例！）