Comment utiliser for_each pour supprimer toutes les valeurs d'une carte STL?

Question

Supposons que j'ai une carte STL où les valeurs sont des pointeurs, et je veux les supprimer tous. Comment représenter le code suivant, mais en utilisant std :: for_each? Je suis heureux pour les solutions à utiliser Boost.

for(stdext::hash_map<int, Foo *>::iterator ir = myMap.begin(); 
    ir != myMap.end(); 
    ++ir) 
{ 
    delete ir->second; // delete all the (Foo *) values. 
} 

(j'ai trouvé checked_delete de Boost, mais je ne suis pas sûr de savoir comment l'appliquer à la pair<int, Foo *> que le iterator représente).

(De même, pour les besoins de cette question, ignorez le fait que stocker des pointeurs bruts qui ont besoin d'être supprimés dans un conteneur STL n'est pas très judicieux).

Note: J'ai trouvé et listé ci-dessous une réponse d'une ligne ci-dessous ... mais le code est assez horrible, donc j'ai accepté la réponse de GMan.

Answer 1

Vous devez faire un objet de fonction:

struct second_deleter 
{ 
    template <typename T> 
    void operator()(const T& pX) const 
    { 
     delete pX.second; 
    } 
}; 

std::for_each(myMap.begin(), myMap.end(), second_deleter()); 

Si vous utilisez coup de pouce, vous pouvez aussi utiliser la bibliothèque lambda:

namespace bl = boost::lambda; 
std::for_each(myMap.begin(), myMap.end(), second_deleter(), 
       bl::bind(bl::delete_ptr(), 
       bl::bind(std::select2nd<myMap::value_type>(), _1)); 

Mais vous pouvez essayer la bibliothèque pointer containers qui fait cela automatiquement. Notez que vous n'utilisez pas de carte, mais un hash_map. Je vous recommande de passer à unordered_map de boost, ce qui est plus courant. Cependant, il ne semble pas y avoir de ptr_unordered_map.

Pour plus de sécurité, vous devriez envelopper ce truc. Par exemple:

template <typename T, typename Deleter> 
struct wrapped_container 
{ 
    typedef T container_type; 
    typedef Deleter deleter_type; 

    wrapped_container(const T& pContainer) : 
    container(pContainer) 
    {} 

    ~wrapped_container(void) 
    { 
     std::for_each(container.begin(), container.end(), deleter_type()); 
    } 

    T container; 
}; 

et de l'utiliser comme:

typedef wrapped_container< 
      boost::unordered_map<int, Foo*>, second_deleter> my_container; 

my_container.container./* ... */ 

Cela garantit peu importe, votre conteneur sera itérés avec un Deleter. (. Sauf exception, par exemple)

Comparez:

std::vector<int*> v; 
v.push_back(new int); 

throw "leaks!"; // nothing in vector is deleted 

wrapped_container<std::vector<int*> > v; 
v.container.push_back(new int); 

throw "no leaks!"; // wrapped_container destructs, deletes elements 

Answer 2

S'il est possible, pourquoi ne pas utiliser des pointeurs intelligents dans votre carte?

Answer 3

Avez-vous essayé d'utiliser BOOST_FOREACH? Cela devrait vous permettre de faire cela en ligne sans créer votre propre foncteur.

Je n'ai pas testé le code suivant mais il devrait ressembler à ceci (sinon exactement):

typedef stdext::hash_map<int, Foo *> MyMapType; //see comment. 
BOOST_FOREACH(MyMapType::value_type& p, myMap) 
{ 
    delete p.second; 
} 

thats bien plus de 1 ligne, en raison de la typedef :)

Answer 4

OK, J'ai découvert comment le faire en une ligne ... mais je ne pense pas que je ferais jamais ce qui suit en vrai code!

std::for_each(mayMap.begin() 
      , myMap.end() 
      , boost::bind(&boost::checked_delete<Foo> 
          , boost::bind(&stdext::hash_map<int, Foo *>::value_type::second, _1))); 

Cependant, je vais accepter la réponse de GMan parce que j'aime son idée d'un récipient enveloppé, et ma réponse, en dépit d'être une ligne comme l'a demandé, est tout simplement méchant.