[C++/STL] Fonction générique pour supprimer les éléments d'une std::map

Bonjour à tous,

Après les vectors, j'ai découvert les "map" qui sont bien utiles pour utiliser des collections de type cle/valeur.
Cependant, je souhaite supprimer tous les éléments de mes maps à l'aide d'une fonction générique et du for_each() :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct DeleteBitmap { void operator()(std::map<int, BITMAP*>* p) const // on peut modifier le paramètre mais pas le foncteur { libererBitmap(p->second); // fonction qui libère un BITMAP* p = NULL; } };   // son appel serait : for_each(mapTotale.begin(), mapTotale.end(), DeleteBitmap());

---

Problème ca ne compile pas sur la ligne "p->second" car second n'est pas un membre de p (logique)...

Actuellement, j'utilise une boucle mais je préfèrerais le template :

Code:

---

1 2 3 4 5 6 7

map<int, BITMAP*>::iterator pos; for (pos = mapTotale.begin(); pos != mapTotale.end(); ++pos) { libererBitmap(pos->second); pos->second = NULL; }

---

Et cela marche avec la boucle...

Voilà si vous pouviez me débloquer ;)

Merci beaucoup ! et bonnes fêtes de fin d'année :ccool:

for_each passe un un itérateur (qui déréférencé donne un std::pair), pas une map au foncteur hein.. :

Code:

---

1 2 3 4 5 6 7 8 9 10

struct print_second { template <typename T> void operator()(const T& t) const { std::cout << t.second << std::endl; } };

---

Salut,
Quelques remarques :
-> Pour compléter la remarque de Goten, le foncteur ne prend pas le conteneur ni l'itérateur mais le résultat du déréfencement de l'itérateur. Pour un conteneur associatif, c'est effectivement un pair clé/valeur

-> Dans ton exemple, tu passes l'argument par pointeur :

Code:

---

1 2 3 4

struct DeleteBitmap { void operator()(std::map<int, BITMAP*>* p) const // on peut modifier le paramètre mais pas le foncteur {

---

Ca n'a pas de sens (sauf à ce que le déréfencement de l'itérateur soit un pointeur). On passe par référence ou par valeur :

Code:

---

1 2 3 4

struct DeleteBitmap { void operator()(std::pair<int, BITMAP*>& const p) const // on peut modifier le paramètre mais pas le foncteur {

---

-> En C++0x, les lambdas seraient bien utiles :

Code:

---

std::for_each(mon_map.begin(),mon_map.end(),[](std::pair<key_t,value_t> val){delete val.second;});

---

-> En revanche, tu vas te rendre rapidement compte qu'il ait quand même plus facile d'encapsuler ta ressource dans une enveloppe RAII (pointeur intelligent par expl). Il te suffit alors tout simplement de faire un clear :

Code:

---

mon_map.clear();

---

ou d'utiliser l'idiom suivant pour garantir la libération effective des ressources internes du conteneur :

Code:

---

std::map<key_t,value_t>().swap(mon_map);

---

Merci pour votre aide !

Une dernière question :

Est-il nécessaire de faire un NULL après une libération de mùémoire ? c'est vrai que j'aime bien mettre mon pointeru libéré à NULL mais je dois passer par une référence non constante pour le faire :

Code:

---

1 2 3 4 5 6

template <typename T> void operator()(T& t) const { libererBitmap(t.second); t.second = NULL; }

---

Ou alors :

Code:

---

1 2 3 4 5

template <typename T> void operator()(const T& t) const { libererBitmap(t.second); }

---

Je pense que c'est mieux d'utiliser des référence constante mais j'en suis pas sur, si vous pouviez m'éclairer ;)

Salut,

Si, juste après ton for_each, tu invoque la fonction clear de ta map, tu n'a pas besoin de mettre le pointeur à NULL, vu que, de toutes manières, l'ensemble des élément de la map seront effectivement détruit (et que tu ne pourras donc plus récupérer un itérateur sur l'un d'eux).

Il est, en effet, préférable de :

• passer une référence constante chaque fois que faire se peut
• séparer clairement les responsabilités, en veillant à ce que le foncteur se contente de libérer la mémoire allouée pour le pointeur sur bitmap et
• en veillant à ce que ce soit la fonction qui décide qu'un pointeur sur bitmap peut être libéré (comprend: qui utilise le foncteur) qui veille à supprimer l'élément de la map

En dehors du for_each, tu pourrais parfaitement avoir une fonction membre proche de

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

struct deleter { template<typename T> void operator(T * ptr) { delete ptr; } template<typename T> void operator(std::pair<type,T*> const & pair) { delete pair.second; } }; void TaClass::releaseRessource(type key) { std::map<type, Truc *>::iterator it=lamap.find(key); if(it!=lamap.end()) { deleter()(it); // OU OU OU deleter (it.second); lamap.erase(it); // OU OU OU lamap.erase(key); } }

---

Je déterre ce sujet car j'ai une question existentielle qui est quasiment la même, à la différence près que je n'ai pas des pointeurs. en fait dans mon cas c'est même un poil plus complexe mais le fond revient au même. Prenons le code suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

using namespace std; map< string, vector< MyClass > > the_map;   // ici du code qui rempli la map, par exemple vector<MyClass> v1 = { MyClass( 0 ), MyClass( 1 ) }; the_map.insert( make_pai( "v1", v1 ) ); vector<MyClass> v2 = { MyClass( 2 ), MyClass( 3 ) }; the_map.insert( make_pai( "v2", v2 ) );   // et maintenant je veux effacer un élément selon une key donnée, prenons "v1" par exemple: auto it = the_map.find( "v1"); if ( it != the_map.end() ) // là je met quoi?

---

Mon problème c'est qu'une map, en mémoire c'est un arbre en fait. Alors comment faire pour supprimer proprement un élément, surtout quand c'est un gros truc? Faut-il utiliser le erase-remove idiom ici? Faut-il faire une copie sélective de la map?

Citation:

---

Envoyé par r0d

Mon problème c'est qu'une map, en mémoire c'est un arbre en fait. Alors comment faire pour supprimer proprement un élément, surtout quand c'est un gros truc? Faut-il utiliser le erase-remove idiom ici? Faut-il faire une copie sélective de la map?

---

Comme tu l'as si bien fait remarquer, map gère ses éléments dans un rb-tree de pair.

Tu fais donc simplement lamap.erease(it); et le tour est joué ;)

std::map fait re balance d'office l'arbre qui contient ses valeurs, aussi bien à l'insertion qu'à l'effacement (la suppression d'un noeud n'implique pas la suppression des noeuds enfants ;))

Okay ça marche impec, merci koala :ccool:
Comme prévu, ce n'est pas efficace du tout, mais une map n'est pas un conteneur propice pour la suppression, surtout si ce sont des gros objets qui y sont stockés.
Mais bon, dans mon cas, cette suppression n'arrive que dans des cas exceptionnels.

Il y a une petite alternative plus simple : map::erase a une "key-based version"

Code:

---

1 2 3 4

auto it = the_map.find( "v1"); if ( it != the_map.end() ) the_map.erase(it);

---

équivalent à

Code:

---

the_map.erase("v1");

---

return (je cite) : "For the key-based version (2), the function returns the number of elements erased, which in map containers is at most 1." Du coup si l'élément n'existe pas la fonction renverra 0, sinon 1.

source : http://www.cplusplus.com/reference/map/map/erase/

Parfait, je prends. Merci :)