C++ 将元组及其索引范围打包

我想知道是否有一种方法可以将元组与其索引范围打包（可能使用）。基本上，我想要实现的是

template <typename... Us, std::size_t... Idx>
void func(??? arg_pack) {
  // std::get<Idx>(std::move(arg_pack.args))...
}

模板
无效函数（？arg_pack）{
//std:：get（std:：move（arg_pack.args））。。。
}

以下内容不起作用，但表明了我的意图

template <typename... Us, std::size_t... Idx>
struct arg_pack {
  std::tuple<Us...> args;
  std::index_sequence<Idx...> idx;
};

模板
结构参数包{
std：：元组参数；
std:：index_序列idx；
};

更新：

---

这是我实际采用的解决方案。希望这能更清楚地说明我的意图。

双变量列表通常存在一个问题：变量参数末尾只能有一个变量

template <typename... Us, std::size_t... Idx>
struct arg_pack {
  std::tuple<Us...> args;
  std::index_sequence<Idx...> idx;
};

我建议将索引列表打包成一种类型（通常的

std:：index\u序列

）并放在第一位

我是说，大概

template <typename...>
struct arg_pack;

template <std::size_t ... Is, typename ... Ts>
struct arg_pack<std::index_sequence<Is...>, Ts...>
 {
   static_assert( sizeof...(Is) == sizeof...(Ts) , "!" );

   std::tuple<Ts...>          args;
   std::index_sequence<Is...> idx;
 };

我还建议声明

declArgPack（）

函数的

make_arg\u pack（）

来创建从

Ts..

值列表开始的对象（而不是定义，以

std:：declval（）的方式）

template <typename ... Ts>
arg_pack<std::make_index_sequence<sizeof...(Ts)>, Ts...> declArgPack ();

下面是一个完整的工作示例

#include <tuple>
#include <type_traits>

template <typename...>
struct arg_pack;

template <std::size_t ... Is, typename ... Ts>
struct arg_pack<std::index_sequence<Is...>, Ts...>
 {
   static_assert( sizeof...(Is) == sizeof...(Ts) , "!" );

   std::tuple<Ts...>          args;
   std::index_sequence<Is...> idx;
 };

template <typename ... Ts>
arg_pack<std::make_index_sequence<sizeof...(Ts)>, Ts...> declArgPack ();

template <typename ... Ts>
using arg_pack_type = decltype(declArgPack<Ts...>());

template <std::size_t ... Is, typename ... Ts>
void func (arg_pack<std::index_sequence<Is...>, Ts...> && ap)
 {
   using unused = int[];

   (void)unused { 0, (std::get<Is>(std::move(ap.args)), 0)... };
 }

int main ()
 {
   arg_pack_type<short, int, long, long long>  ap0;

   func(std::move(ap0));
 }

#包括
#包括
模板
结构参数包；
模板
结构参数包
{
静态断言（sizeof…（Is）=sizeof…（Ts），“！”；
std：：元组参数；
std:：index_序列idx；
};
模板
arg_pack declArgPack（）；
模板
使用arg_pack_type=decltype（declArgPack（））；
模板
无效函数（参数包和ap）
{
使用unused=int[]；
（void）未使用的{0，（std:：get（std:：move（ap.args）），0）…}；
}
int main（）
{
参数包类型ap0；
func（std：：move（ap0））；
}
任何您不想要
模板结构arg_pack{Tuple args；std:：index_sequence idx；}？这种样式将支持所有元组类型，例如
std:：pair
和
std:：array
我将为
arg\u pack
@Lingxi定义一个宏：（？我已经开发了
declArgPack（）
简化
arg\u pack
的定义，避免使用宏。一般建议：如果可能，避免使用c风格的宏。@Lingxi-答案修改：引入
arg\u pack\u type
简化
declArgPack（）
的使用。希望这有帮助。实际上，我的目标是简化
func（）的声明
。设计的用例是将变量模板中的参数分组。也就是说，您可以将多个
arg\u pack
s传递给
func（）
类似
func（pack\u args（a，b，c），pack\u args（d），pack\u args（e，f））
。
#include <tuple>
#include <type_traits>

template <typename...>
struct arg_pack;

template <std::size_t ... Is, typename ... Ts>
struct arg_pack<std::index_sequence<Is...>, Ts...>
 {
   static_assert( sizeof...(Is) == sizeof...(Ts) , "!" );

   std::tuple<Ts...>          args;
   std::index_sequence<Is...> idx;
 };

template <typename ... Ts>
arg_pack<std::make_index_sequence<sizeof...(Ts)>, Ts...> declArgPack ();

template <typename ... Ts>
using arg_pack_type = decltype(declArgPack<Ts...>());

template <std::size_t ... Is, typename ... Ts>
void func (arg_pack<std::index_sequence<Is...>, Ts...> && ap)
 {
   using unused = int[];

   (void)unused { 0, (std::get<Is>(std::move(ap.args)), 0)... };
 }

int main ()
 {
   arg_pack_type<short, int, long, long long>  ap0;

   func(std::move(ap0));
 }