como boost :: function and boost :: bind work

Eu não gosto de ter checkboxs mágicas espalhadas por todo o meu código … como exatamente essas duas classs funcionam para permitir que basicamente qualquer function seja mapeada para um object de function mesmo se a function tiver um parâmetro completamente diferente definido para aquele que está passando para boost::bind

Ele até funciona com diferentes convenções de chamada (isto é, os methods de membro são __thiscall em VC, mas as funções “normais” geralmente são __cdecl ou __stdcall para aquelas que precisam ser compatíveis com C.

    boost::function permite que qualquer coisa com um operator() com a assinatura certa seja ligada como o parâmetro, e o resultado de sua binding possa ser chamado com um parâmetro int , então pode ser ligado a function .

    É assim que funciona (esta descrição se aplica da mesma forma para std::function ):

    boost::bind(&klass::member, instance, 0, _1) retorna um object como este

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

    onde o return_type e int são inferidos da assinatura de klass::member , e o parâmetro de function e o parâmetro ligado são de fato armazenados no object, mas isso não é importante

    Agora, o boost::function não faz nenhuma verificação de tipo: ele pegará qualquer object e qualquer assinatura que você fornecer em seu parâmetro de modelo e criará um object que pode ser chamado de acordo com sua assinatura e chama o object. Se isso é impossível, é um erro de compilation.

    boost::function é na verdade um object como este:

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

    onde o return_type e o return_type são extraídos de Sig e f é alocado dinamicamente no heap. Isso é necessário para permitir que objects completamente não relacionados com tamanhos diferentes se vinculem ao boost::function .

    function_impl é apenas uma class abstrata

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

    A class que faz todo o trabalho, é uma class concreta derivada de boost::function . Existe um para cada tipo de object que você atribui para boost::function

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

    Isso significa que, no seu caso, a atribuição para impulsionar a function:

    1. instancia um tipo function_impl_concrete (que é tempo de compilation, é claro)
    2. cria um novo object desse tipo na pilha
    3. atribui este object ao f membro do boost :: function

    Quando você chama o object de function, ele chama a function virtual de seu object de implementação, que direcionará a chamada para sua function original.

    ISENÇÃO DE RESPONSABILIDADE: Observe que os nomes nesta explicação são deliberadamente inventados. Qualquer semelhança com pessoas reais ou personagens … você sabe disso. O objective era ilustrar os princípios.