So konvertieren Sie einen lambda-Ausdruck, um ein std::function mit Vorlagen

Können Sie eine engagierte/Retrospektive cast. Sobald Sie ein tool wie dieses

#include <functional>

using namespace std;

template<typename T>
struct memfun_type
{
    using type = void;
};

template<typename Ret, typename Class, typename... Args>
struct memfun_type<Ret(Class::*)(Args...) const>
{
    using type = std::function<Ret(Args...)>;
};

template<typename F>
typename memfun_type<decltype(&F::operator())>::type
FFL(F const &func)
{ //Function from lambda !
    return func;
}

kann man sagen FFL() alle lambda-Arten zu haben Sie umgewandelt, was wäre die richtige version von std::function

template <typename... Args> void Callback(std::function<void(Args...)> f){
    //store f and call later
}

int main()
{
    Callback(FFL([](int a, float b){
        //do something
    }));

    return 0;
}

Anzeigen

InformationsquelleAutor Nikos Athanasiou

Ist es möglich, die benötigten std::function-Typ für lambda mit Ableitung, decltype, variadic-templates und ein paar Merkmale Typ:

namespace ambient {

    template <typename Function>
    struct function_traits : public function_traits<decltype(&Function::operator())> {};

    template <typename ClassType, typename ReturnType, typename... Args>
    struct function_traits<ReturnType(ClassType::*)(Args...) const> {
        typedef ReturnType (*pointer)(Args...);
        typedef const std::function<ReturnType(Args...)> function;
    };

    template <typename Function>
    typename function_traits<Function>::function to_function (Function& lambda) {
        return static_cast<typename function_traits<Function>::function>(lambda);
    }

    template <class L>
    struct overload_lambda : L {
        overload_lambda(L l) : L(l) {}
        template <typename... T>
        void operator()(T&& ... values){
            //here you can access the target std::function with
            to_function(*(L*)this)(std::forward<T>(values)...);
        }
    };

    template <class L>
    overload_lambda<L> lambda(L l){
        return overload_lambda<L>(l);
    }

}

Ich es in meinem code wie folgt:

ambient::lambda([&](const vector<int>& val){
//some code here //
})(a);

PS: in meinem realen Fall, den ich dann speichern Sie diese std::function Objekt und seine Argumente innerhalb einer generischen kernel-Objekte, die ich ausführen kann später auf Nachfrage über virtuelle Funktionen.

InformationsquelleAutor Alex Kosenkov

Dies könnte interessant für Sie sein: https://gist.github.com/Manu343726/94769034179e2c846acc

Dass ist ein experiment, das ich geschrieben habe, vor einem Monat. Das Ziel war die Erstellung einer Funktor-wie C++ - template, das emuliert Haskell ist teilweise Anrufe Schließungen, d.h. die automatische Erstellung einer Schließung der m-n argumments, wenn Sie anrufen, mit n argumments eine Funktion mit m Parameter.

Dies ist ein Beispiel dafür, was dieses experiment ist cappable zu tun:

int f( int a, int b, int c, int d)
{
    return a+b+c+d;
}

int main()
{
    auto foo = haskell::make_function( f );

    auto a = foo , 1 , 2 , 3; //a is a closure function object with one parameter

    std::cout << a , 4 << std::endl; //Prints 10
}

haskell::make_function verwendet einige geben, die Züge kümmern sich um die verschiedenen Arten von Funktion Entitäten, Lambda-Ausdrücke enthalten:

auto f = haskell::make_function( []( int x, int y , int z ){ return x*y*z; } );

auto a = f(1,2); //a is functor with one parameter (Using the alternative C++-like syntax)
auto b = a(3); //b is 6

Wie Sie sehen können, ich benutze Komma-operator zu mmimic Haskell-syntax, aber Sie ändern könnte, um den Anruf Betreiber Ihr Ziel zu erreichen syntax.

Ihr völlig frei, zu tun, was Sie wollen, mit dem code (Prüfung der Lizenz).

InformationsquelleAutor Manu343726