variadicテンプレートで入れ子になったパラメータパックを取る方法は？

Question

どのようにして、variadicテンプレートへのパラメータパックの各パラメータ自体がパラメータパックであることを表現できますか？

template <typename... TS> 
void use_tuple(std::tuple<TS...> arg0); 

template <typename... TS0, typename... TS1> 
void use_tuple(std::tuple<TS0...> arg0, std::tuple<TS1...> arg1); 

私はuse_tupleはタプルの任意の数を取ることができるようにしたい：

は、このコードを検討してください。今、私はこのようにそれを記述する必要があります。

template <typename... TS0, typename... REST> 
void use_tuple(std::tuple<TS0...> arg0, REST... rest); 

void use_tuple(); // Terminates the recursion. 

しかし、私はこのようにそれを書きたい：

// Each ELEMENT in PACK_OF_PACKS is a parameter pack. 
template <(typename...)... PACK_OF_PACKS> 
void use_tuple(std::tuple<PACK_OF_PACKS...>... args); 

これはさえ可能ですか？もしそうなら、どうですか？そうでない場合は、他に何ができますか？このコードの私の目標は、すべてのタプルに含まれるのタイプになることです。

私の究極の目標は、このようなものです：

template <typename...> void foo(); 

use_tuple(std::tuple<int, float, char>{}, 
      std::tuple<double, short, std::string>{}, 
      std::tuple<std::function<void()>, std::vector<int>>{}); 
// Results in a call to 
// foo<int, float, char, double, short, std::string, 
//  std::function<void()>, std::vector<int>>(); 

しかし、私は渡されたタプルの数や要素の数に依存しない間接の小型、定数数でこれを実装したいですそれぞれにだから再帰はありません。

Answer 1

そうでない場合は、他に何ができますか？

理由だけTuples...としてタプル自体を渡し、そのuse_tupleの本体で種類を抽出していませんか？

template <typename...> 
using example = int; 

template <typename... Ts> 
void foo(Ts...) { } 

template <typename... Tuples> 
void use_tuple(Tuples...) 
{ 
    foo(typename types<Tuples>::template apply<example>{}...); 
} 

あなたはヘルパーtypesクラスを持つ型を抽出することができます。このコードの

template <typename Tuple> 
struct types; 

template <typename... Ts> 
struct types<std::tuple<Ts...>> 
{ 
    template <template <typename...> class T> 
    using apply = T<Ts...>; 
}; 

live example on wandbox

Answer 2

私の目標は、すべてのタプルに含まれるタイプで取得することです。

すべてを一意のパックとして指定するかどうかはわかりません。 PACK_OF_PACKSは実際にそれを示唆している。この場合、std::tuple_catを使用することができます。この線に沿って
何か作業をする必要があります：

template<typename... T> 
void do_use_tuple(std::tuple<T...>) { 
    // T are the types you are looking for 
} 

template <typename... T> 
void use_tuple(T&&... tuple) { 
    return do_use_tuple(std::tuple_cat(std::forward<T>(tuple)...)); 
} 

あなたも値の転送に興味を持っていない場合は、単にdecltypeを使用すると、あなたは簡単にそれを得ることができます。

詳細はhereを参照してください。

---

あなたが一緒にパックすべてのパラメータを望んでいないと、一度にそれらを1つのタプルを探求したい場合は、代わりにこのような何かを行うことができます。

template<typename T> 
struct tag { using type = T; }; 

template<typename... T, typename F> 
void use_one(std::tuple<T...> &&, F f) { 
    F(tag<T>{}...); 
} 

template <typename... T> 
void use_tuple(T&&... tuple) { 
    int arr = { 0, 
     (use_one(std::forward<T>(tuple), [](auto... tag) { 
      // tag::type contains the types of each 
      // parameter of a tuple, a tuple at a time 
     }), 0)... 
    }; 
    (void)arr; 
} 

それは調整するのは簡単ですラムダと他の関数が関与している場合は、値にもアクセスします。

Answer 3

次のようなものがあると思います（C++ 17）。 私はを推奨しません。 1つは明らかにstd::tuple_catを好むべきです。

http://coliru.stacked-crooked.com/a/c64f2cb9a79af3e2

#include <array> 
#include <iostream> 
#include <tuple> 
#include <utility> 

//////////////////////////////////////////////////////////////////////////////// 

template<class... Ts> 
void foo() { 
    std::cout << __PRETTY_FUNCTION__ << std::endl; 
} 

//////////////////////////////////////////////////////////////////////////////// 

namespace detail { 

struct Index { 
    std::size_t outer{};// identify the tuple 
    std::size_t inner{};// identify the element in the tuple 
}; 

template<std::size_t... ns, class... Tuples> 
constexpr void use_tuple(std::index_sequence<ns...>, Tuples...) { 
    constexpr auto inds = [&]() { 
    std::array<Index, sizeof...(ns)> inds{}; 
    std::size_t n = 0; 

    for(std::size_t outer=0; outer<sizeof...(Tuples); ++outer) { 
     std::size_t size = std::begin({std::tuple_size<Tuples>::value...})[outer]; 
     for(std::size_t inner=0; inner<size; ++inner) inds[n++] = {outer, inner}; 
    } 

    return inds; 
    }(); 

    using TupleTuple = std::tuple<Tuples...>; 

    foo< 
    std::tuple_element_t< 
     inds[ns].inner, 
     std::tuple_element_t<inds[ns].outer, TupleTuple> 
    >... 
    >(); 
} 

}// detail 

template<class... Tuples> 
constexpr void use_tuple(Tuples... tuples) { 
    constexpr std::size_t N = (std::tuple_size<Tuples>{} + ...); 
    detail::use_tuple(std::make_index_sequence<N>{}, std::move(tuples)...); 
} 

//////////////////////////////////////////////////////////////////////////////// 

int main() { 
    std::tuple<int, unsigned, int> t0; 
    std::tuple<double, float> t1; 
    std::tuple<char, bool, bool, int> t2; 

    use_tuple(t0, t1, t2); 

    return 0; 
}