Como funciona o impulso ligam nos bastidores em geral?

Question

Sem gastar muito tempo revendo o código fonte impulso, alguém poderia me dar um rápido resumo de como se ligam impulso é implementado?

Answer 1

I como este pedaço da fonte bind:

template<class R, class F, class L> class bind_t
{
public:

    typedef bind_t this_type;

    bind_t(F f, L const & l): f_(f), l_(l) {}

#define BOOST_BIND_RETURN return
#include <boost/bind/bind_template.hpp>
#undef BOOST_BIND_RETURN

};

Diz-lhe quase tudo o que você precisa saber, realmente.

O cabeçalho bind_template se expande para uma lista de definições operator() inline. Por exemplo, o mais simples:

result_type operator()()
{
    list0 a;
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}

Podemos ver os BOOST_BIND_RETURN expande macro para return neste momento para que a linha é mais como return l_(type...).

A versão um parâmetro está aqui:

template<class A1> result_type operator()(A1 & a1)
{
    list1<A1 &> a(a1);
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}

É muito similar.

As classes listN são invólucros para as listas de parâmetros. Existe uma grande quantidade de magia profunda acontecendo aqui que eu realmente não entendo muito embora. Eles também têm sobrecarregado operator() que chama a função unwrap misteriosa. Ignorando algumas sobrecargas do compilador específico, ele não faz muito:

// unwrap

template<class F> inline F & unwrap(F * f, long)
{
    return *f;
}

template<class F> inline F & unwrap(reference_wrapper<F> * f, int)
{
    return f->get();
}

template<class F> inline F & unwrap(reference_wrapper<F> const * f, int)
{
    return f->get();
}

A convenção de nomenclatura parece ser: F é o tipo do parâmetro de função para bind. R é o tipo de retorno. L tende a ser uma lista de tipos de parâmetros. Há também uma série de complicações, porque há nada menos do que nove sobrecargas para diferentes números de parâmetros. Melhor não me debruçar sobre isso muito.

Answer 2

A propósito, se bind_t é recolhido e simplificado por incluindo boost/bind/bind_template.hpp, torna-se mais fácil compreender como o seguinte:

template<class R, class F, class L> 
class bind_t
{
    public:

        typedef bind_t this_type;

        bind_t(F f, L const & l): f_(f), l_(l) {}

        typedef typename result_traits<R, F>::type result_type;
        ...
        template<class A1> 
            result_type operator()(A1 & a1)
            {
                list1<A1 &> a(a1);
                return l_(type<result_type>(), f_, a, 0);
            }
    private:
        F f_;
        L l_;

};

Answer 3

Eu acho que é uma classe de modelo que declara uma variável de membro para os argumentos que você deseja vincular e sobrecargas () para o resto dos argumentos.