Discussion :

[Nihi777]

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 :

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

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 :

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

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.

[3DArchi]

Salut,

Code :

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

*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 :

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

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 :

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

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;
}

[Nihi777]

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 !

[Médinoc]

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

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