Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::iota_view
Member functions
Deduction guides
Nested classes
Iterator
Helper concepts
Member types
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
struct /*iterator*/ ;
(1) ( 仅用于说明* )
辅助别名模板
template < class I >
using /*iota-diff-t*/ = /* 见下文 */ ;
(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 > 。
  • 否则，若存在宽度大于 I 的有符号整数类型，则 /*iota-diff-t*/ < I > 为该类型。
  • 否则， I 为最宽整型类型之一，此时 /*iota-diff-t*/ < I > 为宽度不小于 I 的未指定 有符号整数式类型 。在此情况下，未指定 /*iota-diff-t*/ < I > 是否满足 weakly_incrementable 概念。
3) 指定类型为 incrementable ，且该类型的前置与后置 operator -- 具有通用语义。
4) 指定类型同时满足 可递减 与 全序 要求，且该类型与相异类型间的 operator + = 、 operator - = 、 operator + 及 operator - 运算符具有通用语义。

/*iterator*/ 模型

然而，仅当 W 满足 incrementable 概念时，它才满足 LegacyInputIterator 要求；否则不满足 LegacyInputIterator 要求。

目录

语义要求

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 ，

使得 b 可从 a 经过 n 次 ++ a 操作后到达，则以下所有条件均成立：

  • ( 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) (since C++20)
constexpr explicit /*iterator*/ ( W value ) ;
(2) (since 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 > ) ;
(since C++20)

返回 value_ 。

示例

运行此代码 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // 绑定临时对象
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

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

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (since C++20)
constexpr void operator ++ ( int ) ;
(2) (since C++20)
constexpr /*iterator*/ operator ++ ( int ) requires std:: incrementable < W > ;
(3) (since 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) (since C++20)
constexpr /*iterator*/ operator -- ( int ) requires /*decrementable*/ < W > ;
(2) (since 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 > ;
(since 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 > ;
(since 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 > ;
(since 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) (since C++20)
friend constexpr bool operator <

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

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

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

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

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

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

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

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

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

requires std:: totally_ordered < W > && std:: three_way_comparable < W > ;
(6) (since 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== 合成 。

这些函数对普通的 非限定 或 限定查找 不可见，仅当 iterator 是参数的关联类时，才能通过 实参依赖查找 找到。

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

friend constexpr /*iterator*/ operator +

( /*iterator*/ i, difference_type n )

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

( difference_type n, /*iterator*/ i )

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

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

这些函数对普通的 非限定查找 或 限定查找 不可见，仅当 iterator 作为参数的关联类时，通过 实参依赖查找 才能找到。

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

friend constexpr /*iterator*/ operator -

( /*iterator*/ i, difference_type n )

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

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

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

这些函数对普通的 无限定 或 有限定查找 不可见，只有当 iterator 是实参的关联类时，才能通过 实参依赖查找 找到。

缺陷报告

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

缺陷报告 适用范围 发布时行为 正确行为
P2259R1 C++20 成员 iterator_category 始终被定义 仅当 W 满足 incrementable 时定义
LWG 3580 C++20 operator + 和 operator - 的函数体排除了 隐式移动 调整为支持隐式移动