Question

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

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

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

这不适用于具有不同类型模板参数的容器。无法使用以下容器实例化该函数： 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）个总实例化“名称”的长度；可以使用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()返回一个std::tuple，其中所有类型都包含在所有Ts...类型的容器中（假设所有Ts...都是类型容器），但是如果您想要另一个返回值，容器，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>, "!" );

 }

模板包包

2 个答案: