Invirtiendo cadenas en un vector usando for_each y bind

Question

Estaba deambulando cómo es posible reverese string s que están contenidas en un vector usando un solo comando for_each solo en una línea "simple".

Sí, sé que es fácil con un functor personalizado, pero no puedo aceptar que no se puede hacer usando bind (al menos no pude hacerlo).

#include <vector> 
#include <string> 
#include <algorithm> 

std::vector<std::string> v; 
v.push_back("abc"); 
v.push_back("12345"); 

std::for_each(v.begin(), v.end(), /*call std::reverse for each element*/); 

Editar: Gracias mucho por esas soluciones funtastic. Sin embargo, la solución para mí no era usar el tr1::bind que viene con el paquete de características/SP1 de Visual Studio 2008. No sé por qué no funciona como se esperaba, pero así son las cosas (even MS admits that it's buggy). Tal vez algunos hotfixes ayudarán.

Con boost :: bind todo funciona como se desea y es tan fácil (pero a veces relly messy :)). Realmente debería haber intentado impulso :: unen en el primer lugar ...

Answer 1

std :: for_each espera una función unaria (o al menos algo con los typedefs de una función unaria).

std :: reverse <> es una función binaria. Se necesitan dos iteradores. Sería posible unirlo todo usando boost :: bind, pero sería un lío bastante horrible. Algo así como:

boost::bind(
    &std::reverse<std::string::iterator>, 
     boost::bind(&std::string::begin, _1), 
     boost::bind(&std::string::end, _1)) 

mejor, creo, sería escribir una función llamada reutilizable reverse_range así:

template <class Range> 
void reverse_range(Range& range) 
{ 
    std::reverse(range.begin(), range.end()); 
} 

(probablemente con alguna metaprogramming para asegurar que la gama & no es un doble referencia)

Y luego usar eso en su for_each (después de adaptarlo para ser una función única, por supuesto).

std::for_each(v.begin(), v.end(), 
    std::ptr_fun(&reverse_range<std::string>)); 

EDIT:

Debido string :: string :: comenzar y terminar tener tanto const y no const variantes, es necesario para que los echasen (como litb descubrió mientras estaba fuera escribiendo a probar mi respuesta ... +1!). Esto lo hace muy detallado. Typedefs puede que sea un poco más higiénico, sino para seguir con el tema de una sola línea:

boost::bind(
    &std::reverse<std::string::iterator>, 
    boost::bind(
     (std::string::iterator (std::string::*)())&std::string::begin, _1), 
    boost::bind(
     (std::string::iterator (std::string::*)())&std::string::end, _1) 
    ) 
); 

¿Qué acaba de gritos de refactorización.

Por último, porque estoy aburrido, puntos de bonificación para C++ 0x:

std::for_each(v.begin(), v.end() [](std::string& s){ std::reverse(s); }); 

EDIT: boost :: bind funciona bien, sin necesidad de impulso :: lambda.

Answer 2

Usted tendría que rodar su propio objeto inversa:

struct Reverser 
{ 
    void operator()(std::string& value) const 
    { 
     std::reverse(value.begin(),value.end()); 
    } 
}; 

Ahora usted puede hacerlo una sola línea:

std::for_each(v.begin(), v.end(), Reverser()); 

Answer 3

Con Boost.Phoenix2:

std::for_each(v.begin(), v.end(), boost::phoenix::reverse(arg1)); 

Parafraseando mr-EDD: awesomer :)

ejemplo medible completo:

#include <boost/spirit/home/phoenix.hpp> 
#include <algorithm> 
#include <vector> 
#include <string> 
#include <iostream> 
#include <iterator> 

int main(void) 
{ 

    using namespace boost::phoenix::arg_names; // for "arg1" 

    std::vector<std::string> v; 
    v.push_back("hello"); 
    v.push_back("world"); 
    std::for_each(v.begin(), v.end(), boost::phoenix::reverse(arg1)); 

    std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "\n")); 
} 

impresiones:

olleh 
dlrow 

Answer 4

podría b E también hacerse con la macro BOOST_FOREACH:

BOOST_FOREACH(std::string& s, v) 
    std::reverse(s.begin(), s.end());