Инициализирайте клас, съдържащ std::функция с ламбда

Добре, значи си мислех, че ще умра, но най-накрая успях да го направя ç_ç

Първо, използвах обичайните индекси. Тъй като нямам официалните, използвах стари индекси, които написах преди няколко месеца:

template<std::size_t...>
struct indices {};

template<std::size_t N, std::size_t... Ind>
struct make_indices:
    make_indices<N-1, N-1, Ind...>
{};

template<std::size_t... Ind>
struct make_indices<0, Ind...>:
    indices<Ind...>
{};

След това използвах някои функционални характеристики, намерени някъде в StackOverflow. Те са хубави и мисля, че са еквивалентни на библиотеката Boost, свързана в коментарите:

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

template<typename C, typename Ret, typename... Args>
struct function_traits<Ret(C::*)(Args...) const>
{
    enum { arity = sizeof...(Args) };

    using result_type = Ret;

    template<std::size_t N>
    using arg = typename std::tuple_element<N, std::tuple<Args...>>::type;
};

След това успях да напиша правилна функция make_foo и функция за нейното изпълнение, тъй като и двете трябва да използват индекси. Внимавайте, това е просто грозно:

template<typename Function, std::size_t... Ind>
auto make_foo_(Function&& func, indices<Ind...>)
    -> Foo<
        typename function_traits<typename std::remove_reference<Function>::type>::result_type,
        typename function_traits<typename std::remove_reference<Function>::type>::template arg<Ind>...>
{
    using Ret = typename function_traits<typename std::remove_reference<Function>::type>::result_type;
    return { std::function<Ret(typename function_traits<typename std::remove_reference<Function>::type>::template arg<Ind>...)>(func) };
}

template<typename Function, typename Indices=make_indices<function_traits<typename std::remove_reference<Function>::type>::arity>>
auto make_foo(Function&& func)
    -> decltype(make_foo_(std::forward<Function>(func), Indices()))
{
    return make_foo_(std::forward<Function>(func), Indices());
}

Кодът е някак грозен и нечетлив, но определено работи. Надяваме се, че сега не разчита на някакво поведение, дефинирано от внедряването. Освен това благодаря на всички за съветите, помогнаха! :)

int main()
{
    auto lambda = [](int i, float b, long c)
    {
        return long(i*10+b+c);
    };

    auto foo = make_foo(lambda);
    std::cout << foo(5, 5.0, 2) << std::endl; // 57, it works!
}

А ето и пример на живо :)

Имам пример, който работи с mutable ламбда. Не мога да разбера как да направя правилната квалификация на член на CV.

Първо, ето шаблона на функцията, който търсим:

#include <functional>

template <typename R, typename ...Args>
void foo(std::function<R(Args...)> f)
{ }

Сега ще оставим шаблон на функция bar да вземе произволна ламбда и да извика правилната версия на foo, като провери типа на operator() на ламбда:

#include <type_traits>

template <typename> struct remove_member;

template <typename C, typename T>
struct remove_member<T C::*>
{ using type = T; };

template <typename F>
void bar(F f)
{
    using ft = decltype(&F::operator());
    foo(std::function<typename remove_member<ft>::type>(f));
}

Пример:

int q;
bar([&](int a, int b) mutable -> int { q = a + b; return q / b; });

Можете да използвате нормални const ламбда с тази модифицирана характеристика, въпреки че не ми харесва да изписвам типа на функцията:

template <typename C, typename R, typename ...Args>
struct remove_member<R (C::*)(Args...) const>
{ using type = R(Args...); };

Мислех, че може да работи с оригиналния код, ако използвам typename std::remove_cv<T>::type, но поне на GCC това не работи поради някакъв странен __attribute__((const)), който е зададен на типа оператор на ламбда, който изглежда пречи на специализацията на шаблона.