c++ - seguridad - tipos de enlace quimico

¿Cómo funciona el enlace de refuerzo detrás de las escenas 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 de refuerzo?

Answer 1

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 2

Por cierto, si bind_t está contraído y simplificado al incluir boost/bind/bind_template.hpp , se vuelve más fácil de entender como lo 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_;
};

Answer 3

Me gusta esta parte de la fuente de 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
};

Te dice casi todo lo que necesitas saber, realmente.

El encabezado bind_template expande a una lista de definiciones de operator() 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 que la macro BOOST_BIND_RETURN expande para return en este punto, por lo que la línea es más parecida a return l_(type...) .

La versión de un solo parámetro está 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 wrappers para las listas de parámetros. Hay una gran cantidad de magia profunda sucediendo aquí que realmente no entiendo demasiado. También han sobrecargado el operator() que llama a la misteriosa función unwrap . Ignorando algunas sobrecargas específicas del compilador, no hace mucho:

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

La convención de nomenclatura parece ser: F es el tipo de parámetro de función para 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.