Шаблоны с переменными числами, вывод типов и std :: function

Функция не является std::function, она может быть преобразована в единицу. Однако вы можете вывести аргументы функции, исключая двусмысленность в отношении перегрузок.

#include <iostream>
#include <functional>

int foo(int bar)
{
  std::cout << bar << std::endl;
  return 0;
}

// Will cause error.
//int foo(double); 

template <typename Ret, typename... Args>
std::function<Ret (Args...)> func(Ret f(Args...))
{
  return f;
}

int main()
{
  auto bar = func(foo);
  bar (0); // prints 0
}

То, что вы хотите сделать с исходным std::function, похоже на это, что более очевидно не работает:

template<typename T>
struct A
{
  A(T);  
};

template<typename T>
void func(A<T> a);

int main()
{
    func(42);
}

42 не является A, хотя его можно преобразовать в один. Однако для преобразования его в единицу потребуется, чтобы T уже был известен.

Ваш код семантически эквивалентен (если он скомпилирован) этому:

int foo(int x){
    std::cout << x << std::endl;
    return x;
}

int main(){
    auto bar = [](int x){ return foo(x); };
    bar(0);
}

Не считая части return x, но это всего лишь я исправляю ваше неопределенное поведение.

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

Вы могли бы так же легко использовать конструктор std::functions без функции-оболочки.

Но все равно.

Чтобы сделать то, что вы хотите, вы должны передать сам указатель функции; без невозможного преобразования.

попробуй это:

int foo(int x){
    return x + 1;
}

template<typename Ret, typename ... Args>
auto func(Ret(*fp)(Args...)) -> std::function<Ret(Args...)>{
    return {fp};
}

int main(){
    auto bar = func(foo);
    std::cout << bar(0) << std::endl; // outputs '1'
}

Причина, по которой ваш код не работает, заключается в попытке неявного преобразования, когда вы передаете аргумент в func.

Как я уже сказал, ваш код в настоящее время семантически эквивалентен приведенному выше примеру с использованием лямбда-выражений. Я настоятельно рекомендую просто использовать лямбда-выражения везде, где требуется перенос функций! Они гораздо более гибкие и являются основной частью языка, а не функцией библиотеки.

Помните, что лямбда-выражения без захвата могут быть преобразованы в указатели на функции; так что следующее соответствует:

int main(){
    int(*bar)(int) = [](int x){ return x + 1; };
    std::cout << bar(0) << std::endl;
}

и чтобы иметь такую ​​же функциональность, как вы хотите в своем посте, мы могли бы написать что-то вроде этого:

int main(){
    auto func = +[](int x){ return x + 1; };

    std::cout << "foo(5) = " << func(5) << std::endl;

    func = [](int x){ return x * 2; };

    std::cout << "bar(5) = " << func(5) << std::endl;
}

Обратите внимание, что мы не возимся с объявлениями указателей функций или типами библиотек? Намного приятнее для всех читать / писать. В этом примере следует обратить внимание на унарный оператор +; чтобы выполнить преобразование в указатель на функцию перед присвоением его переменной. На самом деле он выглядит очень функциональным, чего, похоже, вы и пытаетесь достичь здесь.

Попробуйте развернуть функтор (лямбда и std :: function) через его operator():

#include <iostream>
#include <functional>

int foo(int bar)
{
    std::cout << bar << std::endl;
    return 0;
}

template<typename /*Fn*/>
struct function_maker;

template<typename RTy, typename... ATy>
struct function_maker<RTy(ATy...)>
{
    template<typename T>
    static std::function<RTy(ATy...)> make_function(T&& fn)
    {
        return std::function<RTy(ATy...)>(std::forward<T>(fn));
    }
};

template<typename /*Fn*/>
struct unwrap;

template<typename CTy, typename RTy, typename... ATy>
struct unwrap<RTy(CTy::*)(ATy...) const>
    : function_maker<RTy(ATy...)> { };

template<typename CTy, typename RTy, typename... ATy>
struct unwrap<RTy(CTy::*)(ATy...)>
    : function_maker<RTy(ATy...)> { };

template<typename T>
auto func(T f)
    -> decltype(unwrap<decltype(&T::operator())>::make_function(std::declval<T>()))
{
    return unwrap<decltype(&T::operator())>::make_function(std::forward<T>(f));
}

int main()
{
    //auto barp = func(foo); // compilation error
    auto bar = func(std::function<void(int)>(foo));

    auto bar2 = func([](int)
    {
        // ...
    });

    bar(0); // prints 0
}

Демо