std::integer_sequence

在标头 `<utility>` 定义
template< class T, T... Ints > class integer_sequence;		(C++14 起)

类模板 std::integer_sequence 表示一个编译时的整数序列。在用作函数模板的实参时，能推导参数包 Ints 并将它用于包展开。

模板形参

T	-	用于序列元素的整数类型
...Ints	-	表示序列的非类型形参包

成员类型

成员类型	定义
`value_type`	`T`

成员函数

size

[静态]

返回 Ints 中的元素数
(公开静态成员函数)

std::integer_sequence::size

static constexpr std::size_t size() noexcept;

返回 Ints 中的元素数。等价于 sizeof...(Ints)。

参数

（无）

返回值

Ints 中的元素数。

辅助模板

针对 T 为 std::size_t 的常用情况，定义辅助别名模板 std::index_sequence。

template< std::size_t... Ints > using index_sequence = std::integer_sequence<std::size_t, Ints...>;

分别定义辅助别名模板 std::make_integer_sequence 与 std::make_index_sequence，用于简化以 0, 1, 2, ..., N - 1 为 Ints 创建 std::integer_sequence 与 std::index_sequence 类型：

template< class T, T N > using make_integer_sequence = std::integer_sequence<T, /* 序列 0, 1, 2, ..., N-1 */>;
template< std::size_t N > using make_index_sequence = std::make_integer_sequence<std::size_t, N>;

若 N 为负则程序非良构。若 N 为零，则指示类型为 integer_sequence<T>。

定义辅助别名模板 std::index_sequence_for，以将任何类型形参包转换为同长度的索引序列：

template< class... T > using index_sequence_for = std::make_index_sequence<sizeof...(T)>;

注解

功能特性测试宏	值	标准	功能特性
`__cpp_lib_integer_sequence`	201304L	(C++14)	编译期整数序列

示例

另见 std::apply 中可能的实现作为另一个例子。

运行此代码

#include <array>
#include <cstddef>
#include <iostream>
#include <tuple>
#include <utility>
 
namespace details {
template <typename Array, std::size_t... I>
constexpr auto array_to_tuple_impl(const Array& a, std::index_sequence<I...>)
{
    return std::make_tuple(a[I]...);
}
 
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple_impl(std::basic_ostream<Ch, Tr>& os,
                      const Tuple& t,
                      std::index_sequence<Is...>)
{
    ((os << (Is ? ", " : "") << std::get<Is>(t)), ...);
}
}
 
template <typename T, T... ints>
void print_sequence(int id, std::integer_sequence<T, ints...> int_seq)
{
    std::cout << id << ") 大小为 " << int_seq.size() << " 的序列: ";
    ((std::cout << ints << ' '), ...);
    std::cout << '\n';
}
 
template <typename T, std::size_t N, typename Indx = std::make_index_sequence<N>>
constexpr auto array_to_tuple(const std::array<T, N>& a)
{
    return details::array_to_tuple_impl(a, Indx{});
}
 
template <class Ch, class Tr, class... Args>
auto& operator<<(std::basic_ostream<Ch, Tr>& os, const std::tuple<Args...>& t)
{
    os << '(';
    details::print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
    return os << ')';
}
 
int main()
{
    print_sequence(1, std::integer_sequence<unsigned, 9, 2, 5, 1, 9, 1, 6>{});
    print_sequence(2, std::make_integer_sequence<int, 12>{});
    print_sequence(3, std::make_index_sequence<10>{});
    print_sequence(4, std::index_sequence_for<std::ios, float, signed>{});
 
    constexpr std::array<int, 4> array{1, 2, 3, 4};
 
    auto tuple1 = array_to_tuple(array);
    static_assert(std::is_same_v<decltype(tuple1),
                                 std::tuple<int, int, int, int>>, "");
    std::cout << "5) tuple1: " << tuple1 << '\n';
 
    constexpr auto tuple2 = array_to_tuple<int, 4,
        std::integer_sequence<std::size_t, 1, 0, 3, 2>>(array);
    std::cout << "6) tuple2: " << tuple2 << '\n';
}

输出：

1) 大小为 7 的序列: 9 2 5 1 9 1 6 
2) 大小为 12 的序列: 0 1 2 3 4 5 6 7 8 9 10 11 
3) 大小为 10 的序列: 0 1 2 3 4 5 6 7 8 9 
4) 大小为 3 的序列: 0 1 2 
5) tuple1: (1, 2, 3, 4)
6) tuple2: (2, 1, 4, 3)

参阅

to_array (C++20)	从内建数组创建 `std::array` 对象 (函数模板)
integral_constantbool_constant (C++11)(C++17)	具有指定值的指定类型的编译期常量 (类模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库