C++ variadic Vorlage teilweise Spezialisierung für Nicht-Typ-Argumente

Question

Ich habe eine map_n Vorlage, die eine N-Arity-Funktion auf jeden Satz von Elementen aus N-Eingangstupel angewendet, um ein neues Ausgangstupel zu erzeugen. Alle Eingangstupel müssen gleich lang sein (was ich wahrscheinlich mit statischem Assert überprüfen sollte).

Der Code funktioniert korrekt, außer dass ich die Teilspezialisierung der Rekursionsterminierungsbedingung nicht generisch schreiben konnte, wie im folgenden Codeausschnitt gezeigt.

#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

Es ist viel einfacher als das, was Sie anstreben. Sie brauchen map_n_impl überhaupt nicht. Wenn wir uns an den funktionalen, rekursiven Ansatz halten, brauchen wir zwei Überladungen von map_n: eine für alle Tupel ist nicht leer und eine für alle Tupel ist leer. Wir werden Columbo verwenden bool_pack Trick, um herauszufinden, ob sie alle leer sind oder nicht:

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...>; 

Und dann benutzen Sie einfach das zu SFINAE die beiden disjunkten Bedingungen:

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...); 
} 

Beachten Sie, dass tuple isn‘ t wirklich der beste Weg zu tun cons/car/cdr in C++ - es ist nicht sehr cdr -fähig. Geeigneter wäre verschachtelt pair s.

Sie könnten auch die ganze tuple auf einmal mit dem Index-Sequenz-Trick aufgebaut werden. Es ist ein wenig nervig hier, weil wir zwei Parameterpakete anders auspacken müssen, daher das extra call Lambda. Es gibt möglicherweise einen besseren Weg, dies zu tun:

template <size_t... Is, class F, class... Ts> 
auto map_n_impl(std::index_sequence<Is...>, const F& f, const Ts&... ts) { 
    auto call = [&](auto idx){ 
     return f(std::get<idx>(ts)...); 
    }; 

    return std::make_tuple(
     call(std::integral_constant<size_t, Is>{})... 
     ); 
} 

template <class F, class T0, class... Ts> 
auto map_n(const F& f, const T0& t0, const Ts&... ts) { 
    return map_n_impl(
     std::make_index_sequence<std::tuple_size<T0>::value>{}, 
     f, 
     t0, 
     ts...); 
}