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

< cpp‎ | ranges
 
C++
 
范围库
范围访问
范围原语
悬垂迭代器处理
范围概念
视图

半正则包装
工厂
iota_viewviews::iota
适配器
                              
 
template<std::weakly_incrementable W,

         std::semiregular Bound = std::unreachable_sentinel_t>
    requires __WeaklyEqualityComparableWith<W, Bound> && std::semiregular<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 起)
1) 以重复自增初值生成序列的范围工厂。能为有界和无界（无限）。
2) views::iota(E) 与 views::iota(E, F) 对于适合的 E 和 F 子表达式分别表达式等价于 iota_view{E} 与 iota_view{E, F} 。

表达式等价

表达式 e 表达式等价于表达式 f ，若 e 与 f 拥有相同效果，均为潜在抛出或均非潜在抛出（即 noexcept(e) == noexcept(f) ），且均为常量子表达式或均非常量子表达式。

辅助模板

template<std::weakly_incrementable W, std::semiregular Bound>
inline constexpr bool enable_borrowed_range<ranges::iota_view<W, Bound>> = true;

std::ranges::enable_borrowed_range 的此特化使得 iota_view 满足 borrowed_range 。

数据成员

std::ranges::iota_view::base_

W value_ = W(); /* exposition-only */

当前值

std::ranges::iota_view::pred_

Bound bound_ = Bound(); /* exposition-only */

边界（默认为 std::unreachable_sentinel_t ）

成员函数

std::ranges::iota_view::iota_view

iota_view() = default;
 (1)
constexpr explicit iota_view(W value);
 (2)
constexpr iota_view(std::type_identity_t<W> value,
                    std::type_identity_t<Bound> bound);
 (3)
1) 值初始化 value_ 与 bound_ 。
2) 以 value 初始化 value_ ，并期待 Bound 为 unreachable_sentinel_t （默认）或可从 value 达到的 Bound() 值。此构造函数用于创建无界 iota 视图，例如 iota(0) 产生数 0 、 1 、 2 ……无穷大。
3) 以 value 初始化 value_ 并以 bound 初始化 bound_ 。此构造函数用于创建有界 iota 视图，例如 iota(10, 20) 产生从 10 到 19 的数。

参数

value - 开始值
bound - 边界

std::ranges::iota_view::begin

constexpr iterator begin() const;

返回以 value_ 初始化的迭代器。

std::ranges::iota_view::end

constexpr auto end() const;
 (1)
constexpr iterator end() const requires std::same_as<W, Bound>;
 (2)
1) 若视图有界则返回以 bound_ 初始化的哨位，或若视图无界则返回 std::unreachable_sentinel 。
2) 返回以 bound_ 初始化的迭代器。

std::ranges::iota_view::size

constexpr auto size() const

  requires (std::same_as<W, Bound> && __Advanceable<W>) ||
           (std::integral<W> && std::integral<Bound>) ||
             std::sized_sentinel_for<Bound, W>
{
  if constexpr (__is_integer_like<W> && __is_integer_like<Bound>)
    return (value_ < 0)
      ? ((bound_ < 0)
        ? __make_unsigned_like(-value_) - __make_unsigned_like(-bound_)
        : __make_unsigned_like(bound_) + __make_unsigned_like(-value_))
      : __make_unsigned_like(bound_) - __make_unsigned_like(value_);
  else
    return __make_unsigned_like(bound_ - value_);

}

若视图有界则返回视图的大小。

推导指引

template<class W, class Bound>

    requires (!__is_integer_like<W> || !__is_integer_like<Bound> ||
              __is_signed_integer_like<W> == __is_signed_integer_like<Bound>)

  iota_view(W, Bound) -> iota_view<W, Bound>;

注意推导指引自身抵御有符号/无符号不匹配漏洞，如 views::iota(0, v.size()) ，其中 0 为（有符号） int 而 v.size() 为（无符号） std::size_t 。

嵌套类

std::ranges::iota_view::iterator

template<class W, class Bound>
struct iota_view<W, Bound>::iterator; /* exposition-only */

iota_view::begin 的返回类型。

它若 W 实现 __Advanceable 则此为 random_access_iterator ，若 W 实现 __Decrementable 则为 bidirectional_iterator ，若 W 实现 incrementable 则为 forward_iterator ，否则为 input_iterator 。然而它只是遗留输入迭代器 (LegacyInputIterator) 。

std::ranges::iota_view::iterator::iterator

constexpr explicit iterator(W value);

以 value 初始化仅用于阐释的数据成员 value_ 。此值将为 operator* 所返回并为 operator++ 所增加。

std::ranges::iota_view::iterator::operator*

constexpr W operator*() const noexcept(std::is_nothrow_copy_constructible_v<W>);

按值返回当前值（换言之，这是只读视图）。

std::ranges::iota_view::iterator::operator++

constexpr iterator& operator++()
 (1)
constexpr void operator++(int)
 (2)
constexpr iterator operator++(int) requires std::incrementable<W>;
 (3)
1) 等价于 ++value_; return *this; 。
2) 等价于 ++value_; 。
3) 等价于 auto tmp = *this; ++value_; return tmp; 。

std::ranges::iota_view::iterator::operator--

constexpr iterator& operator--() requires __Decrementable<W>;
 (1)
constexpr iterator operator--(int) requires __Decrementable<W>;
 (2)
1) 等价于 --value_; return *this; 。
2) 等价于 auto tmp = *this; --value_; return tmp; 。

std::ranges::iota_view::iterator::operator[]

constexpr W operator[](difference_type n) const requires __Advanceable<W>;

等价于 return W(value_ + n);

其他期待迭代器具有的成员。

std::ranges::iota_view::sentinel

template<class W, class Bound>
struct iota_view<W, Bound>::sentinel; /* exposition-only */

iota_view::end 的返回类型。

std::ranges::iota_view::sentinel::bound_

Bound bound_ = Bound(); /* exposition only */

仅用于阐释的数据成员保有哨位（通常对于有界 iota 视图为数，或对于无界 iota 视图为 std::unreachable_sentinel_t 的实例）。

std::ranges::iota_view::sentinel::sentinel

sentinel() = default;
constexpr explicit sentinel(Bound bound);

以 bound 初始化仅用于阐释的数据成员 bound_ 。

std::ranges::iota_view::sentinel::operator==

friend constexpr bool operator==(const iterator& x, const sentinel& y);

等价于 x.value_ == y.bound_; 。

std::ranges::iota_view::sentinel::operator-

friend constexpr std::iter_difference_t<W>

    operator-(const iterator& x, const sentinel& y)

    requires std::sized_sentinel_for<Bound, W>;
 (1)
friend constexpr std::iter_difference_t<W>

    operator-(const sentinel& x, const iterator& y)

    requires std::sized_sentinel_for<Bound, W>;
 (2)
1) 等价于 return x.value_ - y.bound_; 。
2) 等价于 return -(y.value_ - x.bound_); 。

示例

运行此代码
#include <ranges>
#include <iostream>
 
int main()
{
    for (int i : std::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) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';
}

输出： 

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