模板包包

Question

例如，我们有类型容器 Container1< Pack1...> , Container2< Pack2...> 等等 如果我们写：

template <template <typename... Pack>
          typename ...Containers,

          typename... Pack
          >
auto Concatinate(Container<Pack...>...)
    -> Container<Pack...>;

这不适用于不同类型模板的容器 arguments.That 是，无法使用这些容器实例化函数： Container1<Pack1...>、Container2<Pack2...>等 如Pack1... != Pack2...等

但我想要一个像这个这样的小函数，它可以将模板参数的类型组合到一个容器中。

有没有

typename ... ... PackOfPack

?

（类型容器表示元组的结构种类）

Answer 1

C++ 中没有 ... ... 可以满足您的需求。

您将不得不编写更复杂的元编程来实现配对。

template<class T0, class...Ts>
struct pack_concat;
template<class T0>
struct pack_concat<T0> { using type=T0; };

template<template<class...>class C0, template<class...>class C1, class...T0s, class...T1s, class Ts...>
struct pack_concat< C0<T0s...>, C1<T1s...>, Ts... >:
  pack_concat< C0<T0s..., T1s...>, Ts... >
{};

template<class T0, class...Ts>
using pack_concat_t = typename pack_concat<T0, Ts...>::type;

因此您的代码变为：

template<
  template<class...>class Container,
  class... Pack,
  class... Rest
>
auto Concatinate(Container<Pack...> c0, Rest...)
-> pack_concat_t< Container<Pack...>, Rest... >;

（请注意，这是 O(n^2) 总实例化 "name" 长度；O(n lg n) 的解决方案是可能的，但过于复杂。这就是我在说。）

Answer 2

使用 std::tuple_cat() 怎么样？

我的意思是...下面的内容怎么样？

template <template <typename ...> class Cnt, typename ... Ts>
std::tuple<Ts...> to_tuple (Cnt<Ts...>);

template <typename ... Ts>
auto concatinate (Ts ... ts)
   -> decltype ( std::tuple_cat(to_tuple(ts)...) );

前面的concatinate()return一个std::tuple所有类型都包含在所有Ts...类型容器中（假设所有Ts...都是类型容器）但是如果你想要另一个 return-container，from_tuple() 函数的构造（所以 -> decltype ( from_tuple(std::tuple_cat(to_tuple(ts)...)) );）是微不足道的

下面是一个完整的编译示例

#include <tuple>
#include <iostream>
#include <functional>

template <template <typename ...> class Cnt, typename ... Ts>
std::tuple<Ts...> to_tuple (Cnt<Ts...>);

template <typename ... Ts>
auto concatinate (Ts ... ts)
   -> decltype ( std::tuple_cat(to_tuple(ts)...) );


template <typename...> struct cnt1 { };
template <typename...> struct cnt2 { };
template <typename...> struct cnt3 { };

int main()
 {
   using pack1 = cnt1<int, long, long long>;
   using pack2 = cnt2<long, long long, long>;
   using pack3 = cnt3<long long, long, int>;

   using expected_tuple = std::tuple<int, long, long long,
                                     long, long long, long,
                                     long long, long, int>;

   using final_tuple = decltype(concatinate(std::declval<pack1>(),
                                            std::declval<pack2>(),
                                            std::declval<pack3>()));

   static_assert( std::is_same_v<expected_tuple, final_tuple>, "!" );

 }

模板包包

Template pack of pack

c++

containers

variadic-templates