Especificación de una función miembro como una devolución de llamada en C++ 11

Question

Tengo el siguiente:

typedef std::function<bool (const std::string&)> SomethingCoolCb; 

class ClassA 
{ 
public: 
    void OnSomethingCool(const SomethingCoolCb& cb) 
    { 
     _cb = cb; 
    } 

private: 
    SomethingCoolCb _cb; 
}; 

class ClassB 
{ 
public: 
    ClassB(); 
    bool Juggle(const std::string& arg); 

private: 
    ClassA _obj; 
}; 

y quiero especificar la función de miembro de ClassB :: Malabares() como la devolución de llamada a ClassB :: _ obj. Sería la forma correcta de hacer que en C++ 11 sea (en el constructor del ClassB):

ClassB::ClassB() 
{ 
    _obj.OnDoSomethingCool(
     [&](const std::string& arg) -> bool 
     { 
      return Juggle(arg); 
     }); 
} 

Por lo que entiendo, el compilador hará que un objeto std :: función del código de lambda anteriormente. Entonces, cuando se invoque la devolución de llamada, llamará al miembro std :: function :: operator() y luego invocará ClassB :: Juggle() en lugar de invocar ClassB :: Juggle() directamente. A menos que me equivoque sobre lo que sucede bajo las sábanas, todo parece ser un poco ineficiente. ¿Hay una mejor manera?

Answer 1

Solo use std::function si realmente necesita funciones polimórficas. De lo contrario, conviértalo en una plantilla.

Para adaptar una función de miembro a un functor use std::mem_fn y luego bind un objeto al primer argumento, el functor resultante puede servir como su devolución de llamada.

muestra:

#include <string> 
#include <functional> 

template<typename F> 
class ClassA 
{ 
public: 
    ClassA(F f) : _cb(f) {} 

private: 
    F _cb; 
}; 

class ClassB 
{ 
public: 
    ClassB() 
    : _obj(std::bind(&ClassB::Juggle, this, 
        std::placeholders::_1)) 
    {} 
    bool Juggle(const std::string& arg) {return true;} 
private: 
    ClassA<decltype(std::bind(
         std::declval<bool (ClassB::*)(const std::string&)>() 
         , std::declval<ClassB*>() 
         , std::placeholders::_1 
        )) > _obj; 
}; 

int main() 
{ 
    ClassB b; 
    return 0; 
} 

Este lado-pasos el precio de la función en el costo de ser terriblemente feo.