index_sequence：C++参数包展开的“索引扳手”

写模板时，你有没有遇到过这种场景：
函数接收一个可变参数包（比如 template<typename... Ts> void foo(Ts&&... args)），但你想对每个参数做点“带编号”的事——比如把它们依次塞进数组、按位置构造 tuple、或者生成一组带下标的日志？
这时候光靠 sizeof...(args) 知道个总数没用，你缺的不是长度，是每个参数的“位置身份证”。
std::index_sequence 就是干这个的：它不存数据，只存一串编译期整数序列，像一把精准卡位的“索引扳手”。

index_sequence 本身是个空壳模板，定义极简：

template<std::size_t... Is>
struct index_sequence {};

它不提供任何成员函数，也不参与运行时逻辑。它的全部价值，在于被推导出来、被传递出去、被展开成实际下标。真正让它活起来的，是配套的 make_index_sequence<N> 和参数包展开的语法糖。

举个实在例子：把任意参数包转成 std::array。

template<typename... Ts>
auto to_array(Ts&&... args) {
    return std::array{std::forward<Ts>(args)...}; // C++17 能行，但类型必须一致
}

这只能处理同类型参数。如果想支持混合类型（比如 int, double, std::string），就得走 tuple 路线——但 std::tuple 构造本身不暴露索引。这时 index_sequence 就派上用场了：

template<typename... Ts>
auto to_tuple_with_index(Ts&&... args) {
    constexpr auto N = sizeof...(args);
    return to_tuple_impl(std::forward_as_tuple(args...),
                         std::make_index_sequence<N>{});
}

template<typename Tuple, std::size_t... Is>
auto to_tuple_impl(Tuple&& t, std::index_sequence<Is...>) {
    return std::make_tuple(std::get<Is>(std::forward<Tuple>(t))...);
}

注意这里的关键动作：std::make_index_sequence<N>{} 生成 index_sequence<0,1,2,...,N-1>，然后 Is... 在函数参数中被展开，直接变成一串编译期常量下标。std::get<Is> 于是能逐个提取 tuple 元素——整个过程零运行时开销，全在编译期完成。

有人会问：为什么不能直接写 std::get<0>(t), std::get<1>(t), ...？
因为 N 是模板参数，是未知数。你没法手写 N 个 std::get<I>。index_sequence 的本质，是把“循环展开”这件事，交给编译器去推导和实例化——它把运行时循环的思维，翻译成编译期递归+展开的语法契约。

再看一个更贴近工程的场景：转发调用并记录参数序号。

假设你封装了一个调试版 printf，希望每传一个参数，就自动打上 [0], [1] 这样的标记：

template<typename... Args>
void debug_print(const char* fmt, Args&&... args) {
    print_with_index(fmt, std::forward_as_tuple(args...),
                     std::make_index_sequence<sizeof...(args)>{});
}

template<typename Tuple, std::size_t... Is>
void print_with_index(const char* fmt, Tuple&& t, std::index_sequence<Is...>) {
    ((std::cout << "[" << Is << "]=" << std::get<Is>(std::forward<Tuple>(t)) << " "), ...);
    std::cout << "\n";
}

调用 debug_print("test", 42, 3.14, "hello")，输出就是：
[0]=42 [1]=3.14 [2]=hello

没有宏，没有字符串拼接，没有运行时分支判断——只有纯粹的编译期索引生成与折叠表达式配合。这就是 index_sequence 的轻量与锋利。

容易踩的坑也在这里：index_sequence 本身不可被“遍历”，也不能直接拿 Is 做算术（比如 Is + 1 会失败，因为 Is... 是包，不是单个值）。它只服务于展开上下文。
所以别试图写 for (auto i : seq)——它不是容器；也别在非展开位置用 Is，比如：

// ❌ 错误！Is 未被展开，编译不过
constexpr std::size_t first = Is; 

// ✅ 正确！在展开语境中，每个 Is 都是独立常量
std::array<int, sizeof...(Is)> a = { static_cast<int>(Is)... };

另一个隐性约束是：index_sequence 的长度必须是编译期常量。make_index_sequence<sizeof...(args)> 能用，是因为 sizeof... 是核心常量表达式；但 make_index_sequence<n> 中的 n 若来自变量或 constexpr 函数外的值，就会报错。

最后说点经验之谈：
当你发现模板里反复出现“我想按顺序处理参数，但又不想写 N 个重载或递归特化”，那 index_sequence 很可能就是你要找的杠杆支点。
它不炫技，不抽象，就干一件事：把“第几个”这个信息，从模糊的“参数包”里，硬生生抠出来，变成可操作的编译期数字。
就像修车时不用拧螺丝刀硬撬，而是换一把尺寸刚好匹配的套筒——index_sequence 就是 C++ 模板元编程里，最趁手的那一把套筒。

下次看到 std::make_index_sequence，别只当它是标准库里的一个配角。它背后站着的是整个编译期索引系统的信任状：位置可证，顺序可验，展开可控。