Boost.Bind pour accéder aux éléments std :: map dans std :: for_each

Question

J'ai une carte qui stocke une structure simple avec une clé. La structure a deux fonctions membres, l'une est const l'autre non. J'ai réussi à appeler la fonction const en utilisant std :: for_each sans aucun problème, mais j'ai quelques problèmes pour appeler la fonction non-const.

struct MyStruct { 
    void someConstFunction() const; 
    void someFunction(); 
}; 

typedef std::map<int, MyStruct> MyMap; 
MyMap theMap; 

//call the const member function 
std::for_each(theMap.begin(), theMap.end(), 
    boost::bind(&MyStruct::someConstFunction, boost::bind(&MyMap::value_type::second, _1))); 

//call the non-const member function 
std::for_each(theMap.begin(), theMap.end(), 
    boost::bind(&MyStruct::someFunction, boost::bind(&MyMap::value_type::second, _1))); 

L'appel à la fonction membre const fonctionne très bien, mais il semble stimuler quelque part à l'intérieur d'un attend const MyStruct, et ne satisfait donc pas l'erreur de compilation suivante dans MSVC7.1.

boost \ bind \ mem_fn_template.hpp (151): erreur C2440: 'argument': ne peut pas convertir 'const MyStruct * __ w64' à 'MyStruct * const'

J'apprécierais tout Aide sur la façon de définir correctement les paramètres du modèle, donc bind reconnaît les paramètres correctement et laisse-moi appeler la fonction non const.

grâce, Carl

Answer 1

IIRC, Boost.Bind utilise boost::mem_fn pour sa capacité de liaison aux membres. Maintenant, si vous regardez mem_fun (faites défiler jusqu'à la partie // data member support), vous verrez qu'il typedefs son type result_type comme const &, alors qu'il a encore des surcharges de l'opérateur d'appel de fonction supportant l'extraction d'un membre non-const de un argument non-const.

Il semble donc que le problème est que cela confond le mécanisme de déduction du type de retour de Boost.Bind. Une solution serait donc de dire explicitement à Bind que le résultat n'est pas const:

//call the non-const member function 
std::for_each(theMap.begin(), theMap.end(), 
    boost::bind(&MyStruct::someFunction, 
     boost::bind<MyStruct&>(&MyMap::value_type::second, _1) 
    ) 
); 

Answer 2

Un problème que je repéré: la deuxième liaison est appelé à un membre non fonctionnel. second est un membre de données, pas une méthode de std :: paire

Answer 3

Si vous êtes déjà dépendez Boost, vous pouvez être prêt à vérifier Boost Foreach

BOOST_FOREACH(MyMap::value_type const& val, MyMap) 
{ 
    val.second.someConstFunction(); 
} 

Beaucoup plus facile à lire, même si je ne sais pas sur les problèmes de performance.

Notez également que vous ne pouvez utiliser dans le typé basé sur un modèle macro sans « échapper » le caractère ,:

• soit par un typedef avant
• ou en utilisant une deuxième paire de parenthèses autour du type

Answer 4

Si vous vous trouvez avoir à faire beaucoup, je vous recommande d'utiliser la bibliothèque Boost.RangeEx:

#include <boost/range/algorithm/for_each.hpp> 
#include <boost/range/adaptor/map.hpp> 
#include <boost/mem_fn.hpp> 
#include <map> 

struct MyStruct { 
    void someConstFunction() const; 
    void someFunction(); 
}; 

typedef std::map<int, MyStruct> MyMap; 
MyMap theMap; 

int main() 
{ 
    //call the const member function 
    boost::for_each(theMap | boost::adaptors::map_values, 
        boost::mem_fn(&MyStruct::someConstFunction)); 

    //call the non-const member function 
    boost::for_each(theMap | boost::adaptors::map_values, 
        boost::mem_fn(&MyStruct::someFunction)); 
} 

Il a été accepté dans Boost mais il n'a pas encore été distribué officiellement. Jusqu'à ce que vous le pouvez download it à partir du Boost Vault (lien de téléchargement au fichier zip).