我有一个map_n
模板,它将N-arity函数应用于来自N个输入元组的每组元素,以产生新的输出元组。所有输入元组必须具有相同的长度(我应该用静态断言检查)。
代码正常工作,除了我无法以通用方式编写递归终止条件部分特化,如下面的代码片段所示。
#include <tuple>
#include <cassert>
namespace impl {
// car, cdr, cons implementation
//
template<unsigned... XS>
struct sequence {
template<unsigned X>
using cons = sequence<X, XS...>;
};
template<unsigned start, unsigned end>
struct range {
static_assert(start < end, "Range: start > end");
using type = typename range<start + 1, end>::type::template cons<start>;
};
template<unsigned start>
struct range<start, start> {
using type = sequence<>;
};
template<typename T, unsigned... N>
auto select(const T& t, sequence<N...>) {
return std::make_tuple(std::get<N>(t)...);
}
} // end namespace impl
// car, cdr, cons
//
// empty list
//
constexpr const std::tuple<> empty;
// car
//
template<typename T>
auto car(const T& t) { return std::get<0>(t); }
// cdr
//
template<typename T, typename R = typename impl::range<1, std::tuple_size<T>::value>::type>
auto cdr(const T& t) {
return impl::select(t, R());
}
// cons
//
template<typename X, typename... XS>
auto cons(X x, const std::tuple<XS...>& t) {
return std::tuple_cat(std::make_tuple(x), t);
}
namespace impl {
// map_n implementation
template<typename F, typename... Ts>
struct map_n_impl {
static auto map(const F& f, const Ts&... t) {
return cons(
f(car(t)...),
map_n_impl<F, decltype(cdr(t))...>::map(f, cdr(t)...)
);
}
};
// NOTE: Need a more general specialization here
//
template<typename F>
struct map_n_impl<F, std::tuple<>, std::tuple<>> {
static std::tuple<> map(const F&, const std::tuple<>&, const std::tuple<>&)
{
return std::make_tuple();
}
};
} // end namespace impl
// map_n
//
template<typename F, typename... Ts>
auto map_n(const F& f, const Ts&... t) {
return impl::map_n_impl<F, Ts...>::map(f, t...);
}
int main(int, const char **) {
{
auto tup1 = std::make_tuple(1.0, 2.0, 3.0);
auto tup2 = std::make_tuple(0.0, 1.0, 2.0);
auto r = map_n([](auto x, auto y) { return x - y; }, tup1, tup2);
assert(std::get<0>(r) == 1.0);
assert(std::get<1>(r) == 1.0);
assert(std::get<2>(r) == 1.0);
}
// {
// auto tup1 = std::make_tuple(1.0, 2.0, 3.0);
// auto tup2 = std::make_tuple(0.0, 1.0, 2.0);
// auto tup3 = std::make_tuple(4.0, 5.0, 6.0);
// auto r = map_n([](auto x, auto y, auto z) { return x - y + z; }, tup1, tup2, tupe3);
// assert(std::get<0>(r) == 5.0);
// assert(std::get<1>(r) == 6.0);
// assert(std::get<2>(r) == 7.0);
// }
return 0;
}
答案 0 :(得分:1)
它比你想要的容易得多。你根本不需要map_n_impl
。如果我们要坚持功能性的递归方法 - 我们需要两个map_n
重载:一个用于所有元组都是非空的,一个用于所有元组都是空的。我们将使用Columbo的bool_pack
技巧来判断他们是否全部为空:
template <bool... >
struct bool_pack;
template <bool... b>
using all_true = std::is_same<bool_pack<true, b...>, bool_pack<b..., true>>;
template <class... T>
using all_empty = all_true<std::is_same<T, std::tuple<>>::value...>;
然后只是将它用于SFINAE两个不相交的条件:
template<typename F, typename... Ts,
std::enable_if_t<!all_empty<Ts...>::value, int*> = nullptr>
auto map_n(const F& f, const Ts&... t) {
return cons(
f(car(t)...),
map_n(f, cdr(t)...)
);
}
template<typename F, typename... Ts,
std::enable_if_t<all_empty<Ts...>::value, int*> = nullptr>
auto map_n(const F& , const Ts&... t) {
return std::make_tuple(t...);
}
请注意,tuple
并不是在C ++中cons
/ car
/ cdr
的最佳方式 - 它不是很{{} 1}} - 能。更合适的是嵌套cdr
s。
您还可以使用索引序列技巧一次性构建整个pair
。这里有点烦人,因为我们需要以不同的方式解压缩两个参数包,因此额外的tuple
lambda。可能有更好的方法:
call