[VC++6] Vector Erase - Free Memory ?

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:

---

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

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 :D (en gros, faire un delete sur l'objet avant l'erase)

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

Code:

---

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

---

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

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:

---

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

---

Alors en regard de vos réponses j'ai fait ceci:

Code:

---

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...:oops:

merci de vos réponses:ccool:

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)).

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

Code:

---

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

Code:

---

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

---

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

Code:

---

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.

Hello j'ai apporté la modification (mettre +1) cependant toujours rien en mettant bien la solution de loic...:roll:
... c'est grave docteur .....

Ton poste n'aurait pas 2Go de RAM ?
[EDIT]
Ta sortie (pas très C++ au passage) :

Code:

---

printf("%f\n",(float) memoryStatus.dwAvailPageFile / 1024 / 1024);

---

affiche 2062.914063*1024*1024 = 2Go. D'où, memoryStatus.dwAvailPageFile n'est peut être pas ton bon indicateur...

J'ai effectivement modifier mon printf (habitude du c, je le reconnais!). Mon poste a 1.75Go de Ram..
sinon que me conseilles tu d'utiliser comme indicateur de mémoire alors?

Et en mettant à jour memoryStatus.dwAvailPageFile ça donne quoi ?

Code:

---

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); GlobalMemoryStatus(&memoryStatus); printf("<AFTER>: %f\n",(float) memoryStatus.dwAvailPageFile / 1024 / 1024); // taille en Mo

---

:oops:promis je le fais pas expres... mais non ça ne bouge pas d'un poil ! :roll:

Tu peux essayer ce code ?

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> class Object { public: Object() { data.resize(100000000); } std::vector<char> data; };     int main(void) { system("PAUSE"); Object* o = new Object(); std::vector<Object*> vec; vec.push_back(o); system("PAUSE");   std::vector<Object*>::iterator it = vec.begin(); delete *it;   //delete vec.back(); // équivalent aux deux lignes précédentes.   system("PAUSE"); vec.pop_back();}

---

Normalement, avant la première pause, le programme consomme environ 1mo, à la deuxième, environ 100mo, à la troisième à nouveau 1 mo.
(C'est ce que je constate chez moi avec le gestionnaire des taches)

Oui je constate la même chose que toi avec ce code... tout n'est pas perdu alors:?...

Salut,
De ce que j'ai pu lire dans le oueb, déterminer la mémoire accaparée par un processus n'est pas chose aisée. Si j'ai bien compris la démarche, il s'agit de parcourir les pages associées au processus et vérifier leur état avec le risque qu'elles puissent être partagées. Il existe des outils permettant de traquer les allocations/libérations (et bien d'autres choses) mais en général sont payants sous Windows. Apparemment, Purify d'IBM est proposé en version d'essai. Je ne sais pas ce que vaut cette version mais si tu as le temps et le courage cela vaut peut être le coup d'essayer.

Je pense également que le problème vient de la mesure de ta mémoire utilisée.

ce programme:

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 32

#include <vector> #include <iostream> #include <cassert>   struct one_mb { long long _[131072]; };     int main() { std::vector< one_mb* > v;   for( unsigned int i = 0; i < 1000; ++i ) { one_mb* t = new one_mb; v.push_back( t ); }   std::vector< one_mb* >::iterator it = v.begin(); while( it != v.end() ) { delete( *it ); ++it; //it = v.erase( it ); }   assert( v.size() == 1000 );   return 0; }

---

passé sous Valgrind donne:

Citation:

---

==12761== Memcheck, a memory error detector.
==12761== Copyright (C) 2002-2008, and GNU GPL'd, by Julian Seward et al.
==12761== Using LibVEX rev 1884, a library for dynamic binary translation.
==12761== Copyright (C) 2004-2008, and GNU GPL'd, by OpenWorks LLP.
==12761== Using valgrind-3.4.1-Debian, a dynamic binary instrumentation framework.
==12761== Copyright (C) 2000-2008, and GNU GPL'd, by Julian Seward et al.
==12761== For more details, rerun with: -v
==12761==
==12761==
==12761== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 17 from 1)
==12761== malloc/free: in use at exit: 0 bytes in 0 blocks.
==12761== malloc/free: 1,011 allocs, 1,011 frees, 1,048,584,188 bytes allocated.
==12761== For counts of detected errors, rerun with: -v
==12761== All heap blocks were freed -- no leaks are possible.

---

Et comme résultat si on désire supprimer qu'un seul élément:

Code:

---

1 2 3

// insérer 1000 éléments dans le vecteur... delete( *v.begin() );

---

Citation:

---

==12811== malloc/free: in use at exit: 1,047,527,424 bytes in 999 blocks.

---

Sinon, je te conseilles de passer par les pointeurs intelligents, ou les conteneurs de pointeurs. Exemples:

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 32 33 34

#include <iostream> #include <vector> #include <boost/smart_ptr.hpp> #include <boost/ptr_container/ptr_vector.hpp>   using namespace std; using namespace boost;   struct one_mb { long long _[131072]; };   int main() { typedef shared_ptr< one_mb > one_mb_p; vector< one_mb_p > v; for( unsigned int i = 0; i < 1000; ++i ) { one_mb_p t( new one_mb ); v.push_back( t ); }   // ou avec les conteneurs de pointeurs   ptr_vector< one_mb > v_; for( unsigned int i = 0; i < 1000; ++i ) { v_.push_back( new one_mb ); }   return 0; }

---

qui donne comme valgrind:

Citation:

---

==13121== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 17 from 1)
==13121== malloc/free: in use at exit: 0 bytes in 0 blocks.
==13121== malloc/free: 3,022 allocs, 3,022 frees, 2,097,192,564 bytes allocated.
==13121== For counts of detected errors, rerun with: -v
==13121== All heap blocks were freed -- no leaks are possible.

---

Donc, bien ce à quoi on doit s'attendre.

Je te conseille cependant la 2è méthode (ptr_container) plutôt que la 1ère, pour quelques raisons.