Как преобразовать лямбда в std:: функция с помощью шаблонов

можно использовать посвященный / ретроспективный бросок. Как только у вас есть такой инструмент

#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;
}

можно сказать FFL() для всех типов лямбда пусть они преобразуются в то, что было бы правильной версией 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;
}

дисплей

как показано на вывод сигнатуры вызова лямбды или произвольного вызываемого объекта для "make_function", вы можете вывести вызывающую подпись лямбды (или любого другого функтора с одной вызывающей подписью) из его (single)operator():

template<typename T> struct remove_class { };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...)> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) volatile> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const volatile> { using type = R(A...); };

template<typename T>
struct get_signature_impl { using type = typename remove_class<
    decltype(&std::remove_reference<T>::type::operator())>::type; };
template<typename R, typename... A>
struct get_signature_impl<R(A...)> { using type = R(A...); };
template<typename R, typename... A>
struct get_signature_impl<R(&)(A...)> { using type = R(A...); };
template<typename R, typename... A>
struct get_signature_impl<R(*)(A...)> { using type = R(A...); };
template<typename T> using get_signature = typename get_signature_impl<T>::type;

это довольно негибкий подход, хотя; как говорит Р. Мартиньо Фернандес, он не будет работать для функторов с несколькими operator()s, ни для функторов с шаблонаoperator() или для (C++14) полиморфного лямбды. Вот почему bind откладывает вывод своего типа результата до конечной попытки вызова.

можно получить необходимый тип std:: function для lambda с помощью derivation, decltype, variadic templates и нескольких признаков типа:

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

}

Я использую его в мой код вроде этого:

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

PS: В моем реальном случае я затем сохраняю этот объект std:: function и его аргументы внутри общих объектов ядра, которые я могу выполнить позже по требованию с помощью виртуальных функций.

не карринг уже реализовано с помощью std::bind?

auto sum = [](int a, int b){ return a+b; };
auto inc = std::bind( sum, _1, 1 );
assert( inc(1)==2 );

это может быть интересно для вас: https://gist.github.com/Manu343726/94769034179e2c846acc

это эксперимент, который я написал месяц назад. Цель состояла в том, чтобы создать функтор-подобный шаблон C++, который эмулирует частичные замыкания вызовов Haskell, т. е. автоматическое создание замыкания m-n споры, когда вы звоните с n аргументирует функцию с m параметры.

это один из примеров того, что этот эксперимент cappable делать:

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 использует некоторые черты типа, чтобы заботиться о различных типах сущностей функции, лямбды входят:

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

как вы можете видеть, я использую оператор запятой для синтаксиса mmimic Haskell, но вы можете изменить его на оператор вызова для достижения синтаксиса цели.

вы совершенно свободны делать все, что вы хотите с кодом (Проверьте лицензию).