C++ 创建从可变模板包派生的类型的元组

给定作为可变模板参数包的大小值列表，如何根据参数包生成派生类型的元组（例如矩阵），从而使可变模板的第n个元素生成

矩阵

。例如：

make_matrix_tuple<2,3,4,5>() == make_tuple( Matrix<2,3>, Matrix<3,4>, Matrix<4,5> );

make_matrix_tuple（）==make_tuple（矩阵，矩阵，矩阵）；

如何编写包含大小为t的参数包的make_matrix_tuple函数？ 派生的类型不是指继承，而是指依赖（？）。我不确定正确的术语是什么。
解包参数包非常简单

template <typename ElementType, size_t... Sizes>
void make_tuple_of_vectors() { std::tuple < std::array<ElementType, Sizes> ... > tuple; }

模板
void make_tuple_of_vectors（）{std:：tupletuple；}

然而，我相信我有点不知所措，接下来的部分。 我尝试递归地从参数包中解包一对参数，如下所示：

template <typename Type, size_t size1, size_t size2>
struct dummy_matrix
{
    size_t SIZE1 = size1;
    size_t SIZE2 = size2;
    using type = Type;
};

template <size_t Iterator, typename ElementType, size_t T, size_t... Sizes>
struct unpack_two
{
    using type = typename unpack_two<Iterator - 1, ElementType, Sizes...>::type;
};

template<typename ElementType, size_t T, size_t T2, size_t... Sizes>
struct unpack_two<0, ElementType, T, T2, Sizes...>
{ 
    using type = dummy_matrix<ElementType, T, T2>;
};

模板
结构虚拟矩阵
{
尺寸=尺寸1；
尺寸2=尺寸2；
使用类型=类型；
};
模板
解包二
{
使用type=typename解包两个：：type；
};
模板
解包二
{ 
使用类型=虚拟矩阵；
};

因此

unpack_two:：type

给出第N个和（N+1）-N个矩阵类型。
有了这些，我被一些对我来说似乎合理的东西所困扰，然而编译器却强烈反对

template <size_t... Sizes, size_t... Is>
auto
foo_impl(std::index_sequence<Is...>) {
    std::tuple < unpack_two<Is, float, Sizes ... >::type ... > tuple; 
    return tuple; 
}
template <size_t... Args>
void foo()
{
    auto vs = foo_impl<Args...>(std::make_index_sequence<sizeof...(Args)-1>{});
}
int main() { foo<6,9,12>(); }

模板
汽车
foo_impl（std:：index_序列）{
std:：tupletuple；
返回元组；
}
模板
void foo（）
{
auto vs=foo_impl（std:：make_index_sequence{}）；
}
int main（）{foo（）；}

我正在尝试为解包两个模板解包

std:：size\u t

大小列表，然后为

std:：make\u tuple（）解包
std:：index\u序列
如果能解释一下我的尝试失败的原因，或者说
std:：index_sequence
工具是否正确，我将不胜感激。但我最感兴趣的是提出问题的任何解决方案

如何根据参数包生成派生类型（如矩阵）的元组，从而使变量的第n个元素生成
矩阵
[？]

可能在助手函数中使用
constepr
std:：array

一个例子

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

template <std::size_t, std::size_t>
struct Matrix
 { };

template <std::size_t ... Ds, std::size_t ... Is>
auto mmt_helper (std::index_sequence<Is...>)
 {
   constexpr std::array ca { Ds... };

   return std::make_tuple(Matrix<ca[Is], ca[Is+1u]>{}...);
 }

template <std::size_t ... Ds>
auto make_matrix_tuple ()
 { return mmt_helper<Ds...>(std::make_index_sequence<sizeof...(Ds)-1>{}); }

int main ()
 {
   auto mt = make_matrix_tuple<2,3,4,5>();

   using T1 = decltype(mt);
   using T2 = std::tuple<Matrix<2u, 3u>, Matrix<3u, 4u>, Matrix<4u, 5u>>;

   static_assert( std::is_same_v<T1, T2> );
 }

#包括
#包括
#包括
模板
结构矩阵
{ };
模板
自动mmt\U辅助程序（标准：：索引\U序列）
{
constexpr std:：数组ca{Ds…}；
返回std：：make_tuple（矩阵{}；
}
模板
自动生成矩阵元组（）
{返回mmt_helper（std:：make_index_sequence{}）；}
int main（）
{
自动mt=生成矩阵元组（）；
使用T1=decltype（mt）；
使用T2=std:：tuple；
静态断言（std:：is_same_v）；
}
接受，比我想做的要干净得多。是否可以调整它，以便获得创建的元组的类型？似乎非静态数据成员的类型不能包含auto。@MkjG Jup就是一个例子。@MkjG-您应该展示一个使用示例。。。无论如何
decltype（）
是你的朋友；您可以按照Timo的链接进行示例。