¿Cómo funciona el enlace de refuerzo entre bastidores en general?

Question

Sin pasar mucho tiempo revisando el código fuente de impulso, ¿podría alguien darme un resumen rápido de cómo se implementa el enlace boost?

Answer 1

me gusta esta pieza de la fuente 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 

}; 

Le dice casi todo lo que necesita saber, de verdad.

El encabezado bind_template se expande a una lista de definiciones en línea operator(). Por ejemplo, el más simple:

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

podemos ver el BOOST_BIND_RETURN expande macro a return en este punto lo que la línea es más como return l_(type...).

El parámetro es una versión aquí:

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

Es bastante similar.

Las clases listN son envoltorios para las listas de parámetros. Hay una gran cantidad de magia profunda sucediendo aquí que realmente no entiendo demasiado. También han sobrecargado operator() que llama a la misteriosa función unwrap. Haciendo caso omiso de algunas sobrecargas específicas del compilador, que no hace mucho:

convención

// 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(); 
} 

El nombramiento parece ser: F es el tipo de parámetro de la función de bind. R es el tipo de devolución. L tiende a ser una lista de tipos de parámetros. También hay muchas complicaciones porque hay no menos de nueve sobrecargas para diferentes números de parámetros. Lo mejor es no pensar demasiado en eso.

Answer 2

Creo que es una clase de plantilla que declara una variable miembro para los argumentos que desea vincular y sobrecarga() para el resto de los argumentos.

Answer 3

Por cierto, si bind_t se colapsa y simplificado mediante la inclusión de boost/bind/bind_template.hpp, se hace más fácil de entender como la siguiente:

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_; 

};