Wie funktioniert steigern bindet Arbeit hinter den Kulissen im Allgemeinen?

Question

Ohne eine lange Zeit verbringen die Boost-Quellcode Überprüfung könnte jemand mir einen schnellen Überblick darüber, wie Boost-bind umgesetzt wird?

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 bind_template Header erweitert, um eine Liste von Inline-operator() Definitionen. Zum Beispiel ist die einfachste:

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

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

Die ein 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 ist ziemlich ähnlich.

Die listN Klassen sind Wrapper für die Parameterlisten. Es gibt eine Menge von tiefer Magie geht hier vor, dass ich wirklich obwohl zu viel nicht verstehen. Sie haben auch operator() überlastet, dass die geheimnisvolle unwrap Funktion aufruft. einige Compiler spezifische Überlastungen zu ignorieren, ist es nicht viel tun:

// 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 die Art des Funktionsparameters ist zu bind. R ist der Rückgabetyp. L neigt eine Liste der Parametertypen zu sein. Darüber hinaus gibt es viele Komplikationen, weil es nicht weniger als neun Überlastungen für eine unterschiedliche Anzahl von Parametern. Am besten nicht zu verweilen auf dieser zu viel.

Answer 2

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

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

Ich denke, es ist eine Template-Klasse, die eine Membervariable für die Argumente erklären Sie binden und Überlastungen wollen () für den Rest der Argumente.