Question

我有一个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;
}

Answer 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

C ++可变参数模板对非类型参数的部分特化

1 个答案: