Polynomial operations using operator overloading

Question

I'm trying to use operator overloading to define the basic operations (+,-,*,/) for my polynomial class but when i run the program it crashes and my computer frozes.

Update4

Ok. i successfully made three of the operations, the only one left is division.

Here's what I got:

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

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

I think you'll need && there, otherwise the loop terminates only if i and p.i reach their respective end at the same time.

Logic with negations is tricky. Probably simpler to think of this as:

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

which according to boolean arithmetic is the same as:

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

You also don't seem to be incrementing the iterators if both are equal (infinite loop leading to infinitely many memory allocations?).

---

Style issues: you are better off using iterators as local variables. Don't make variables class members if they are supposed to be "initialized" before you start using them in a method, and they become useless after the method completes.

Also prefer passing arguments by const reference, and mark member functions const if they don't modify the current object (operator+ shouldn't):

 polinom operator+(const polinom& P) const;

(which would reveal the problem making locally used iterators members - you would be modifying the instances!)