如何解决在元组上通用化for_each以接受可变数量的参数
|| 目前,我有:template <unsigned I,unsigned N,typename Tuple,typename UnaryFunction>
struct for_;
template <unsigned N,typename UnaryFunction>
struct for_<N,N,Tuple,UnaryFunction> {
static
void call(const Tuple&,UnaryFunction) {}
};
template <unsigned I,typename UnaryFunction>
struct for_ {
static
void call(Tuple&& x,UnaryFunction f) {
f(get<I>(x));
for_<I + 1,UnaryFunction>::call(std::forward<Tuple>(x),f);
}
};
template <typename Tuple,typename UnaryFunction>
inline
void for_each(Tuple&& x,UnaryFunction f) {
for_<0,tuple_size<
typename std::remove_const<
typename std::remove_reference<Tuple>::type
>::type
>::value,f);
}
是否可以通过可变参数模板将其概括为采用任意数量的元组参数?
编辑:
这是我将无法使用的方式:
if (i != e) {
std::array<Tuple,2> x;
std::get<0>(x) = *i;
std::get<1>(x) = *i;
++i;
std::for_each (i,e,[&x](const Tuple& y) {
for_each(std::get<0>(x),y,assign_if(std::less));
for_each(std::get<1>(x),assign_if(std::greater));
});
}
编辑:更改为使用右值引用和std :: forward
解决方法
我不确定这是否是您的期望,但我会发布它-也许有人会觉得有用。
namespace std {
template<int I,class Tuple,typename F> struct for_each_impl {
static void for_each(const Tuple& t,F f) {
for_each_impl<I - 1,Tuple,F>::for_each(t,f);
f(get<I>(t));
}
};
template<class Tuple,typename F> struct for_each_impl<0,F> {
static void for_each(const Tuple& t,F f) {
f(get<0>(t));
}
};
template<class Tuple,typename F>
F for_each(const Tuple& t,F f) {
for_each_impl<tuple_size<Tuple>::value - 1,f);
return f;
}
}
函子:
struct call_tuple_item {
template<typename T>
void operator()(T a) {
std::cout << \"call_tuple_item: \" << a << std::endl;
}
};
主功能:
std::tuple<float,const char*> t1(3.14,\"helloworld\");
std::for_each(t1,call_tuple_item());
,您可以在此处查看我的答案以获取有关扩展元组的提示
如何将元组扩展为可变参数模板函数的参数?
,请参阅以下有关我将使用的map(UnaryFunction,Tuple&&...)
实现以及我一直在使用的代码,以使它完全按我的意愿工作(for_aux
,last
等)。
#include <array>
#include <iostream>
#include <tuple>
namespace detail {
struct static_ {
private:
static_() = delete;
static_(const static_&) = delete;
static_& operator=(const static_&) = delete;
};
template <unsigned... Args>
struct max;
template <unsigned Head,unsigned... Tail>
struct max<Head,Tail...>: private static_ {
static const unsigned value = Head > max<Tail...>::value
? Head
: max<Tail...>::value;
};
template <>
struct max<>: private static_ {
static const unsigned value = 0;
};
template <unsigned... Args>
struct min;
template <unsigned Head,unsigned... Tail>
struct min<Head,Tail...>: private static_ {
static const unsigned value = Head < min<Tail...>::value
? Head
: min<Tail...>::value;
};
template <>
struct min<>: private static_ {
static const unsigned value = 0;
};
template <typename... Args>
struct for_aux;
template <typename A,typename B>
struct for_aux<A,B>: private static_ {
static
void call(A&& a,B b) {
b(std::forward(a));
}
};
template <typename A,typename B,typename C>
struct for_aux<A,B,C>: private static_ {
static
void call(A&& a,B&& b,C c) {
c(std::forward(a),std::forward(b));
}
};
template <typename A,typename C,typename D>
struct for_aux<A,C,D>: private static_ {
static
void call(A&& a,C&& c,D d) {
d(std::forward(a),std::forward(b),std::forward(c));
}
};
// template <typename Head,typename... Tail>
// struct for_aux: private static_ {
// static
// void call(Tail&&... x,Head f) {
// f(std::forward(x)...);
// }
// };
template <typename... Args>
struct last;
template <typename X>
struct last<X>: private static_ {
typedef X type;
};
template <typename Head,typename... Tail>
struct last<Head,Tail...>: private static_ {
typedef typename last<Tail...>::type type;
};
template <unsigned I,unsigned N,typename UnaryFunction,typename... Tuples>
struct map;
template <unsigned N,typename... Tuples>
struct map<N,N,UnaryFunction,Tuples...>: private static_ {
static
void call(UnaryFunction,const Tuples&...) {}
};
template <unsigned I,typename... Tuples>
struct map: private static_ {
static
void call(UnaryFunction f,Tuples&&... x) {
f(std::get<I>(std::forward<Tuples>(x))...);
map<I + 1,Tuples...>::call(f,std::forward<Tuples>(x)...);
}
};
template <typename Tuple>
struct tuple_size: private static_ {
enum {
value = std::tuple_size<
typename std::remove_const<
typename std::remove_reference<Tuple>::type
>::type
>::value
};
};
}
template <typename UnaryFunction,typename... Tuples>
inline
void map(UnaryFunction f,Tuples&&... x) {
detail::map<0,detail::max<
detail::tuple_size<Tuples>::value...
>::value,Tuples...
>::call(f,std::forward<Tuples>(x)...);
}
using namespace std;
struct f {
template <typename T,typename U>
void operator()(const T& i,const U& j) {
cout << i << \" \" << j << endl;
}
};
int main() {
const array<int,2> x = {{2}};
const tuple<double,char> y(1.1,\'a\');
map(f(),x,y);
}
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。