Boost.Bind para acceder a los elementos de std :: map en std :: for_each

Question

Tengo un mapa que almacena una estructura simple con una clave. La estructura tiene dos funciones miembro, una es const y la otra no. Logré llamar a la función const usando std :: for_each sin ningún problema, pero tengo algunos problemas para llamar a la función no 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))); 

La llamada a la función miembro const funciona bien, pero parece impulsar internamente espera un MyStruct const en alguna parte, y por lo tanto se produce el siguiente error de compilación en MSVC7.1.

impulso \ bind \ mem_fn_template.hpp (151): error C2440: 'argumento': no ​​se puede convertir de 'MyStruct const * __ W64' a 'MyStruct * const'

lo agradecería cualquier ayuda sobre cómo establecer los parámetros de la plantilla correctamente, de modo que bind reconoce los parámetros correctamente y me permite llamar a la función non const.

gracias, Carl

Answer 1

IIRC, Boost.Bind usa boost::mem_fn por su capacidad de vincular a los miembros. Ahora, si mira mem_fun (desplácese hacia abajo a la parte // data member support), verá que typedefs su result_type como const &, mientras que todavía tiene sobrecargas del operador de llamada de función que admite la extracción de un miembro no-const de un argumento no const.

Parece que el problema es que esto confunde el mecanismo de deducción del tipo de devolución de Boost.Bind. Una solución sería así dice explícitamente Enlazar que el resultado no es 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 problema que vi: el segundo se unen se llama a un miembro sin función. segundo es un miembro de datos, no es un método de std :: par

Answer 3

Si ya eres depende de Boost, puede estar dispuesto para comprobar Boost Foreach

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

Mucho más fácil de leer, aunque no sé sobre problemas de rendimiento.

También tenga en cuenta que no pueda usar con plantilla escrito dentro de la macro sin "escapar" del carácter ,:

• ya sea por un typedef antes
• o mediante el uso de un segundo par de paréntesis alrededor del Tipo

Answer 4

Si usted se encuentra el tener que hacer esto mucho le recomiendo que utilice la biblioteca 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)); 
} 

Ha sido aceptado en Boost pero aún no viene con la distribución oficial. Hasta que lo haga, puede download it del Boost Vault (enlace de descarga al archivo comprimido).