命名空间
变体
操作

std::ranges::iota_view<W, Bound>::iterator

来自 cppreference.com
< cpp‎ | ranges‎ | iota view
 
C++
 
范围库
范围适配器
 
std::ranges::iota_view
成员函数
推断指南
嵌套类
迭代器
辅助概念
成员类型
成员函数
非成员函数
哨兵
成员函数
非成员函数
 
struct /*iterator*/;
 (1) ((仅供说明*)
辅助别名模板
template< class I >
using /*iota-diff-t*/ = /* see below */;
 (2) ((仅供说明*)
辅助概念
template< class I >

concept /*decrementable*/ =
    std::incrementable<I> && requires(I i) {
        { --i } -> std::same_as<I&>;
        { i-- } -> std::same_as<I>;

    };
 (3) ((仅供说明*)
template< class I >

concept /*advanceable*/ =
    /*decrementable*/<I> && std::totally_ordered<I> &&
    requires(I i, const I j, const /*iota-diff-t*/<I> n) {
        { i += n } -> std::same_as<I&>;
        { i -= n } -> std::same_as<I&>;
        I(j + n);
        I(n + j);
        I(j - n);
        { j - j } -> std::convertible_to</*iota-diff-t*/<I>>;

    };
 (4) ((仅供说明*)
1) ranges::iota_view<W, Bound>::iterator 是 ranges::iota_view<W, Bound> 的 begin() 和 end() 返回的迭代器的类型。
2) 计算两种迭代器类型和 整型 的差值类型。
  • 如果I不是一个整型，或者它是一个整型并且sizeof(std::iter_difference_t<I>)大于sizeof(I)，那么/*iota-diff-t*/<I>是std::iter_difference_t<I>.
  • 否则，/*iota-diff-t*/<I>是一个带符号整型，其宽度大于I的宽度（如果存在这样的类型）。
  • 否则，I是其中一个最宽的整型，/*iota-diff-t*/<I>是一个未指定 带符号整型，其宽度不小于I的宽度。是否/*iota-diff-t*/<I>在本例中模拟weakly_incrementable 是未指定的。
3) 指定一个类型是incrementable，并且该类型的预增和后增operator--具有共同的含义。
4) 指定一个类型既是decrementable又是totally_ordered，并且在该类型及其不同类型之间operator+=、operator-=、operator+和operator-具有共同的含义。

/*iterator*/ 模型

但是，它只有在W模型incrementable 时才满足LegacyInputIterator，否则不满足LegacyInputIterator。

内容

[edit] 语义要求

3) 类型I模型decrementable 仅当I满足decrementable 并且它包含的所有概念都已建模，以及给定类型I的相等对象a和b
  • 如果a和b同时在预减和后减operator--的域中（即它们是可以递减的），那么以下所有内容都是true
  • 如果a和b同时在预增和后增operator++的域中（即它们是可以递增的），那么bool(--(++a) == b)是true。
4) 令D表示/*iota-diff-t*/<I>。类型I模型advanceable 仅当I满足advanceable 并且它包含的所有概念都已建模，以及给定
  • 类型I的对象a和b以及
  • 类型D的值n,

使得在对++a进行n次应用后，可以从a到达b，所有以下条件都得到满足

  • (a += n)等于b.
  • std::addressof(a += n)等于std::addressof(a).
  • I(a + n)等于(a += n).
  • 对于类型D的任意两个正值x和y，如果I(a + D(x + y))定义良好，那么I(a + D(x + y))等于I(I(a + x) + y).
  • I(a + D(0))等于a.
  • 如果I(a + D(n - 1))定义良好，那么I(a + n)等于[](I c) { return ++c; }(I(a + D(n - 1))).
  • (b += -n)等于a.
  • (b -= n)等于a.
  • std::addressof(b -= n)等于std::addressof(b).
  • I(b - n)等于(b -= n).
  • D(b - a)等于n.
  • D(a - b) 等于 D(-n).
  • bool(a <= b) 为 true.

[编辑] 嵌套类型

类型 定义
iterator_concept 一个 迭代器标签，见下文
iterator_category
(仅当 W 符合 incrementable 且
/*iota-diff-t*/<W> 为一个整型类型) 		std::input_iterator_tag
value_type W
difference_type /*iota-diff-t*/<W>

[编辑] 确定迭代器概念

iterator_concept 定义如下

[编辑] 数据成员

成员 定义
W value_ 当前值
(仅供说明目的的成员对象*)

[编辑] 成员函数

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

/*iterator*/() requires std::default_initializable<W> = default;
 (1) (自 C++20)
constexpr explicit /*iterator*/( W value );
 (2) (自 C++20)
1) 按值初始化 value_。
2) 用 value 初始化 value_。

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

constexpr W operator*() const
    noexcept(std::is_nothrow_copy_constructible_v<W>);
 (自 C++20)

返回 value_.

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // binds with temporary
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

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

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

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

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

constexpr /*iterator*/& operator--() requires /*decrementable*/<W>;
 (1) (自 C++20)
constexpr /*iterator*/operator--(int) requires /*decrementable*/<W>;
 (2) (自 C++20)
1) 等价于 --value_ ; return *this;.
2) 等价于 auto tmp = *this; --value_ ; return tmp;.

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

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

constexpr /*iterator*/& operator+=( difference_type n )
    requires /*advanceable*/<W>;
 (自 C++20)

更新 value_ 并返回 *this

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

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

constexpr /*iterator*/& operator-=( difference_type n )
    requires /*advanceable*/<W>;
 (自 C++20)

更新 value_ 并返回 *this

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

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

constexpr W operator[]( difference_type n ) const
    requires /*advanceable*/<W>;
 (自 C++20)

返回 W(value_ + n).

示例

运行这段代码
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

[编辑] 非成员函数

operator==, <, >, <=, >=, <=>(std::ranges::iota_view::iterator)

friend constexpr bool operator==

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::equality_comparable<W>;
 (1) (自 C++20)
friend constexpr bool operator<

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::totally_ordered<W>;
 (2) (自 C++20)
friend constexpr bool operator>

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::totally_ordered<W>;
 (3) (自 C++20)
friend constexpr bool operator<=

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::totally_ordered<W>;
 (4) (自 C++20)
friend constexpr bool operator>=

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::totally_ordered<W>;
 (5) (自 C++20)
friend constexpr bool operator<=>

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires std::totally_ordered<W> && std::three_way_comparable<W>;
 (6) (自 C++20)
1) 返回 x.value_ == y.value_.
2) 返回 x.value_ < y.value_.
3) 返回 y < x.
4) 返回 !(y < x).
5) 返回 !(x < y).
6) 返回 x.value_ <=> y.value_.

!= 运算符从 operator== 合成。

这些函数对普通的 无限定查找 或 限定查找 不可見，只能通过 参数依赖查找 在迭代器是参数的关联类时被找到。

operator+(std::ranges::iota_view::iterator)

friend constexpr /*iterator*/ operator+

    ( /*iterator*/ i, difference_type n )

    requires /*advanceable*/<W>;
 (1) (自 C++20)
friend constexpr /*iterator*/ operator+

    ( difference_type n, /*iterator*/ i )

    requires /*advanceable*/<W>;
 (2) (自 C++20)

等价于 i += n; return i;.

这些函数对普通的 无限定查找 或 限定查找 不可見，只能通过 参数依赖查找 在迭代器是参数的关联类时被找到。

operator-(std::ranges::iota_view::iterator)

friend constexpr /*iterator*/ operator-

    ( /*iterator*/ i, difference_type n )

    requires /*advanceable*/<W>;
 (1) (自 C++20)
friend constexpr difference_type operator-

    ( const /*iterator*/& x, const /*iterator*/& y )

    requires /*advanceable*/<W>;
 (2) (自 C++20)
1) 等价于 i -= n; return i;.
2) 令 D 为 difference_type

这些函数对普通的 无限定查找 或 限定查找 不可見，只能通过 参数依赖查找 在迭代器是参数的关联类时被找到。

[编辑] 缺陷报告

以下行为更改缺陷报告被追溯地应用于之前发布的 C++ 标准。

DR 应用于 已发布的行为 正确行为
P2259R1 C++20 成员 iterator_category 始终被定义 仅在 W 满足 可递增 时被定义
LWG 3580 C++20 operator+ 和 operator- 的主体排除了 隐式移动 适合进行隐式移动
取自 "https://cppreference.cn/mwiki/index.php?title=cpp/ranges/iota_view/iterator&oldid=176931"