Discussion :

[MProg]

Bonjour,

Je voudrais savoir lorsque je fait un erase ou un remove dans un conteneur de type list (STL) si l'élément est juste effacé du conteneur et existe encore en dehors du conteneur, ou s'il est vraiment effacé pour de bon mémore vidée etc...

J'ai trouvé ça dans la FAQ :

Dois-je effacer ce que j'ai stocké dans un vecteur ? [haut]

auteur : LFE
La réponse dépend de la nature de ce qui est stocké dans un vecteur.
S'il s'agit d'un objet, il n'est pas utile de le détruire, il le sera lorsqu'il est retiré du vecteur, ou lorsque le vecteur est détruit.
Par contre, s'il s'agit d'un pointeur sur un objet, il faut le détruire car un pointeur n'est pas un objet. Si cette destruction n'est pas faite, le programme présentera une fuite de mémoire.

Dans mon cas je pense qu' "il s'agit d'un pointeur sur un objet" mais alors je ne sait pas comment effacer "proprement" un élément.

Voici mon code :

Une liste d'objet->

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
 
 
using namespace std;
#include <list>
 
class Triangle
{
 
    public :
 
    Vecteur *v[3];
    Triangle();
};
 
typedef list<Triangle*>           l_Triangle;

Et un itérateur pour les parcourrir :

Code :

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

1
2
3
4
5
6
7
8
 
 
    l_Triangle::iterator i_Tri = Liste->begin();
    while (i_Tri != Liste->end())
    {  
 
    i_Tri++;
    }

bon le truc c'est que si je fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
    l_Triangle::iterator i_Tri = Liste->begin();
    while (i_Tri != Liste->end())
    {  
 
    delete i_Tri;
    i_Tri = NULL;
 
    i_Tri++;
    }

Ca bugge et je sais pourquoi (je détruit mon itérateur donc le i_Tri++ plante
puisque je peux pas ajouter 1 à un itérateur qu n'existe plus)
Je sais pas comment faire pour supprimer un ou plusieur éléments de ma liste sans fuite de mémoire.

j'ai trouvé ca dans la FAQ mais je sais pas m'en servir:

Exemple] Comment détruire les pointeurs d'un conteneur ? [haut]

auteur : Laurent Gomila

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
 
#include <list> 
#include <algorithm>
 
// Foncteur servant à libérer un pointeur - applicable à n'importe quel type
struct Delete 
{ 
   template <class T> void operator ()(T*& p) const 
   { 
      delete p;
      p = NULL;
   } 
}; 
 
int main() 
{ 
   // Création d'une liste de pointeurs 
   std::list<int*> l; 
   l.push_back(new int(5)); 
   l.push_back(new int(0)); 
   l.push_back(new int(1)); 
   l.push_back(new int(6)); 
 
   // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste ! 
   std::for_each(l.begin(), l.end(), Delete()); 
 
   return 0;

Merci
MProg

Merci d'essayer de ne pas confondre QUOTE et CODE koala01

[Laurent Gomila]

Code :

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

1
2
delete i_Tri;
i_Tri = NULL;

i_Tri est un itérateur, ce n'est pas lui qu'il faut détruire et mettre à NULL, mais l'élément qu'il désigne. D'ailleurs ça m'étonne que ce code compile.

Code :

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

1
2
delete *i_Tri;
*i_Tri = NULL;

En plus ce code ne sera pas suffisant si tu veux retirer l'élément du conteneur, là tu n'as fait que détruire l'objet et désallouer la mémoire, mais le pointeur est toujours dans la liste.

Jette un oeil à ceci :
http://cpp.developpez.com/faq/cpp/?p...ssion_elements

[MProg]

Ok, merci donc si je fait un remove ou erase et aprés :

Code :

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

1
2
3
4
 
 
delete *i_Tri;
*i_Tri = NULL;

Mon code sera propre ?

Merci
MProg

[poukill]

Juste pour info, il existe dans Boost un conteneur exprès pour les pointeurs : http://www.boost.org/libs/ptr_contai...container.html
(c'est un conteneur intelligent)

[poukill]

Ok, merci donc si je fait un remove ou erase et aprés :

Code :

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

1
2
3
4
 
 
delete *i_Tri;
*i_Tri = NULL;

Mon code sera propre ?

Merci
MProg

Surtout pas!
Il faut d'abord supprimer l'élément par un

Code :

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

delete *i_Tri;

Puis il faut retirer ce pointeur de la list:

Code :

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

list.erase(i_Tri);

[MProg]

Ok, donc si je fait :

Code :

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

1
2
3
4
5
 
l_Vecteur::iterator i_Vect = svList->begin();
delete *i_Vect; 
svList->remove(*i_Vect);
*i_Vect=NULL;

C'est une bonne façon pour effacer un élément de ma liste
Mais mon objectif est d'en effacer plusieurs.

Le problème c'est que cela ne fonctionne pas car je ne peux pas faire +1
sur un truc que je viens d'effacer ... comment je peux faire ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
    l_Vecteur::iterator i_Vect = svList->begin();
    while (i_Vect != svList->end())
    {  
 
     delete *i_Vect; 
     svList->remove(*i_Vect);
     *i_Vect=NULL;
 
     i_Vect++;
    }

Merci
MProg

[Alp]

Et si tu détruisais tout ce vers quoi pointent les itérateurs pour commencer, auquel cas tu peux continuer à parcourir ta liste, et ensuite faire un std::remove ?

[poukill]

C'est une bonne façon pour effacer un élément de ma liste
Mais mon objectif est d'en effacer plusieurs.

Quand tu dis plusieurs, c'est tous, ou bien quelques uns?

[poukill]

Et si tu détruisais tout ce vers quoi pointent les itérateurs pour commencer, auquel cas tu peux continuer à parcourir ta liste, et ensuite faire un std::remove ?

Oui aussi.
Personnellement la dernière fois que j'avais eu ce problème, j'avais créer un vecteur d'itérateur pour l'occasion ! Puis je boucle sur le vecteur pour finalement supprimer les éléments.

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
std::vector<map::iterator> vect;
map::iterator iter;
for (iter = map.begin(); iter != map.end(); iter++)
{
    if (*iter == 5) {// Condition
         vect.push_back(iter);
         delete *iter; // On delete le pointeur
    }
}
 
// On supprime tous les éléments à partie des itérateurs du vecteur
std::vector<map::iterator>::iterator iter_vect;
for (iter_vect = vect.begin(); iter != vect.end(); iter_vect++)
{
    map.erase(*iter_vect);
}

Je sais pas si c'est la bonne façon de faire, mais ça marche plutôt bien....

[MProg]

Ah oui c'est malin comme idée de séparer les deux taches

Mais juste une question que devient le : *i_Vect=NULL; ?

Parce que à la base mon objectif était de ne pas avoir de fuite de mémoire
quand je supprime.

Si je ne met pas mon pointeur à null j'ai pas de perte de mémoire ?

Merci
MProg

[Laurent Gomila]

Ah oui c'est malin comme idée de séparer les deux taches

Sauf qu'ici ça ne sert à rien, tu peux très bien supprimer les éléments directement.

Mais juste une question que devient le : *i_Vect=NULL; ?

Parce que à la base mon objectif était de ne pas avoir de fuite de mémoire
quand je supprime

Mettre 0 dans une case mémoire ne va pas aider à éviter les fuites
C'est delete qui libère la mémoire, après ça ne sert à rien de réinitialiser ton pointeur puisque de toute façon tu vas le supprimer du conteneur.

[poukill]

Sauf qu'ici ça ne sert à rien, tu peux très bien supprimer les éléments directement.

Oui, mais c'est peut-être plus rapide non? Car l'appel à List::remove prend plus de temps que la suppression d'un élément par l'itérateur?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
map::iterator iter;
for (iter = map.begin(); iter != map.end(); iter++)
{
    if (*iter == 5) {// Condition
         delete *iter; // On delete le pointeur
         //map.erase(iter); Impossible. Itérateur non valide par la suite
         map.remove(*iter); // OK mais plus long
    }
}

EDIT : Dans le sujet il s'agissait d'une liste, donc... -> voir la suite des posts

[Laurent Gomila]

Il suffit d'incrémenter l'itérateur avant la suppression pour éviter qu'il soit invalide.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
map::iterator iter;
for (iter = map.begin(); iter != map.end(); )
{
    if (iter->second == 5)
    {
         delete *iter;
         map.erase(iter++);
    }
    else
    {
        ++iter;
    }
}

[poukill]

Dans mon code j'avais écrit map en pensant list, car MProg parlait de liste, et non pas de map.

Je pense que ça t'a induit en erreur Laurent...

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
 
std::list<Triangle*> liste_tri;
std::list<Triangle*>::iterator iter;
for (iter = liste_tri.begin(); iter != liste_tri.end(); )
{
    if (*iter == .....) // Condition
    {
         delete *iter; // On détruit l'élément pointé
         liste_tri.erase(iter++); // OK 
    }
    else
    {
          ++iter;
    }
}

Donc code corrigé pour une liste de pointeurs !

[yan]

Dans mon code j'avais écrit map en pensant list, car MProg parlait de liste, et non pas de map.

Je pense que ça t'a induit en erreur Laurent...

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
std::list<Triangle*> liste_tri;
std::list<Triangle*>::iterator iter;
for (iter = liste_tri.begin(); iter != liste_tri.end(); )
{
    if (*iter == .....) // Condition
    {
         delete *iter; // On détruit l'élément pointé
         liste_tri.erase(iter++); // OK 
    }
    else
    {
          ++iter;
    }
}

Donc code corrigé pour une liste de pointeurs !

faudrait pas plutôt :

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
std::list<Triangle*> liste_tri;
std::list<Triangle*>::iterator iter;
for (iter = liste_tri.begin(); iter != liste_tri.end(); )
{
    if (*iter == .....) // Condition
    {
         delete *iter; // On détruit l'élément pointé
        iter= liste_tri.erase(iter);  
    }
    else
    {
          ++iter;
    }
}

même pour une map?

[Laurent Gomila]

Pour une liste oui, mais pour une map erase ne renvoie rien (faudra qu'on m'explique pourquoi d'ailleurs).

[yan]

Pour une liste oui, mais pour une map erase ne renvoie rien (faudra qu'on m'explique pourquoi d'ailleurs).

Ah oui tien, sous visual il le fait
http://msdn2.microsoft.com/en-us/lib...7h(VS.80).aspx
mais pas dans la norme SGI
http://www.sgi.com/tech/stl/Map.html

Par contre j'ai un sérieux doute sur liste_tri.erase(iter++); . j'ai fait ce test sous visual 2005

Code C++ :

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
35
36
37
#include <iostream>
#include <list>
#include <vector>
 
class COperateur
{
public:
	COperateur(int a ):number(a){}
	int number;
};
 
int main()
{	
	std::vector<COperateur*> m_listOp;
	m_listOp.push_back(new COperateur(0));
	m_listOp.push_back(new COperateur(1));
	m_listOp.push_back(new COperateur(2));
	m_listOp.push_back(new COperateur(3));
	m_listOp.push_back(new COperateur(4));
	m_listOp.push_back(new COperateur(5));
	m_listOp.push_back(new COperateur(6));
	m_listOp.push_back(new COperateur(7));
	m_listOp.push_back(new COperateur(8));
 
	std::vector<COperateur*>::iterator iter = m_listOp.begin();
	iter++;iter++;iter++;iter++;iter++;
	std::cout<<(*iter)->number<<std::endl;
 
	while(iter!=m_listOp.end())
		{
		std::cout<<(*iter)->number<<std::endl;
		delete *iter;
		m_listOp.erase(iter++);
		}
 
	return 0;
}

m_listOp.erase(iter++); me génère une erreur d'execution. iter = m_listOp.erase(iter); résoud le problème.

[Laurent Gomila]

C'est normal, le retrait dans un std::vector invalide les autres itérateurs. Par contre sur std::list ça fonctionnerait.

De toute façon, liste_tri.erase(iter++) n'est qu'une manière allegée d'écrire ceci :

Code :

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

1
2
3
4
std::list<x>::iterator suivant = iter;
++suivant;
l.erase(iter);
iter = suivant;

Ce qui n'a aucune chance d'être incorrect si les itérateurs ne sont pas invalidés par la suppression.

[koala01]

Salut,

C'est normal, le retrait dans un std::vector invalide les autres itérateurs. Par contre sur std::list ça fonctionnerait.

De toute façon, liste_tri.erase(iter++) n'est qu'une manière allegée d'écrire ceci :

Code :

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

1
2
3
4
std::list<x>::iterator suivant = iter;
++suivant;
l.erase(iter);
iter = suivant;

Ce qui n'a aucune chance d'être incorrect si les itérateurs ne sont pas invalidés par la suppression.

Sauf que, sauf erreur de ma part, les itérateur sont souvent de simples pointeurs sur éléments, et que, sauf erreur aussi, la suppression d'un élément ne fait pas prendre par l'élément qui le suit l'adresse de l'élément supprimé...

De plus, lors de la suppression, d'accord, envisageons simplement qu'il y ai un système qui permette de ne pas invalider l'itérateur...

Il fait quoi dans ce cas
Prendre l'élément précédent et si c'est le premier élément de la liste

Prendre l'élément suivant et si c'est le dernier de la liste

"Et si, juste avant de supprimer un élément, on a du modifier celui qui sera pris comme base pour récupérer l'itérateur, le fait de le re-tester ne risque-t-il pas de le faire supprimer indument "

A moins que la norme ne disque quelque chose sur le sujet

[yan]

[QUOTE=Laurent Gomila;2442505]C'est normal, le retrait dans un std::vector invalide les autres itérateurs. Par contre sur std::list ça fonctionnerait.[\QUOTE]

Ben c'est cela qui me chagrine dans cette méthode, cela dépend fortement du conteneur... alors que iter = m_listOp.erase(iter) est bien mieux... non?
Pour le conteneur associative, je ne sais pas puisse que la fonction n'est pas identique entre la STL de visual et la STL de SGI...