Wie funktioniert Boost Bind im Allgemeinen hinter den Kulissen?

Question

Ohne lange Zeit den Boost-Quellcode zu überprüfen, könnte mir jemand einen kurzen Überblick darüber geben, wie Boost-Bind implementiert ist?

Answer 1

Ich mag dieses Stück der bind Quelle:

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 

}; 

Teilt man fast alles, was Sie wissen müssen, wirklich.

Der Header bind_template wird zu einer Liste von Inline-Definitionen operator() erweitert. Zum Beispiel ist die einfachste:

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

Wir können die BOOST_BIND_RETURN Makro erweitert sich zu return an dieser Stelle sehen, so dass die Linie eher wie return l_(type...) ist.

Der eine Parameter-Version ist hier:

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

Es ziemlich ähnlich ist.

Die Klassen listN sind Wrapper für die Parameterlisten. Hier passiert viel Magie, die ich nicht wirklich verstehe. Sie haben auch operator() überladen, die die mysteriöse unwrap Funktion aufruft. Das Ignorieren einiger Compiler spezifische Überlastungen, tut es nicht viel:

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

Die Namenskonvention zu sein scheint: F ist die Art der Funktionsparameter zu bind. R ist der Rückgabetyp. L neigt dazu, eine Liste von Parametertypen zu sein. Es gibt auch eine Menge Komplikationen, denn es gibt nicht weniger als neun Überladungen für eine unterschiedliche Anzahl von Parametern. Am besten, nicht zu lange darüber nachzudenken.

Answer 2

Ich denke, es ist eine Vorlage-Klasse, die eine Member-Variable für die Argumente, die Sie binden möchten, und overloads() für den Rest der Argumente deklariert.

Answer 3

By the way, wenn bind_t kollabiert ist und vereinfacht durch boost/bind/bind_template.hpp einschließlich, wird es einfacher, wie das zu verstehen, folgende:

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

};