Libération de mémoire

Bonjour,

J'ai un pb qui survient lors de la libération de mémoire
allouée pour les objets d'une classe, mais je n'arrive absolument pas à
savoir pourquoi, (lorsque je quitte l'appli un message d'erreur
de Windows s'affiche).

Le code étant extrêmement long et compliqué je vais simplifier.
La classe en question alloue un tableau d'objets lors de sa
création:

Code:

---

1 2 3 4 5 6

MaClasse(int taille) { pObj = new Obj[taille]; ... }

---

et libère la mémoire allouée lors de sa destruction:

Code:

---

1 2	~MaClasse(){delete[] pObj;}

---

Quelque part dans une autre classe 2 objets MaClasse sont créés:

Code:

---

1 2 3

MaClasse *p1 = new Maclasse(50); MaClasse *p2 = new Maclasse(50);

---

et sont détruits dans le destructeur de cette même autre classe:

Code:

---

1 2 3

delete p1; delete p2;

---

Le pb apparement vient qu'il y a 2 instanciations/libérations.
Si je n'instancie qu'un seul objet je n'ai pas d'erreur
lors de la désallocation.

Est ce que quelqu'un aurait eu ce genre de pb ou aurait
une idée ?


D'avance merci.

Ta classe gère la durée de vie d'une ressource, tu as donc d'autres critères à vérifier:

• soit elle doit être explicitement non-copiable et non-assignable (constructeur de copie et opérateur d'affectation déclarés privés et non-définis),
• soit elle est copiable, et doit donc avoir un constructeur de copie (et un opérateur d'affectation aussi, si elle est assignable) clairement défini. Si elle possède aussi un opérateur d'affectation, je conseille l'idiome copy-and-swap.

De plus, pour être parfaitement exception-safe, ta classe ne doit gérer "elle-même" la durée de vie que d'une seule ressource. (en gros, un seul new dans le corps du constructeur, un seul delete dans le corps du destructeur).

Le code que tu montres n'as pas de raison à priori de ne pas fonctionner. Donc, je pense comme Medinoc: quelque part tu dois avoir une copie de ta variable et ceci n'est pas gérer correctement.

Oui je crois qu'en effet la classe (celle qui alloue un tableau) n'est pas en cause.
J'ai déjà effectué un 1er traçage mais je n'ai rien remarqué de suspect.
C'est vrai que le code est long et complexe, je pense qu'il faut donc que je surveille le code pas à pas mais bon, pas évident...:aie:

Si quelqu'un à une idée/intuition qu'il n'hésite pas.

Ben l'idée, c'est ce qu'à dit Médinoc au début: l'opérateur = et le constructeur par copie sont-ils gérés? Probablement non, et l'erreur est ici.

L'opérateur = et le constructeur par copie ne sont effectivement pas
gérés, mais le truc c'est qu'ils ne sont pas utilisés dans mon code (enfin je crois).
Tout se déroule (en gros) comme dans l'exemple que j'ai donné plus haut, aussi je ne pense pas que l'opérateur = et le constructeur par copie interviennent dans ce genre de code (mais je peux me tromper :oops:)

Pour être absolument sûr qu'ils ne sont pas utilisés, rends ta classe non-copiable et non-assignable, en les déclarant private sans les définir.

Citation:

---

Envoyé par tintin72

enfin je crois

---

Probablement à un endroit dont tu ne te doutes même pas. Comme dit Médinoc, pour en être sûr déclare les en private et compile. Tu le verras tout de suite.

Salut
~MaClasse(){delete[] pObj;}
Je pense qu'il faudrait ajouter une fonction membre qui supprime l'objet créer par un pointeur.

Code:

---

1 2 3 4 5 6

void CMaClasse::Clear() { if(pObj != NULL) // tester si le pointeur n'est pas NULL delete[] pObj; }

---

On detruit l'objet pObj
Ensuite on detruit l'instance de CMaClass
Cordialement

Citation:

---

Envoyé par buggen25

Salut
~MaClasse(){delete[] pObj;}
Je pense qu'il faudrait ajouter une fonction membre qui supprime l'objet créer par un pointeur.

Code:

---

1 2 3 4 5 6

void CMaClasse::Clear() { if(pObj != NULL) // tester si le pointeur n'est pas NULL delete[] pObj; }

---

On detruit l'objet pObj
Ensuite on detruit l'instance de CMaClass
Cordialement

---

1. Ça ne sert à rien ici, ça n'est pas le problème.
2. Inutile de tester NULL avant, delete[] NULL est garanti ne rien faire.
3. Par contre, tu oublies de mettre le pointeur à NULL, ce qui fait qu'il risque d'être deleté deux fois.

Ce n'est pas la peine de venir aider si c'est pour donner du code dangereux...

Citation:

---

Pour être absolument sûr qu'ils ne sont pas utilisés, rends ta classe non-copiable et non-assignable, en les déclarant private sans les définir.

---

Pourrais tu me dire comment faire pour les déclarer private sans les définir, (un petit exemple).
J'avoue que je nage un peu là. :oops:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class MaClasse { MaClasse(Maclasse const &); MaClasse& operator=(MaClasse const &); };   // Ou alors   class MaClasse : boost::noncopyable { };

---

Code:

---

1 2 3 4 5 6 7 8

class MaClasse { ... ... private: MaClasse(MaClasse const &); MaClasse & operator= (MaClasse const &); };

---

Et rien d'autre.
Ils sont déclarés, privés, mais définis nulle part. Donc, si quelque chose tente de les utiliser, il y aura une erreur de compilation ou d'édition de liens (selon qu'on tente de l'utiliser depuis la classe elle-même ou depuis l'extérieur).

Edit : Grillé, grillé et regrillé :aie:

Code:

---

1 2 3 4 5 6 7 8

class A { private: A(const A&); A& operator=(const A&); };

---

Edit2 :

Pourquoi avez-vous écrit tous les deux : MaClasse(MaClasse const &) ? 8O
Y a t-il une différence avec l'usuel: MaClasse(const MaClasse&) ?

Merci pour vos réponses rapides ;)
Malheureusement ça compile sans pb :?
Aucun warning, rien. J'ai bien peur d'avoir affaire
à une erreur plutot vicieuse.
Bon j'y retourne.

Citation:

---

Envoyé par Arzar

Pourquoi avez-vous écrit tous les deux : MaClasse(MaClasse const &) ? 8O
Y a t-il une différence avec l'usuel: MaClasse(const MaClasse&) ?

---

Aucune différence, mais pour le compilo, c'est le X const & qui est l'usuel : Le const X & est un cas particulier autorisé pour le type le plus à gauche, mais en temps normal, le const est à droite du type :
X const * const * pcpcX;

Citation:

---

Envoyé par tintin72

Malheureusement ça compile sans pb :?
Aucun warning, rien.

---

Ca n'empêche pas de gérer correctement ton pointeur ;) !

Citation:

---

Envoyé par tintin72

J'ai bien peur d'avoir affaire
à une erreur plutot vicieuse.

---

Alors c'est peut dû au fait que tes objets sont détruits 2 fois pour une autre raison : tu fais explicitement 2 fois un delete sur la même adresse. La seconde hypothèse, c'est le charcutage mémoire! Enfin, à ce stade, il faut un peu plus de code pour t'apporter de l'aide.
Bon courage.

Citation:

---

La seconde hypothèse, c'est le charcutage mémoire!

---

Qu'est ce que le "charcutage mémoire" exactement ?

Citation:

---

Envoyé par Arzar

Pourquoi avez-vous écrit tous les deux : MaClasse(MaClasse const &) ? 8O
Y a t-il une différence avec l'usuel: MaClasse(const MaClasse&) ?

---

Parce que pour nous, c'est ça l'écriture usuelle ?
Il n'y a pas de différence en l'occurrence. La règle est que const s'applique à ce qui est placé avant lui, sauf s'il apparait en début, auquel cas il s'applique à ce qui est place derrière. Cette règle est surtout utile dans des écritures genre int const * (pointeur sur entier constant ou pointeur constant sur entier ?).

Écrire int const i = 42; au lieu de const int i = 42; permet de se placer dans le cas général, et non dans un cas particulier. C'est une question d'habitude.

Citation:

---

Envoyé par tintin72

Qu'est ce que le "charcutage mémoire" exactement ?

---

Tu as alloué les octets 5 à 10 et tu écris sur l'octet 11 ou 4. Bref, là où tu n'as pas le droit.