Función de miembro de llamada en cada elemento en un contenedor

Question

Esta pregunta es una cuestión de estilo, ya que siempre puede escribir un bucle for o algo similar; sin embargo, ¿existe un STL o BOOST menos molesto equivalente a la escritura?

for (container<type>::iterator iter = cointainer.begin(); 
    iter != cointainer.end(); 
    iter++) 
iter->func(); 

?

Algo así como (imaginaria) esto:

call_for_each(container.begin(), container.end(), &Type::func); 

creo que sería 1) escribir menos, 2) fácil de leer, 3) menos cambios Si ha decidido cambiar el tipo de base de tipo/contenedor.

EDIT: Gracias por su ayuda, ahora, ¿y si quisiera pasar algunos argumentos a la función miembro?

Answer 1

descubrí que impulso se unen parece ser muy adecuado para la tarea, además de que puede pasar argumentos adicionales para el método:

#include <iostream> 
#include <functional> 
#include <boost/bind.hpp> 
#include <vector> 
#include <algorithm> 

struct Foo { 
    Foo(int value) : value_(value) { 
    } 

    void func(int value) { 
     std::cout << "member = " << value_ << " argument = " << value << std::endl; 
    } 

private: 
    int value_; 
}; 

int main() { 
    std::vector<Foo> foo_vector; 

    for (int i = 0; i < 5; i++) 
     foo_vector.push_back(Foo(i)); 

    std::for_each(foo_vector.begin(), foo_vector.end(), 
     boost::bind(&Foo::func, _1, 1)); 
} 

Answer 2

#include <algorithm> // for_each 
#include <functional> // bind 

// ... 

std::for_each(container.begin(), container.end(), 
        std::bind(&Type::func)); 

Ver std::for_each y std::bind documentación para más detalles.

omitido su edición: De todos modos aquí es otra manera de lograr lo que desee sin necesidad de impulso, si alguna vez necesita ser:

std::for_each(foo_vector.begin(), foo_vector.end(), 
    std::bind(&Foo::func, std::placeholders::_1)); 

Answer 3

Puede utilizar std::for_each o boost's foreach constructs.

Utilice boost BOOST_FOREACH o BOOST_REVERSE_FOREACH cuando no desee mover la lógica a otra función.

Answer 4

Si realmente desea mejorar el rendimiento en lugar de simplemente actualizar su código, lo que realmente necesita es una función de mapa. Eric Sink escribió un .net implementation