Discussion :

[Mattgic]

Bonjour à tous,

Petite question.. quand on appelle la fonction erase() sur un vecteur "d'objet-pointeur" (vector<T *> ), la mémoire ne semble pas bougée avant et après l'appelle. Cela est il normal ? Comment faire pour vraiment libérer la mémoire ?

Méthode employée :

Code :

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

1
2
3
4
5
 
std::vector<ObjectT*>::iterator it = list.begin();
if(it!=NULL && (*it)!=NULL)
free (*it); // delete (*it); ne marche pas plus
list.erase(list.begin());

Merci de votre aide

[Arzar]

C'est normal.

La plupart du temps, quand on utilise des std::vector<Objet*> c'est justement car on ne veut pas que le vecteur détruise l'objet pour nous.

On peut par exemple avoir un std::vector<Objet*> avec un ensemble de pointeur sur des objets vérifiant un certain critère, et une std::list<Objet*> avec un ensemble de pointeur sur des objets vérifiant un autre critère et puis peut être une std::map<int, Objet*> pour indexer tout nos objets, etc, etc.

Pour détruire réellement l'objet pointé, et bien on lit l'excellente faq de developpez sur le sujet (en gros, faire un delete sur l'objet avant l'erase)

Edit : Désolé, j'ai répondu trop vite

Code :

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

free (*it); // delete (*it); ne marche pas plus

Si, si delete (*it) détruit bien l'objet pointé.

[JolyLoic]

2 choses :
- Libérer la mémoire pour l'objet pointé (a priori, delete)
- Libérer la mémoire pour le vecteur lui même. A priori, pour des raisons d'optimisations, il ne le fait pas de lui même. Si vraiment tu est dans un cas où la capacity du vector est largement supérieure à sa size, tu peux utiliser le swap trick :

Code :

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

vector<ObjectT*>(list).swap(list);

[Mattgic]

Alors en regard de vos réponses j'ai fait 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
 
struct Delete 
{ 
   template <class T> void operator ()(T*& p) const 
   { 
      delete p;
      p = NULL;
   } 
};
...
std::for_each(list.begin(), list.begin(), Delete());  
/*Oui begin,begin car je n'ai que le premier à supprimer
la méthode pop_back ne marche pas non plus pour libérer 
de la mémoire */
 
list.erase(list.begin());

le resultat est toujours le même.. la mémoire n'est pas libérée. ...
ensuite je n'ai pas trop compris comment utiliser le swap trick...

merci de vos réponses

[JolyLoic]

Ajoute simplement la ligne que je t'ai indiquée juste après ton erase.

Cette ligne va créer un nouveau vector du même type, copié depuis ton vector (vector<ObjectT*>(list)) mais qui sera avec une capacity() régénérée depuis 0 (et donc dimentionnée au plus juste), puis on échange ce nouveau vector avec l'ancien (.swap(list)).

[Mattgic]

Re décidement je dois émettre des mauvaises ondes lol:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
printf("<BEFORE>: %f\n",(float) memoryStatus.dwAvailPageFile / 1024 / 1024); 
// taille en Mo
 
std::for_each(list.begin(), list.begin(), Delete()); 
list.erase(list.begin());
std::vector<ObjectT*> (list).swap(list);
 
printf("<AFTER>: %f\n",(float) memoryStatus.dwAvailPageFile / 1024 / 1024); 
// taille en Mo

en sortie : BEFORE : 2062.914063; AFTER : 2062.914063

[3DArchi]

Code :

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

std::for_each(list.begin(), list.begin(), Delete());

Aucune libération n'est exécutée car cela revient à un range vide :

Code :

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

1
2
3
std::for_each(list.begin(), list.end(), Delete()); 
// uniquement pour le premier élément :
std::for_each(list.begin(), list.begin()+1, Delete());

Cela libère au minimum tes objets.
En revanche, comme l'ont expliqué Arzar et JolyLoic, le tableau du vecteur peut très bien ne pas diminuer en taille. Si tu veux aussi diminuer ce tableau, alors tu dois utiliser le code proposer par Loïc.

[EDIT] Pour compléter la réponse, std::for_each(début, fin) (et en fait tous les algos avec des itérateurs) est exécuté pour l'intervalle [début,fin[ et non [début, fin]. L'élément à la position fin n'est pas pris en compte. Donc un intervalle [début,début[ est vide.