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

来自cppreference.com
< cpp‎ | ranges
template<std::weakly_incrementable W,

         std::semiregular Bound = std::unreachable_sentinel_t>
    requires __WeaklyEqualityComparableWith<W, Bound>

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) 对于适合的 EF 子表达式分别表达式等价iota_view{E}iota_view{E, F}

目录

[编辑] 表达式等价

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

[编辑] 数据成员

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_ ,并期待 Boundunreachable_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 为(有符号) intv.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

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>;

Equivalent to 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 <vector>
#include <iostream>
 
int main()
{
    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 << ' ';
}

输出:

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