C++11: Как написать функцию-оболочку для создания объектов `std::function`

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

//plain function pointers
template<typename... Args, typename ReturnType>
auto make_function(ReturnType(*p)(Args...))
    -> std::function<ReturnType(Args...)> 
{return {p};}

//nonconst member function pointers
template<typename... Args, typename ReturnType, typename ClassType>
auto make_function(ReturnType(ClassType::*p)(Args...)) 
    -> std::function<ReturnType(Args...)>
{return {p};}

//const member function pointers
template<typename... Args, typename ReturnType, typename ClassType>
auto make_function(ReturnType(ClassType::*p)(Args...) const) 
    -> std::function<ReturnType(Args...)>
{return {p};}

//qualified functionoids
template<typename FirstArg, typename... Args, class T>
auto make_function(T&& t) 
    -> std::function<decltype(t(std::declval<FirstArg>(), std::declval<Args>()...))(FirstArg, Args...)> 
{return {std::forward<T>(t)};}

//unqualified functionoids try to deduce the signature of `T::operator()` and use that.
template<class T>
auto make_function(T&& t) 
    -> decltype(make_function(&std::remove_reference<T>::type::operator())) 
{return {std::forward<T>(t)};}

Переменные:

int func(int x, int y, int z) { return x + y + z;}
int overloaded(char x, int y, int z) { return x + y + z;}
int overloaded(int x, int y, int z) { return x + y + z;}
struct functionoid {
    int operator()(int x, int y, int z) { return x + y + z;}
};
struct functionoid_overload {
    int operator()(int x, int y, int z) { return x + y + z;}
    int operator()(char x, int y, int z) { return x + y + z;}
};
int first = 0;
auto lambda = [](int x, int y, int z) { return x + y + z;};
auto lambda_state = [=](int x, int y, int z) { return x + y + z + first;};
auto bound = std::bind(func,_1,_2,_3);

Тесты:

std::function<int(int,int,int)> f0 = make_function(func); assert(f0(1,2,3)==6);
std::function<int(char,int,int)> f1 = make_function<char,int,int>(overloaded); assert(f1(1,2,3)==6);
std::function<int(int,int,int)> f2 = make_function<int,int,int>(overloaded); assert(f2(1,2,3)==6);
std::function<int(int,int,int)> f3 = make_function(lambda); assert(f3(1,2,3)==6);
std::function<int(int,int,int)> f4 = make_function(lambda_state); assert(f4(1,2,3)==6);
std::function<int(int,int,int)> f5 = make_function<int,int,int>(bound); assert(f5(1,2,3)==6);
std::function<int(int,int,int)> f6 = make_function(functionoid{}); assert(f6(1,2,3)==6);
std::function<int(int,int,int)> f7 = make_function<int,int,int>(functionoid_overload{}); assert(f7(1,2,3)==6);
std::function<int(char,int,int)> f8 = make_function<char,int,int>(functionoid_overload{}); assert(f8(1,2,3)==6);

http://coliru.stacked-crooked.com/a/a9e0ad2a2da0bf1f lambda была успешной, потому что она была неявно преобразована в указатель функции, потому что ваш пример не фиксирует никакого состояния. Обратите внимание, что моему коду требуются типы параметров для перегруженных функций, функционоидов с перегруженным оператором() (включая привязку), но теперь он может вывести все неперегруженные функционоиды.

Строки decltype сложны, но они используются для вывода типов возвращаемых значений. Обратите внимание, что ни в ОДНОМ из моих тестов мне не нужно указывать тип возвращаемого значения. Давайте разложим make_function<short,int,int> так, как если бы T было char(*)(short, int, int):

-> decltype(t(std::declval<FirstArg>(), std::declval<Args>()...))(FirstArg, Args...)
`std::declval<FirstArg>()` is `short{}` (roughly)
-> decltype(t(short{}, std::declval<Args>()...))(FirstArg, Args...)
`std::declval<Args>()...` are `int{}, int{}` (roughly)
-> decltype(t(short{}, int{}, int{})(FirstArg, Args...)
`t(short{}, int{}, int{})` is an `int{}` (roughly)
-> decltype(short{})(FirstArg, Args...)
`decltype(int{})` is `int`
-> int(FirstArg, Args...)
`FirstArg` is still `short`
-> int(short, Args...)
`Args...` are `int, int`
-> int(short, int, int)
So this complex expression merely figures out the function's signature
well, that should look familiar...

В общем, вы не можете решить эту проблему без строгого ограничения: все, что вы передаете make_function, может вызываться только с одной сигнатурой.

Что вы собираетесь делать с чем-то вроде:

struct Generic
{
    void operator()() { /* ... */ }
    void operator()() const { /* ... */ }

    template<typename T, typename... Ts>
    T operator()(T&& t, Ts&&...) { /* ... */ }

    template<typename T, typename... Ts>
    T operator()(T&& t, Ts&&...) const { /* ... */ }
};

Общие лямбда-выражения С++ 14 будут иметь ту же проблему.

Подпись в std::function основана на том, как вы планируете ее вызывать, а не на том, как вы ее создаете/назначаете.

Вы также не можете решить это для std::bind, так как оно имеет неопределенную арность:

void foo() { std::cout << "foo()" << std::endl; }
//...

auto f = std::bind(foo);
f();                 // writes "foo()"
f(1);                // writes "foo()"
f(1, 2, 3, 4, 5, 6); // writes "foo()"

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

Хороший способ решить эту проблему включает std::result_of.

Предположим, вы создаете структуру управления циклом, которая принимает лямбда-выражение или другой функционал. Если этот функционал возвращает void, вы хотите, чтобы цикл не контролировался. Если он возвращает bool или подобное, вы хотите зациклиться, пока он возвращает true. Если он возвращает enum ControlFlow, обратите внимание на возвращаемое значение ControlFlow (скажем, continue или break). Рассматриваемая функция принимает либо повторяющийся элемент, и, возможно, некоторые дополнительные данные (индекс в итерации, возможно, некоторую метаинформацию о «местоположении» об элементе и т. д.).

std::result_of позволит вам симулировать вызов переданного типа с другим количеством аргументов. Затем класс свойств может выяснить, какая из вышеперечисленных сигнатур является «наиболее подходящей», а затем направить к реализации, которая обрабатывает эту сигнатуру (возможно, обернув «более простые» случаи в лямбду и вызвав более сложные случаи).

Наивно, ваш make_function мог бы столкнуться с этой проблемой, потому что тогда вы могли бы просто перегрузить различные std::function< blah(etc) > случаи. Но с auto параметрами, поступающими по трубе, и std::bind уже выполняющими идеальную пересылку, это подходит только для самых простых случаев.

std::result_of классы свойств (и, возможно, связанные с ними сопоставление понятий и requires предложений) и диспетчеризация тегов (или SFINAE в крайнем случае).

Большим недостатком является то, что вам в конечном итоге придется управлять порядком переопределения самостоятельно в полуручном режиме. Я мог бы увидеть некоторую полезность во вспомогательных классах, где вы предоставляете список сигнатур для сопоставления, и он либо создает boost::variant, либо вы также создаете канонический вывод и метод преобразования в этот канонический вывод.

Короткий ответ? Реализация std::bind зависит от конкретной реализации, но она может включать в себя эквивалент идеальной пересылки пакетов переменных параметров и, как таковая, не подходит для вашего метода «получить адрес единственного конкретного operator()», который вы используете.

В качестве другого примера:

template <typename A,typename B> 
vector<B> map(std::function<B (A)> f, vector<A> arr) {
   vector<B> res;
   for (int i=0;i<arr.size();i++) res.push_back(f(arr[i]));
   return res;
}

следует писать так:

template<typename expression>
using result = typename std::result_of<expression>::type;
template<typename expression>
using decayed_result = typename std::decay<result<expression>>::type;

template <typename function,typename B> 
vector<decayed_result<function(B)>> map(function&& f, vector<A> const& arr) {
   vector<decayed_result<function(B)>> res;
   res.reserve( arr.size() );
   for (A const& a : arr) {
     res.push_back( f(a) );
   }
   return res;
}

опять же, result_of - правильное решение, а не преобразование без необходимости в std::function.

Для fold_right получаем:

template<bool b, typename T=void>
using EnableIf = typename std::enable_if<b,T>::type;

template<typename function, typename src, typename dest>
EnableIf<
  std::is_convertible< result<function(src, dest)>, dest >::value,
  std::vector<dest>
>
fold_right( function&& f, std::vector<src> const& v, dest initial )

который снова пропускает любое стирание типа на f. И если вы действительно хотите стереть тип на f, вы можете сделать:

template<typename T> struct identity { typedef T type; };
template<typename T> using do_not_deduce = typename identity<T>::type;

template<typename src, typename dest>
std::vector<dest> fold_right( do_not_deduce< std::function<dest(src,dest)> > f, std::vector<src> const& v, dest init );

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

Результат make_function зависит от полного типа источника, что делает вывод стирания типа почти полностью бесполезным.