C++ 如何获取函数中整数的模板参数包？

假设我想要一个函数，如：

void reset()
{
    (std::get</*pack of integers from 0 to 4*/>(someTuple).reset(), ...);
}

void reset（）
{
（std:：get（someTuple）.reset（），…）；
}

我使用了一个助手函数，如下所示：

template < size_t... Indexes >
void reset(std::integer_sequence<size_t, Indexes...>)
{
    (std::get<Indexes>(someTuple).reset(), ...);
}
void reset()
{
    reset(std::make_integer_sequence<size_t,5>{});
}

#include <utility>
#include <type_traits>
#include <tuple>

template <std::size_t N, class = std::make_index_sequence<N>>
struct iterate;

template <std::size_t N, std::size_t... Is>
struct iterate<N, std::index_sequence<Is...>> {
   template <class Lambda>
   void operator()(Lambda lambda) {
      lambda(std::integral_constant<std::size_t, Is>{}...);
   }
};

struct Foo {
   void reset() {}
};

void reset() {
   std::tuple<Foo, Foo, Foo> bar;
   iterate<std::tuple_size<decltype(bar)>::value>{}([&](auto... is) {
      (std::get<is>(bar).reset(), ...);
   });
}

int main() {
   reset();
}

模板
无效重置（标准：：整数\u序列）
{
（std:：get（someTuple）.reset（），…）；
}
无效重置（）
{
重置（std:：make_integer_sequence{}）；
}

但我能用一个函数实现这一点吗？这种尝试类似于：

template < size_t... Indexes >
void reset(std::integer_sequence<size_t, Indexes...> = std::make_integer_sequence<size_t,5>{})
{
    (std::get<Indexes>(someTuple).reset(), ...);
}

模板
无效重置（std:：integer\u sequence=std:：make\u integer\u sequence{}）
{
（std:：get（someTuple）.reset（），…）；
}

---

调用

reset（）

解析为

reset（std:：integer\u序列）

而不是

reset（std:：integer\u序列）

失败。我使用的是GCC-7.0.0的最新快照

您可以使用通用lambda和一些助手结构，如下所示：

template < size_t... Indexes >
void reset(std::integer_sequence<size_t, Indexes...>)
{
    (std::get<Indexes>(someTuple).reset(), ...);
}
void reset()
{
    reset(std::make_integer_sequence<size_t,5>{});
}

#include <utility>
#include <type_traits>
#include <tuple>

template <std::size_t N, class = std::make_index_sequence<N>>
struct iterate;

template <std::size_t N, std::size_t... Is>
struct iterate<N, std::index_sequence<Is...>> {
   template <class Lambda>
   void operator()(Lambda lambda) {
      lambda(std::integral_constant<std::size_t, Is>{}...);
   }
};

struct Foo {
   void reset() {}
};

void reset() {
   std::tuple<Foo, Foo, Foo> bar;
   iterate<std::tuple_size<decltype(bar)>::value>{}([&](auto... is) {
      (std::get<is>(bar).reset(), ...);
   });
}

int main() {
   reset();
}

#包括
#包括
#包括
模板
结构迭代；
模板
结构迭代{
模板
void运算符（）（Lambda Lambda）{
lambda（std：：积分常数{}；
}
};
结构Foo{
void reset（）{}
};
无效重置（）{
std：：元组条；
迭代{}（[&]（自动…是）{
（std:：get（bar）.reset（），…）；
});
}
int main（）{
重置（）；
}

使用默认的模板参数，您可以实现如下功能：

template <class S = std::make_index_sequence<5>>
struct reset; // intentionally undefined

template <size_t... Is>
struct reset<std::index_sequence<Is...>> {
    template <class Tuple>
    static void impl(Tuple& t) {
        (std::get<Is>(t).reset(), ...);
    }
};

reset<>::impl(someTuple);

模板
结构重置；//故意未定义
模板
结构重置{
模板
静态void impl（元组和t）{
（std:：get（t）.reset（），…）；
}
};
reset：：impl（someTuple）；

但不是在函数中（因为这样做需要函数模板的部分专门化，而这种语言不支持）

相反，只需为内联参数包解包创建一个助手lambda：

void reset() {
    indexer<5>()([&](auto I){
        std::get<I>(someTuple).reset();
    });
}

void reset（）{
索引器（）（[&]（自动I）{
std:：get（someTuple）.reset（）；
});
}

我想，你所拥有的就是前进的道路