C++ 如何从可变模板类包中的每个类型恢复非typename模板参数？

我试图从一组可变的模板类（其中每个类都有一个非类型参数）中恢复非typename模板参数，以便在另一种类型中将它们用作整数序列

下面的代码显示了我所拥有的。整数序列/成员序列是从元组中抄袭出来的

模板
结构大小\u t\u序列{
使用类型=大小\u t\u序列；
};
模板
结构推送大小推送序列；
模板
结构推送大小推送序列
：大小\u t\u序列{}；
模板
结构make\u size\u t\u序列
：push_size_t_sequence:：type{}；
模板
结构生成大小顺序：
push_size_t_序列：：类型{}；
模板
结构成员\u序列{
使用类型=成员\序列；
};
模板
结构推送\成员\序列；
模板
结构推送成员序列
：成员_序列{}；
模板
结构生成\成员\序列
：push_成员_序列：：type{}；
模板
结构生成\成员\序列：
push_成员_序列：：类型{}；
模板
结构解包\u序列\u impl；
模板
结构解包\u序列\u impl{
使用成员类型=成员序列；
使用大小\类型=大小\序列；
};
模板
结构解包\u序列：
解包\u序列\u impl{
使用base\u t=解包顺序\u impl；
使用member\u types=typename base\u t:：member\u types；
使用size\u types=typename base\u t:：size\u types；
};
模板
课例{
int s=N；
};
int main（）
{
auto mem_sequence=make_member_sequence:：type（）；
自动整数_序列=生成_大小_t_序列：：类型（）；
auto un_mem_sequence=解包_sequence:：member_types（）；
自动解包大小顺序=解包大小顺序：：大小类型（）；
}

mem\u序列

和

integer\u序列

的类型是

member\u序列

和

size\u序列

。

un_mem_sequence

和

un_size_sequence

的类型应该相同

我怎样才能做到这一点

谢谢你的帮助

提姆

编辑：

为了澄清，我试图完成的是从一个模板类恢复模板参数，以便在另一个模板类中使用它们。下面是三个模板类：

MyObject

，

MyTuple

，

MyPack

MyTuple

将

MyObject

对象作为其模板参数。我想恢复

MyObject

模板参数，用作

MyPack

对象的模板参数

模板
肌体；
模板
MyPack；
模板
MyTuple{}；
int main（）{
MyTuple a；
MyPack b；
}

所以我想从MyTuple中的MyObject中提取参数，用于创建MyPack

编辑2:

第二点澄清：

MyTuple

不仅仅接受

MyObject

类型，还接受任何具有一个int模板参数的类型

模板
肌体；
模板
肌对象2；
模板
MyPack；
模板
MyTuple{}；
int main（）{
MyTuple a；
MyPack b；
}

模板
结构MakeMyPack；
模板
结构MakeMyPack
{
使用类型=MyPack；
};

为了澄清，我试图完成的是从一个模板类恢复模板参数，以便在另一个模板类中使用它们。下面是三个模板类：MyObject、MyTuple和MyPack。MyTuple将MyObject对象作为其模板参数。我想恢复MyObject模板参数，用作MyPack对象的模板参数

为了好玩，我提出了一个更通用的解决方案，使用双变量模板（模板模板和值模板），不受

MyTuple

和

MyObject

template <typename>
struct getMyPack;

template <template <typename...> class C,
          template <int> class ... Cs, int ... Is>
struct getMyPack<C<Cs<Is>...>>
 { using type = MyPack<Is...>; };

模板
结构getMyPack；
模板
结构getMyPack
{使用type=MyPack；}；

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

#include <type_traits>

template <int>
struct MyObject1
 { };

template <int>
struct MyObject2
 { };

template <int...>
struct MyPack
 { };

template <typename...>
struct MyTuple
 { };

template <typename>
struct getMyPack;

template <template <typename...> class C,
          template <int> class ... Cs, int ... Is>
struct getMyPack<C<Cs<Is>...>>
 { using type = MyPack<Is...>; };


int main ()
 {
   using T0 = MyTuple<MyObject1<1>, MyObject2<2>, MyObject1<3>>;
   using T1 = MyPack<1, 2, 3>;
   using T2 = typename getMyPack<T0>::type;

   static_assert( std::is_same<T1, T2>::value, "!" );
 }

#包括
模板
结构MyObject1
{ };
模板
结构MyObject2
{ };
模板
结构MyPack
{ };
模板
结构MyTuple
{ };
模板
结构getMyPack；
模板
结构getMyPack
{使用type=MyPack；}；
int main（）
{
使用T0=MyTuple；
使用T1=MyPack；
使用T2=typename getMyPack:：type；
静态断言（std:：is_same:：value，“！”；
}

--编辑--

第二点澄清：MyTuple不仅接受MyObject类型，还接受任何具有int模板参数的类型

正如我所怀疑的那样

我的解决方案未绑定到

MyObject

，因此应该可以工作

---

前面的示例已修改以显示它。

对不起，我不明白您到底想要什么。请问，你能添加一些实际的例子吗？@max66我已经添加了我希望是一个澄清的编辑。谢谢！我现在意识到我的澄清遗漏了一个关键点。我可以有MyObject、MyObject2和MyObject3等。我想我可以用上面的unpack_sequence_impl之类的东西来解决这个问题。我把两个参数包作为模板参数，并通过将它们一起展开来推导它们，但这似乎不起作用。谢谢！这很有魅力。我没有想到将推导出的数据包包装到另一个数据包中，以启用推导。你帮我省去了很多挫折。

#include <type_traits>

template <int>
struct MyObject1
 { };

template <int>
struct MyObject2
 { };

template <int...>
struct MyPack
 { };

template <typename...>
struct MyTuple
 { };

template <typename>
struct getMyPack;

template <template <typename...> class C,
          template <int> class ... Cs, int ... Is>
struct getMyPack<C<Cs<Is>...>>
 { using type = MyPack<Is...>; };


int main ()
 {
   using T0 = MyTuple<MyObject1<1>, MyObject2<2>, MyObject1<3>>;
   using T1 = MyPack<1, 2, 3>;
   using T2 = typename getMyPack<T0>::type;

   static_assert( std::is_same<T1, T2>::value, "!" );
 }