C++ 如何转换c+中忽略参数的函数+;11?
我正在寻找一个更优雅的代码来忽略不必要的参数。有点像是反向的std::bindC++ 如何转换c+中忽略参数的函数+;11?,c++,c++11,templates,lambda,c++14,C++,C++11,Templates,Lambda,C++14,我正在寻找一个更优雅的代码来忽略不必要的参数。有点像是反向的std::bind void doSomething(function<A(B)> callback); // Given function // Instead of void myDoSomething(function<A()> callback0) { doSomething([&](B b) { return callback0();
void doSomething(function<A(B)> callback); // Given function
// Instead of
void myDoSomething(function<A()> callback0) {
doSomething([&](B b) {
return callback0();
});
}
// I want
void myDoSomething(function<A()> callback0) {
doSomething(add_ignored_arg<B>(callback0));
}
void doSomething(函数回调);//给定函数
//而不是
void myDoSomething(函数回调0){
doSomething([&](B){
返回callback0();
});
}
//我想要
void myDoSomething(函数回调0){
doSomething(添加被忽略的参数(回调0));
}
选项#1
C++11基本解决方案,将忽略的参数注入第一个位置():
选项3
C++11高级解决方案,将被忽略的参数注入任何位置,并带有接受原始函数指针和std::function
wrappers()的额外重载:
测验
你有一个函数,它接受一个带参数的回调,你想用一个不接受参数的回调来调用这个函数吗?lambda?t.C.有什么问题吗?只有通过引用捕获
f
的“重”语法是个坏主意。
template <typename Arg, typename R, typename... Args>
std::function<R(Arg, Args...)> add_ignored_arg(std::function<R(Args...)> f)
{
return [f] (Arg&& /*arg*/, Args&&... args) { return f(std::forward<Args>(args)...); };
}
template <typename Arg, typename R, typename... Args>
std::function<R(Arg, Args...)> add_ignored_arg(std::function<R(Args...)> f)
{
return [f] (auto&& /*arg*/, auto&&... args) { return f(std::forward<decltype(args)>(args)...); };
}
template <std::size_t N, typename Arg, typename R, typename... Args, std::size_t... Before, std::size_t... After, typename Tuple = std::tuple<Args...>>
auto inject_param(index_sequence<Before...>, index_sequence<After...>)
-> std::function<R(typename std::tuple_element<Before, Tuple>::type..., Arg, typename std::tuple_element<N + After, Tuple>::type...)>;
template <std::size_t N, typename Arg, typename R, typename... Args, std::size_t... Before, std::size_t... After, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(std::function<R(Args...)> f, index_sequence<Before...>, index_sequence<After...>)
-> decltype(inject_param<N, Arg, R, Args...>(index_sequence<Before...>{}, index_sequence<After...>{}))
{
return [f] (typename std::tuple_element<Before, Tuple>::type&&... before
, Arg&& /*arg*/
, typename std::tuple_element<N + After, Tuple>::type&&... after)
{
return f(std::forward<typename std::tuple_element<Before, Tuple>::type>(before)...,
std::forward<typename std::tuple_element<N + After, Tuple>::type>(after)...);
};
}
template <std::size_t N, typename Arg, typename R, typename... Args, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(std::function<R(Args...)> f)
-> decltype(inject_param<N, Arg, R, Args...>(make_index_sequence<N>{}, make_index_sequence<sizeof...(Args) - N>{}))
{
return add_ignored_arg<N, Arg>(f, make_index_sequence<N>{}, make_index_sequence<sizeof...(Args) - N>{});
}
template <std::size_t N, typename Arg, typename R, typename... Args, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(R(*f)(Args...))
-> decltype(inject_param<N, Arg, R, Args...>(make_index_sequence<N>{}, make_index_sequence<sizeof...(Args) - N>{}))
{
return add_ignored_arg<N, Arg>(std::function<R(Args...)>(f), make_index_sequence<N>{}, make_index_sequence<sizeof...(Args) - N>{});
}
template <std::size_t N, typename Arg, typename R, typename... Args, std::size_t... Before, std::size_t... After, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(std::function<R(Args...)> f, std::index_sequence<Before...>, std::index_sequence<After...>)
-> std::function<R(typename std::tuple_element<Before, Tuple>::type..., Arg, typename std::tuple_element<N + After, Tuple>::type...)>
{
return [f] (auto&&... args)
{
auto t = std::forward_as_tuple(std::forward<decltype(args)>(args)...);
return f(static_cast<typename std::tuple_element<Before, decltype(t)>::type>(std::get<Before>(t))...,
static_cast<typename std::tuple_element<N + After + 1, decltype(t)>::type>(std::get<N + After + 1>(t))...);
};
}
template <std::size_t N, typename Arg, typename R, typename... Args, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(std::function<R(Args...)> f)
{
return add_ignored_arg<N, Arg>(f, std::make_index_sequence<N>{}, std::make_index_sequence<sizeof...(Args) - N>{});
}
template <std::size_t N, typename Arg, typename R, typename... Args, typename Tuple = std::tuple<Args...>>
auto add_ignored_arg(R(*f)(Args...))
{
return add_ignored_arg<N, Arg>(std::function<R(Args...)>(f), std::make_index_sequence<N>{}, std::make_index_sequence<sizeof...(Args) - N>{});
}
struct B {};
void foo(int i, char c, double d)
{
std::cout << i << " " << c << " " << d << std::endl;
}
void doSomething(std::function<void(int, char, B, double)> callback)
{
callback(123, 'A', B{}, 3.14f);
}
void myDoSomething(std::function<void(int, char, double)> callback)
{
doSomething(add_ignored_arg<2, B>(callback));
}
int main()
{
myDoSomething(&foo);
}
123 A 3.14