Discussion :

[Aspic]

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 :

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

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 :

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

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

[Goten]

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

Code :

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

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

[3DArchi]

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 :

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

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 :

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

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 :

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

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 :

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

mon_map.clear();

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

Code :

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

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

[Aspic]

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 :

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

1
2
3
4
5
6
template <typename T>
	void operator()(T& t) const
	{
	    libererBitmap(t.second);
	    t.second = NULL;
	}

Ou alors :

Code :

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

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

[koala01]

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 :

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

[r0d]

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 :

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

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?

[koala01]

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 )

[r0d]

Okay ça marche impec, merci koala
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.

[Kaamui]

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

Code :

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

1
2
3
4
 
auto it = the_map.find( "v1");
if ( it != the_map.end() )
  the_map.erase(it);

équivalent à

Code :

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

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/

[r0d]

Parfait, je prends. Merci