opérations polynomiales en utilisant la surcharge des opérateurs

Question

Je suis en train d'utiliser la surcharge d'opérateur pour définir les opérations de base (+, -, *, /) pour ma classe polynomiale mais quand je lance le programme, il se bloque et mes Frozes informatiques

.

Update4

Ok. je l'ai fait avec succès trois des opérations, le seul à gauche est la division.

Voici ce que je suis:

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

Pour ce qui est d'obtenir la fonction ajouter correctement des polynômes, je vous recommande cette logique simple:

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;
}

La dernière partie peut probablement être laissée aux fonctions de la bibliothèque standard

#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));

... mais serait probablement plus simple en utilisant list.insert :

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

Answer 2

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

Je pense que vous aurez besoin && là, sinon la boucle se termine que si i et p.i atteignent leur extrémité respective en même temps.

Logique avec négations est délicate. Probablement plus simple de penser à cela comme:

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

qui, selon arithmétique booléenne est la même que:

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

Vous ne semblez pas être aussi incrémenter les itérateurs si les deux sont égaux (boucle infinie conduisant à un nombre infini allocations de mémoire?).

---

Problèmes de style: vous feriez mieux d'utiliser itérateurs comme variables locales. Ne faites pas les membres de la classe variables si elles sont censées être « initialisé » avant de commencer à les utiliser dans une méthode, et ils deviennent inutiles après la méthode complète.

arguments préfèrent également en passant par référence const, et marquer les fonctions membres const si elles ne modifient pas l'objet courant (operator+ ne doit pas):

 polinom operator+(const polinom& P) const;

(qui révélerait le problème de faire des membres itérateurs utilisés localement - vous être en train de modifier les instances)

Answer 3

Il y a d'autres problèmes de conception et avec exactitude votre code, mais je pense que l'accident se produit dans cette ligne

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

quand je == poly.end () && P.i! = P.End () ou i! = Poly.end () && P.i == P.End (). Déréférencement i quand il fait après le dernier élément se bloque.