Namespaces
Variants

    std::ranges::views::iota, std::ranges::iota_view, std::ranges::views::indices

    来自 zh.cppreference.net
     
    C++
     
    范围库
    范围适配器
     
    std::ranges::iota_view
    成员函数
    推导指引
    嵌套类
    迭代器
    辅助概念
    成员类型
    成员函数
    非成员函数
    哨位
    成员函数
    非成员函数
     
    定义于头文件 <ranges> 
    template< std::weakly_incrementable W,
          std::semiregular Bound = std::unreachable_sentinel_t >
    requires /*weakly-equality-comparable-with*/<W, Bound> && std::copyable<W>
class iota_view
    : public ranges::view_interface<iota_view<W, Bound>>
    		(1) (C++20 起) 
    namespace views {
    inline constexpr /* unspecified */ iota = /* unspecified */;
}
    		(2) (C++20 起) 
    namespace views {
    inline constexpr /* unspecified */ indices = /* unspecified */;
}
    		(3) (C++26 起)
    调用签名
    		 
    template< class W >
    requires /* see below */
constexpr /* see below */ iota( W&& value );
    		(C++20 起) 
    template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ iota( W&& value, Bound&& bound );
    		(C++20 起) 
    template< class T >
    requires /*is-integer-like*/<T>
constexpr /* see below */ indices( T bound );
    		(C++26 起)
    1) 一种范围工厂，通过重复递增初始值来生成元素序列。可以是有界或无界（无限）的。
    2) views::iota(e) 和 views::iota(e, f) 分别对于任何合适的子表达式 表达式等价于 iota_view<std::decay_t<decltype((e))>>(e) 和 iota_view(e, f)e 和 f。
    3) 设 T 为 std::remove_cvref_t<decltype((e))>。若 views::indices(e) 为 ，则对于任何合适的子表达式 ，views::iota(T(0), e) 与 e/*is-integer-like*/<T>表达式等价true

    定制点对象

    名称 views::iota 表示一个 定制点对象 ，这是一个常量 函数对象 ，属于字面量 semiregular 类类型。详情请参阅 定制点对象 。

    数据成员

    成员 描述
    W value_ 起始值
    （仅用于阐述的成员对象*）
    Bound bound_ 哨兵值，可能无法到达
    （仅用于阐述的成员对象*）

    成员函数

    		创建 iota_view
    (公开成员函数)
    		获取 iota_view 的起始迭代器
    (公开成员函数)
    		获取表示 iota_view 末尾的哨兵
    (公开成员函数)
    		检查 iota_view 是否为空（即迭代器与哨兵比较相等）
    (公开成员函数)
    (optional)
    		获取 iota_view 的大小（仅在有限时提供）
    (公开成员函数)
    继承自 ranges::view_interface
    (C++23)
    		 返回指向范围起始的常量迭代器
    (的公开成员函数std::ranges::view_interface<D>)
    (C++23)
    		 返回范围常量迭代器的哨位
    (的公开成员函数std::ranges::view_interface<D>)
    		返回派生视图是否非空，仅当 ranges::empty 可应用于它时提供
    (的公开成员函数std::ranges::view_interface<D>)
    		返回派生视图中的首元素，仅当它满足 forward_range
    时提供 (的公开成员函数std::ranges::view_interface<D>)
    		返回派生视图中的末元素，仅当它满足 bidirectional_range 和 common_range
    时提供 (的公开成员函数std::ranges::view_interface<D>)
    		返回派生视图中的第 n个元素，仅当它满足 random_access_range
    时提供 (的公开成员函数std::ranges::view_interface<D>)

    推导指引

    嵌套类

    		迭代器类型
    ( 仅用于说明的成员类* )
    		当 iota_view 有界且 Bound 与 W 类型不同时使用的哨兵类型
    ( 仅用于说明的成员类* )

    辅助模板

    template < std:: weakly_incrementable W, std:: semiregular Bound >
    constexpr bool ranges:: enable_borrowed_range < ranges :: iota_view < W, Bound >> = true ;
    		(C++20 起)

    此 ranges:: enable_borrowed_range 的特化使 iota_view 满足 borrowed_range 要求。

    可能的实现

    另见 libstdc++ 中的实现。

    views::indices (3) 
    namespace views {
    inline constexpr auto indices = []</*is-integer-like*/ I>(I n)
    {
        return views::iota(I{}, n);
    };
}

    注意

    功能测试宏 值 标准 功能
    __cpp_lib_ranges_indices 202506L (C++26) ranges::views::indices

    示例

    运行此代码
    #include <algorithm>
#include <iostream>
#include <ranges>
    
struct Bound
{
    int bound;
    bool operator==(int x) const { return x == bound; }
};

int main()
{
    for (int i : std::ranges::iota_view{1, 10})
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, 10))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, Bound{10}))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';
    
    std::ranges::for_each(std::views::iota(1, 10),
                          [](int i){ std::cout << i << ' '; });
    std::cout << '\n';

#if __cpp_lib_ranges_indices
    constexpr int v[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

    // auto broken_indices = views::iota(0, std::ranges::size(v));
    //     does not compile due to types (int VS size_t) mismatch

    auto good_indices = std::views::indices(std::ranges::size(v));

    for (auto i : good_indices)
        std::cout << v[i] << ' ';
    std::cout << '\n';
#endif
}

    输出： 

    1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9

    缺陷报告

    下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

    缺陷报告 应用于 发布时的行为 正确行为
    LWG 4096 C++20 views::iota 可能按原样复制 iota_view 已禁止
    P2325R3 C++20 iota_view 要求 W 是 semiregular
    因为 view 要求 default_initializable     		仅要求 W 是 copyable

    参考文献

    • C++26 标准（ISO/IEC 14882:2026）：
    • 25.6.4 增量视图 [range.iota]
    • C++23 标准（ISO/IEC 14882:2024）：
    • 26.6.4 增量视图 [range.iota]
    • C++20 标准（ISO/IEC 14882:2020）：
    • 24.6.4 增量视图 [range.iota]

    参阅

    (C++11)
    		 以起始值的连续增量填充范围
    (函数模板 & 算法函数对象)
    (C++23)
    (C++23)
    		 以起始值的连续增量填充范围
    (算法函数对象)
    (C++23)
    		 一个视图，由重复生成相同值的序列构成
    (类模板) (定制点对象)
    (C++23)
    		 一个视图，将适配序列的每个元素映射为包含元素位置及其值的元组
    (类模板) (范围适配器对象)