C++ Copie Constructor Comportement étrange

Question

Vu le code suivant:

class monomial { 
public: 
    mp_real coe; 
    int exp;   
    monomial *next; 
}; 

class polynomial 
{ 
private: 
    monomial *start; 
public: 
    polynomial(); 
    ~polynomial(); 
    void destroy_poly(monomial *); 
    polynomial & operator=(const polynomial &); 
    polynomial(const polynomial&); 
    monomial * get_start(); 
}; 
polynomial::polynomial() { 
    start = NULL; 
} 
polynomial::~polynomial() { 
    if (start != NULL) { 
     destroy_poly(start); 
    } 
    start = NULL; 
} 
void 
polynomial::destroy_poly(monomial * m) { 
    monomial * cm = m; 
    if (cm->next != NULL) { 
     destroy_poly(cm->next); 
    } 
    delete m; 
} 
polynomial::polynomial(const polynomial& p) { 
    if (p.start != NULL) { 
     start = new monomial(); 
     start->coe = p.start->coe; 
     start->exp = p.start->exp; 

     monomial * tmpPtr = p.start; 
     monomial * lastPtr = start; 

     while (tmpPtr->next != NULL) { 
      monomial * newMon = new monomial(); 
      newMon->coe = tmpPtr->next->coe; 
      newMon->exp = tmpPtr->next->exp; 

      lastPtr->next = newMon; 
      lastPtr = lastPtr->next; 
      tmpPtr = tmpPtr->next; 
     } 
    } 
} 
polynomial & polynomial::operator=(const polynomial &p) { 
    if (p.start != NULL) { 
     start = new monomial(); 
     start->coe = p.start->coe; 
     start->exp = p.start->exp; 

     monomial * tmpPtr = p.start; 
     monomial * lastPtr = start; 

     while (tmpPtr->next != NULL) { 
      monomial * newMon = new monomial(); 
      newMon->coe = tmpPtr->next->coe; 
      newMon->exp = tmpPtr->next->exp; 

      lastPtr->next = newMon; 
      lastPtr = lastPtr->next; 
      tmpPtr = tmpPtr->next; 
     } 
    } 
    return *this; 
} 

Puis, en main.cpp:

main() { 
    polynomial poly; 
    // code that initializes/sets values for 
    // various monomials pointed to by poly.start. 

    map<set<unsigned int>, polynomial> hash; 
    set<unsigned int> tmpSet; 

    tmpSet.insert(0); 

    hash[tmpSet] = poly; 
} 

je peux mettre un point d'arrêt sur la première ligne du constructeur de copie, et après que je step-over la ligne de hachage [tmpSet] = poly, p.start à l'intérieur du constructeur de copie est NULL. Ensuite, il est appelé une seconde fois, à quel moment p.start a des valeurs étranges à l'intérieur.

Qu'est-ce qui se passe?

Merci, Erich

EDIT 1: la pensée en ajoutant l'opérateur d'affectation à la classe polynomiale fixe, mais il n'a pas. Toujours avoir le même problème.

Answer 1

Vous violez le Rule of Three:
Puisque vous surchargez Copier constructeur, vous Si surcharge opérateur d'affectation de copie et destructor pour votre classe.

La déclaration ci-dessus était en référence aux scénarios généraux, Dans votre exemple de code, vous pouvez remplacer le devrait avec un doit.

Answer 2

Vous devez ajouter un constructeur par défaut, où vous initialisez start to NULL.

Answer 3

Deux numéros.

1) Vous n'avez pas de constructeur sans argument, donc le compilateur classe les valeurs initiales comme bon lui semble. Le fait que p.start est initialement NULL est

2) Lorsque votre constructeur de copie a adopté une polynomial avec p.start == NULL, vous n'initialise pas l'une des variables dans la classe, de sorte que la copie suivante pourrait avoir toute valeur initiale du compilateur Assigne (voir le problème n ° 1). Pour corriger, vous devez ajouter un constructeur sans argument qui initialise le polynôme dans un état sain. Et puis le constructeur de copie, s'il est passé tel un polynôme, devrait s'initialiser à un état sain.

Answer 4

Comme Als l'a souligné, vous violez la Règle des Trois. Eh bien regardez, quand vous mettez quelque chose dans le conteneur ce qui arrive à vos pointeurs.

monomial *start; 
monomial *next; 

Pensez-y.

Answer 5

Votre constructeur de copie quitte l'ensemble à une valeur aléatoire si p.start == NULL. Cela pourrait être la cause du problème, selon l'autre code dans votre programme. De plus, vous n'avez aucun opérateur d'affectation, donc le compilateur fait des copies superficielles pour vous. Vous devez ajouter une autre fonction polynomial &operator=(const polynomial& b)