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

В общем, вы не можете решить это без строгого ограничения, что бы вы ни передавали 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 { /* ... */ }
};

C ++ 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 это стирание типа объект. Вы печатаете erase, потому что хотите использовать тип там, куда не хотите переносить тип. Вывод из типа, какой тип результирующего объекта стирания типа вы должны создать, почти всегда является неправильным ответом, потому что у вас есть вся зависимость не типизированных стертых случаев и вся неэффективность стирания типа.

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