cómo boost :: function and boost :: bind work

Question

No me gusta tener cajas mágicas dispersas por todo mi código ... ¿Cómo funcionan exactamente estas dos clases para permitir básicamente que cualquier función se asigne a un objeto de función incluso si la función <> tiene un parámetro completamente diferente al que más im pasando a boost::bind

incluso trabaja con diferentes convenciones de llamada (es decir, métodos miembros son __thiscall bajo VC, pero las funciones "normales" son generalmente __cdecl o __stdcall para aquellos que necesitan ser compatible con C.

Answer 1

boost::function permite cualquier cosa con operator() con la firma correcta para vincularse como parámetro, y el resultado de su enlace se puede invocar con un parámetro int, por lo que puede vincularse al function<void(int)>.

Esto es cómo funciona (esta descripción se aplica por igual a std::function):

boost::bind(&klass::member, instance, 0, _1) devuelve un objeto como éste

struct unspecified_type 
{ 
    ... some members ... 
    return_type operator()(int i) const { return instance->*&klass::member(0, i); 
} 

donde el return_type y int se infiere a partir de la firma del klass::member, y el El puntero a la función y el parámetro enlazado están de hecho almacenados en el objeto, pero eso no es importante

Ahora, boost::function hace no hacer ninguna verificación de tipo: tomará cualquier objeto y cualquier firma que proporcione en su parámetro de plantilla, y creará un objeto que se pueda llamar de acuerdo con su firma y llame al objeto. Si eso es imposible, es un error de compilación.

boost::function es en realidad un objeto como este:

template <class Sig> 
class function 
{ 
    function_impl<Sig>* f; 
public: 
    return_type operator()(argument_type arg0) const { return (*f)(arg0); } 
}; 

donde el return_type y argument_type se extraen de Sig, y f se asigna dinámicamente en el montón. Eso es necesario para permitir que objetos completamente no relacionados con diferentes tamaños se unan a boost::function.

function_impl es sólo una clase abstracta

template <class Sig> 
class function_impl 
{ 
public: 
    virtual return_type operator()(argument_type arg0) const=0; 
}; 

La clase que hace todo el trabajo, es una clase concreta derivada de boost::function. Hay uno para cada tipo de objeto que se asigna a boost::function

template <class Sig, class Object> 
class function_impl_concrete : public function_impl<Sig> 
{ 
    Object o 
public: 
    virtual return_type operator()(argument_type arg0) const=0 { return o(arg0); } 
}; 

Eso significa, en su caso, la cesión a estimular la función:

1. instancia un tipo function_impl_concrete<void(int), unspecified_type> (que es el tiempo de compilación, por supuesto)
2. crea un nuevo objeto de ese tipo en el montón
3. asigna este objeto para el miembro f de la función impulso ::

Cuando llama al objeto de función, llama a la función virtual de su objeto de implementación, que dirigirá la llamada a su función original.

DESCARGO DE RESPONSABILIDAD: Tenga en cuenta que los nombres en esta explicación se componen deliberadamente. Cualquier parecido con personas o personajes reales ... lo sabes. El propósito fue ilustrar los principios.