Discussion :

[black-falco]

Bonjour à tous.

Cela fait quelques temps que je n'ai pas fait de C++ digne de ce nom, j'ai donc quelques problèmes ...

J'ai 2 classes : une classe Sommet et une classe Relation (pour des graphes).
Ma classe relation possède en attributs privés 2 pointeurs sur Sommet (Sommet*) et un int pour le poids de la relation entre les sommets.
Je veux construire tous ces objets dynamiquement afin de les contrôler entièrement.

Le coeur du problème :

Relation* r = new Relation(); // utilise le constructeur par défaut
Relation* r2 = new Relation(r); // devrait utiliser le constructeur par copie

constructeur par copie : Relation::Relation (const Relation&)

En passant la relation r en paramètre, le compilo me dit qu'il est impossible de connvertir un 'Relation *' en 'const Relation'.

Comment résoudre ce problème en laissant tout en dynamique ?

[Davidbrcz]

Quand tu fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Relation* r2 = new Relation(r);

Ce que tu passe au constructeur de Relation c'est un pointeur et non un objet.

Pour avoir un objet,il faut déférencer ton pointeur avec *.
C'est à dire que ton instruction devient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Relation* r2 = new Relation(*r);

[black-falco]

Plus d'erreur de compilation mais des violations mémoire...

Voilà mon constructeur par copie :

Relation::Relation (const Relation &r)
{
delete s1;
delete s2;
s1 = new Sommet(*r.s1);
s2 = new Sommet(*r.s2);
poids = r.poids;
}

Pour mes instances de Sommet, ça marche comme pour Relation.
Sommet* s = new Sommet(5);
Sommet* s2 = new Sommet(*s);

Je pense donc que les étoiles dans les parenthèses de ces instructions sont utiles pour déréférencer le pointeur :
s1 = new Sommet(*r.s1);
s2 = new Sommet(*r.s2);

Mais problème ...

[Médinoc]

s1 et s2 ne sont pas initialisés dans ton constructeur de copie, le delete (qui plus est inutile) a donc un comportement indéfini (et comme tu as du bol, c'est un plantage).

[black-falco]

Merci beaucoup !

Le problème se situait donc au niveau des "delete toto" qui n'avait rien à faire là.
J'ai une excuse, on m'avait dit de faire ça

Donc pour ceux que ça intéresse :
Objet* toto = new Objet(); ne nécessite pas de delete avant de refaire un new dessus

Et lorsqu'on passe en paramètre un pointeur alors que la définition de la fonction/méthode a pour paramètre un <Objet &toto>, ne pas oublier de déréférencer le pointeur pour l'appel.

Merci pour ces réponses très rapide, vraiment cool ce forum =))

[Médinoc]

Le delete sur une variable membre est typiquement à faire dans le destructeur, ou dans une fonction qui modifie.

Mais clairement pas dans le constructeur sur un pointeur non-initialisé. Non seulement le delete sur un pointeur non-initialisé est un comportement indéfini (par opposition au delete NULL qui est garanti ne rien faire), mais ça n'a aucun sens: Puisque la variable n'existait pas avant, elle ne peux absolument pas pointer sur quelque chose.

Pour une variable locale, il est important de faire le delete[] avant de "perdre" le dernier pointeur vers l'objet. Ne pas le faire est ce qu'on appelle une "fuite de mémoire".