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.

[Mattgic]

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

[3DArchi]

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

Code :

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

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

[Mattgic]

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?

[Sylvain Togni]

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

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

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

[Mattgic]

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

[Arzar]

Tu peux essayer ce code ?

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

[Mattgic]

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

[3DArchi]

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.

[JulienDuSud]

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

ce programme:

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

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

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

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

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

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

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