Delegado en C++ 11

Question

¿C++ 11 proporciona delegados?

Si no es así, ¿cuál es la mejor (más eficiente) forma de hacer algo similar en C++? Boost.Signals? FastDelegate? ¿Algo más?

Answer 1

Usted puede obtener la semántica delegado como el uso de bind para unirse a una función miembro de una instancia de clase:

#include <functional> 

struct C 
{ 
    void Foo(int) { } 
}; 

void Bar(std::function<void(int)> func) 
{ 
    func(42); // calls obj.Foo(42) 
} 

int main() 
{ 
    using namespace std::placeholders; 

    C obj; 
    Bar(std::bind(&C::Foo, obj, _1)); 
} 

En este ejemplo, Bar() toma cualquier cosa que tenga un solo int parámetros y que devuelve void.

En main(), vinculamos un puntero a la función de miembro C::Foo a la instancia de C con el nombre obj. Esto nos da un objeto que se puede llamar con un solo parámetro int y que devuelve void.

Llamamos Bar() con este objeto y Bar() hace la llamada obj.Foo(42).

Answer 2

El mecanismo C siempre ha sido puntero a la función & bastón (excepto qsort() y bsearch() que no tomó un bastón).

Así que uno siempre pasaría el objeto de clase como testigo.

ej .:

class tp { 
    public: 
     tp() { n = 0; } 
     void m(int z) { printf("%d is %d\n", n++, z++); } 
     int n; 
}; 

void higher_func(int *opx, int cnt, void *handler(int itm, void *baton), void *baton) 
{ 
    for (int i = 0; i < cnt; i++) 
     handler(opx[itm], baton); 
} 

/* You would need to provide this stub -- potentially templateable */ 
void translate_baton(int itm, void *baton) { ((tp *)baton)->m(itm); } 

/* used like so: */ 
int main() 
{ 
    int array[7]; 

    //... 
    tp cx; 
    higher_func(array, 7, translate_baton, &cx); 
} 

Answer 3

No necesariamente tienen que esperar para C++ 0x. Puede implementar Delegados casi tan bien en el estándar actual C++ 03. Simplemente tiene que sobrecargar el operador(), de modo que puede llamar al MyObjectFunctor functor; functor(); y dado que el funtor es un objeto, puede pasarlo como un delegado/objeto a funciones;

La versión actual de la STL define el encabezado <algorithm> que proporciona funciones listas para ser utilizadas con Functors/Lambdas/Delegates.

ejemplo simple de un functor.

struct FunctorDelegate 
{ 
    // as so to delegate as a function that takes an int input 
    void operator()(int) 
    { 
     // do what I want 
    } 
}; 

int main() 
{ 
    //... do some stuffs with an std::vector<int> aRange; 
    FunctorDelegate functor; 
    std::for_each(aRange.begin(), arange.end(), functor); 
} 

Answer 4

No necesita C++ 0x. en <functional> tiene bind1stbind2ndmem_fun y mem_fun_ref. También tiene Boost.Bind que generaliza todas las funciones anteriores (IIRC).

Yendo de la memoria ...

vector<Foo> foo = makeVector(); 
vector<Foo*> foop = makeVectorP(); 
vector<Bar> bar1,bar2,bar3,bar4; 
transform(foo.begin(), foo.end(), back_inserter(bar1), mem_fun_ref(&Foo::getBar)); 
transform(foop.begin(), foop.end(), back_inserter(bar2), mem_fun(&Foo::getBar)); 
transform(foo.begin(), foo.end(), back_inserter(bar3), bind1st(&bar_from_foo)); 
transform(foo.begin(), foo.end(), back_inserter(bar4), boost::bind(&bar_from_foo, _1)); 

Answer 5

Aunque std::function funciona muy bien, me gustaría señalar esta bonita pieza de código delegado, por escrito here (incluyendo ejemplo de uso!). A continuación de las referencias y respuestas, puede leer todo sobre cómo se construye esta clase Delegate y por qué puede ser más rápido que std::function.

Tenga en cuenta también que mi pregunta here para un problema que me encontré con él en VS 2015.