std::ranges::iota_view<W, Bound>::iterator
struct /*iterator*/; |
(1) | (C++20 起) |
辅助别名模板 |
||
template< class I > using /*iota-diff-t*/ = /* see below */; // 仅用于阐释 |
(2) | (C++20 起) |
辅助概念 |
||
template< class I > concept /*decrementable*/ = // 仅用于阐释 |
(3) | (C++20 起) |
template< class I > concept /*advanceable*/ = // 仅用于阐释 |
(4) | (C++20 起) |
iota-diff-t
计算迭代器类型和整数式类型的差类型。
- 若
W
不是整数类型,或若它是整数类型且 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
。
advanceable
指定类型为 decrementable
及 totally_ordered
,而且该类型与其差类型间的 operator+=、 operator-=、 operator+ 和 operator- 均拥有通常含义。语义要求
I
实现 decrementable
,仅若 I
满足 decrementable
且所有其所蕴含的概念均得到实现,并且给定相等的 I
类型对象 a
与 b
:
- 若
a
与b
在前与后 operator-- 的定义域内(即它们可自减),则以下均为 true :- std::addressof(--a) == std::addressof(a)、
- bool(a-- == b)、
- bool(((void)a--, a) == --b)、
- bool(++(--a) == b) 。
- 若
a
与b
在前与后 operator++ 的定义域内(即它们可自增),则 bool(--(++a) == b) 为 true 。
D
代表 /*iota-diff-t*/<I> 。类型 I
实现 advanceable
仅若 I
满足 advanceable
且所有其所蕴含均得到实现,并且给定
-
I
类型对象a
与b
及 -
D
类型值n
,
使得 b
可在 n
次应用 ++a 后从 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
|
若 W 实现 advanceable 则为 std::random_access_iterator_tag 。否则若 W 实现 decrementable 则为 std::bidirectional_iterator_tag 。否则若 W 实现 incrementable 则为 std::forward_iterator_tag 。否则为 std::input_iterator_tag 。 |
iterator_category
|
若 W 实现 incrementable 则为 std::input_iterator_tag 。否则无成员类型 iterator_category 。
|
value_type
|
W
|
difference_type
|
/*iota-diff-t*/<W> |
注意: /*iterator*/ 是
-
random_access_iterator
,若 W 实现advanceable
, -
bidirectional_iterator
,若 W 实现decrementable
, -
forward_iterator
,若 W 实现incrementable
, - 否则为
input_iterator
。
然而,若 W
实现 incrementable
则它仅满足老式输入迭代器 (LegacyInputIterator) ,否则不满足老式输入迭代器 (LegacyInputIterator) 。
数据成员
此迭代器类型的典型实现仅保有一个 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 起) |
value_
。value
初始化仅用于阐释的数据成员 value_
。此值将由 operator* 返回,并为 operator++ 所自增。
std::ranges::iota_view::iterator::operator*
constexpr W operator*() const noexcept(std::is_nothrow_copy_constructible_v<W>); |
(C++20 起) | |
按值返回当前值(换言之,这是只读视图)。
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 起) |
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 起) |
std::ranges::iota_view::iterator::operator+=
constexpr /*iterator*/& operator+=( difference_type n ) requires /*advanceable*/<W>; |
(C++20 起) | |
若 W
为无符号整式,则在 n
非负时进行 value_ += static_cast<W>(n) ,否则进行 value -= static_cast<W>(-n) ,然后返回 *this 。
否则等价于 value_ += n; return *this; 。
std::ranges::iota_view::iterator::operator-=
constexpr /*iterator*/& operator-=( difference_type n ) requires /*advanceable*/<W>; |
(C++20 起) | |
若 W
为无符号整式,则在 n
非负时进行 value_ -= static_cast<W>(n) ,否则进行 value += static_cast<W>(-n) ,然后返回 *this 。
否则等价于 value_ -= n; return *this; 。
std::ranges::iota_view::iterator::operator[]
constexpr W operator[]( difference_type n ) const requires /*advanceable*/<W>; |
(C++20 起) | |
等价于 return W(value_ + n); 。
非成员函数
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 起) |
!=
运算符从 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 ) |
(2) | (C++20 起) |
D
为 difference_type
。
- 若
W
为有符号整数式,等价于 return D(D(x.value_) - D(y.value_)); 。 - 否则若
W
为无符号整数式,等价于 return y.value_ > x.value_ ? D(-D(y.value_ - x.value_)) : D(x.value_ - y.value_); 。 - 否则等价于 return x.value_ - y.value_; 。
缺陷报告
下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。
DR | 应用于 | 出版时的行为 | 正确行为 |
---|---|---|---|
P2259R1 | C++20 | 始终定义成员 iterator_category
|
仅若 W 满足 incrementable 才定义
|
LWG 3580 | C++20 | operator+ 与 operator- 复制迭代器
|
使之移动迭代器 |