Delete invalid pointer

Bonjour,

j'ai un problème lorsque je veux
libérer la mémoire allouée dans une classe.

J'ai un vecteur de vecteur d'une classe Test

que j'initialise dans le constructeur comme ceci:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

matrice.resize(6);     vector<vector<Test> >::iterator i; vector<Test>::iterator j;   for (i = matrice.begin(); i != matrice.end(); ++i) { i->resize(7);   for (j = i->begin(); j != i->end(); ++j) {   Slot& s = *(new Test()); *j = s;   } }

---

Lorsque j'essaye de libérer la mémoire dans le destructeur avec

Code:

---

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

for (i = matrice.begin(); i != matrice.end(); ++i) {   for (j = i->begin(); j != i->end(); ++j) {   Test &s = *j;   delete &s;   } }

---

Le compilateur me dit que le pointeur est invalide je suis un débutant
en c++ et je ne trouve pas une solution à mon problème.

Salut,

Code:

---

*j = s;

---

réalise une copie complète de l'objet. Par défaut, en C++, tu manipules des valeurs et non leur référence contrairement à d'autres langages (type java ou C#). Donc au moment du delete, ce n'est pas du tout le bon pointeur que tu supprimes. Le pointeur alloué, en fait, tu l'as perdu.

La solution :
1/Supprimer les allocations dynamiques (surtout si ta classe n'a pas de sémantique d'entité)

2/ Utiliser des pointeurs intelligents si tu as vraiment besoin.

Ne jamais oublier que la STL (et ses algos) est ton amie ;)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include <vector> #include <algorithm> #include <boost/shared_ptr.hpp>   struct Slot{}; struct Test : public Slot{};   template<class T> boost::shared_ptr<T> factory() { return boost::shared_ptr<T>(new T); }   void add_line(std::vector<boost::shared_ptr<Slot> > &v_) { v_.resize(7); std::generate(v_.begin(),v_.end(),factory<Test>); }   int main() { std::vector<std::vector<boost::shared_ptr<Slot> > > matrice;   matrice.resize(6); std::for_each(matrice.begin(),matrice.end(),add_line);   return 0; }

---

un peu plus agréable à lire avec les lambda de C++0x :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

#include <vector> #include <algorithm> #include <memory>   struct Slot{}; struct Test : public Slot{};   typedef std::shared_ptr<Slot> ptrSlot; typedef std::vector<ptrSlot> vector_ptrSlot; typedef std::vector<vector_ptrSlot> matrice_ptrSlot;   int main() { matrice_ptrSlot matrice;   matrice.resize(6); std::for_each( matrice.begin() ,matrice.end() , [](vector_ptrSlot &v_) { v_.resize(7); std::generate(v_.begin(),v_.end(), [](){return std::shared_ptr<Test>(new Test);} ); } );   return 0; }

---

Ca me pique un peu les yeux quand même.

Je vais vraiment essayer d'éviter les allocations dynamique pour les prochaines fois. Merci beaucoup !

Citation:

---

Slot& s = *(new Test());

---

:vomi:

Ça, c'est un truc à ne jamais faire: Tu emmêles les pointeurs et les références. delete &s est tout aussi sale.