¿Estoy reinventando la rueda con este método trivial llamada clase de reenvío?

Question

yo sólo me encontré crear una clase

template <typename T> struct invoker { 
    void operator()(T& it) const {it();} 
}; 

para que pudiera pasar una invoker<foo> a algo (que no está bajo mi control), que quiere llamar invoker<foo>::operator()(foo&) en él en varias ocasiones con diferentes foo casos, para conseguir que se reenviar esas llamadas al método foofoo::operator()().

Sé que son solo unas pocas líneas, pero esto parece ser el tipo de cosa que probablemente ya está prevista por el funcional de STL, o boost::bind de alguna manera. Excepto que no puedo ver el truco, si es que hay uno. (Estoy seguro de que no soy la primera persona en usar algo muy parecido a esto: ¿tiene un nombre?)

Answer 1

Sí, estás reinventando la rueda. std :: mem_fun_ref hace lo que quieres.

std::vector<foo> foos; 

... 

std::for_each(foos.begin(), foos.end(), std::mem_fun_ref(&foo::operator())); 

alternativa:

std::vector<foo*> foos; 

... 

std::for_each(foos.begin(), foos.end(), std::mem_fun(&foo::operator())); 

No tener que meterse con si el parámetro es es una gran ventaja PTR o no de impulso :: mem_fn.

Sin embargo, es mucho más complejo que eso y empiezas a tener problemas con los encuadernadores C++ 03 y necesitas algo más expresivo como boost.bind.

Answer 2

Bueno, se puede utilizar std::bind, probablemente boost::bind así lograr el mismo comportamiento:

#include <string> 
#include <iostream> 
#include <functional> 

struct foo { 
    void operator()() { 
     std::cout << "Hallo, im at addr: " << std::hex << this << std::endl; 
    } 
}; 

int main() { 
    std::function<void(foo*)> fun = std::bind(&foo::operator(), std::placeholders::_1); 
    foo f1, f2; 
    fun(&f1); 
    fun(&f2); 
} 

Salidas:

Hallo, im at addr: 0xbffc396a 
Hallo, im at addr: 0xbffc3969 

Si utiliza una clase de plantilla para el tipo de argumento, que puede tener la misma behvaiour sin reinventar la rueda.

Editar: Eddie el Loco como señaló, sólo puede utilizar boost::mem_fn o std::mem_fn:

std::function<void(foo*)> fun = std::mem_fn(&foo::operator()); 

En lugar de bind.