[destructeur] [pas appelé]

Je construit plusieurs objet et par après je fais appel à delete pour les détruire et récupérer la mémoire.

Pour vérifier que le destructeur est bien appelé, j'y ai mis une fonction qui écrit dans un fichier (elle fonctionne bien cette fonction). Seulement pas un seul ptit message dans le fichier de réception... (il n'y a aucun problème avec la fonction d'écriture, je rappel)

Donc je me dis, "ben, tiens, mes destructeurs sont pas appelés. Pas normal ca..."

Alors voilà, est-ce que je peux mettre du code (par exemple ma fonction d'écriture) dans un destructeur ?
Et est-ce normal que j'ai rien dans mon fichier de réception ?

Ta conclusion est bien hative. Un break point serait plus fiable comme test, ou simplement un affichage sur cout.
Normalement tes detructeurs sont toujours appelés. Les exceptions que je connais sont:
- si le constructeur a échoué (exception)
- destruction polymorphique sans destructeur de base virtuel (comportement indéfini) -> voir FAQ
- bug de certains compilos, avec les objets statiques en particulier (tu peux éliminer cette piste)

Mais là je dirai que c'est ton test qui est suspect.

Il y a de l'héritage, dans tes classes?
Une sombre histoire de destructeur virtuel?

Je viens de faire le barbare en faisant l'appel à exit(0), rien. J'ai utilisé un breakPoint, rien...

ma classe ne dérive de rien. C'est juste un simple Node dans une liste.

Mais ma méthode d'écriture de fichier est sans problème. Je l'emplois tout le temps et elle ne se plante jamais. (d'ailleurs en général je l'employais pour m'aider à débugger)

Tu devrais poster ton code :wink:

voilà en gros ma classe Node

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

Node::Node(Data * d) { data = d; previous = false; next = false; }     Node::~Node() { delete( }

---

et voici mon code, de la construction à la destruction.

Code:

---

1 2 3 4 5 6 7 8

Node * n = liste->getFirst(); to->printFile("bon", "y"); while(n!=false) { ..... n = n->getNext(); } delete n;

---

le code se lit bien jusqu'au bout. Delete est lu pourtant.

Pourriez vous me dire comment utiliser try catch avec mon destructeur ?

si tu veux tester tes objets en mémoire dynamique, une méthode qui marche bien c'est surcharger tes operateur new et delete ... (comme tu parles de delete ...

Comme ceci par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

// Surcharge de new et delete void* operator new (size_t size) { void* p = malloc(size); cout << " Objet de MaClasse alloué à l'adresse " << p << " pour " << size << " octets " << endl; return p; }   void operator delete (void* p,size_t size) { cout << " Adresse suivante (MaClasse) libérée : " << p << " de " << size << " octets " << endl; free(p); }

---

Au moins tu verras bien si tout se libère :)

Je rajoute une question :


je crée un pointeur : Node * n
J'effectue une copie de pointeur : n = nAutre
je détruit n : delete n

que devient nAutre ?

Je veux juste que le pointeur n soit libéré mais l'objet en lui meme ne doit pas etre détruit car toujours référé par nAutre.

Je suppose que delete n, ca détruit tout meme l'objet laissant nAutre tout seul pointant sur rien.

Un pointeur ça ne se libère pas, ça prend juste une adresse.
Si tu veux que ton poineur ne pointe plus sur un objet, tu peux lui donner la valeur NULL.

Si tu veux détruire l'objet pointé par un pointeur, tu utilise l'opérateur delete.


Et pour revenir sur ton code :

Code:

---

1 2 3 4 5 6 7 8

Node * n = liste->getFirst(); to->printFile("bon", "y"); while(n!=false) { ..... n = n->getNext(); } delete n;

---

Tu fais une comparaison entre un pointeur et un booléen (n!=false) ... ce n'est vraiment pas propre.
De plus, lorsque tu sors de la boucle, le pointeur vaut NULL, et tu effectue donc "delete NULL;", ce qui ne fait rien ...

C'est vrai que j'ai tendance à utiliser les booleans. Mais bon, je comprend pas pourquoi il vaudrait NULL, d'accord si on le déclare à l'intérieur, mais là, n est déclaré avant la boucle et les éléments dans liste->getFirst() aussi.

c'est un peu comme si je faisais ca :

Code:

---

1 2 3 4 5 6

int i = 0;   { i = 1; }

---

en dehors de la boucle, i vaudra quand meme 1. A moins qu'il y a une notion que j'ai pas capté pour les objets.

Mais cela répondrait bien à mon problème. Ce qui me laisse croire que mon argument ci dessus est mauvais.[/code]

je viens de comprendre désolé !!! il devient NULL effectivement car justement je fais un test comparatif dans la boucle... normal alors que delete NULL ne donne rien.