cpp/named req/ForwardIterator：修订间差异

来自cppreference.com
←上一编辑
Fruderica​（留言 | 贡献）
44,217次编辑
+
Xmcgcg​（留言 | 贡献）
11,121次编辑
无编辑摘要
 
（未显示7个用户的16个中间版本）
第2行： 第2行：
{{cpp/named req/navbar}}
{{cpp/named req/navbar}}


{{named req|ForwardIterator}} 是能从所指向元素读取数据的 {{named req|Iterator}} 。
{{named req|ForwardIterator}}是能从所指向元素读取数据的{{named req|Iterator}}。


不同于 {{named req|InputIterator}} 和 {{named req|OutputIterator}} ，它能被用于多趟算法。
{{named req|InputIterator}}和{{named req|OutputIterator}}，它被用于多趟算法
 
。


===要求===
===要求===
若达成下列条件，则类型 {{tt|It}} 满足 {{named req/core|ForwardIterator}}
{{}}
 
{{|}}
* 类型 {{tt|It}} 满足 {{named req|InputIterator}}
{{tt|}}|}}
* 类型 {{tt|It}} 满足{{named req|DefaultConstructible|可默认构造}}
{{|{{|}}{{tt|}} 的类型{{|std::iterator_traits<>::}}
* 类型 {{tt|It}} 的对象提供后述的''多趟保证''
{{tt|}}{{|}}
* 类型 {{tt|std::iterator_traits<It>::reference}} 必须恰为
{{|}}
:* 若 {{tt|It}} 满足 {{named req|OutputIterator}} （ {{tt|It}} 可变）则为 {{tt|T&}}
{{|{{|}}{{|}}{{tt|}} {{c|}} 类型
:* 否则为 {{tt|const T&}} （ {{tt|It}} 为常），
{{|c|}}{{tt|}} 类型}}
:（其中 {{tt|T}} 是 {{c|std::iterator_traits<It>::value_type}} 所指代的类型）
{{}}
* 在同一底层序列上的所有迭代器{{rev inl|since=c++14|和值初始化迭代器}}中定义等于和不等于比较。
 
而且，给定
* {{tt|i}} ，类型 {{tt|It}} 的可解引用迭代器
* {{tt|reference}} ， {{tt|std::iterator_traits<It>::reference}} 所指代的类型
 
则下列表达式必须合法且拥有其指定的效应


{|table class="wikitable"
{|table class="wikitable"
|-
|-
!表达式||返回类型||等价表达式||注意
!表达式
类型
|-
|-
|{{c|i++}}|| {{c|It}} || {{c|It ip{{=}}i; ++i; return ip;}} ||
|{{c|++}}
|{{c|}}
|{{c |= ;++;return ;}}
|-
|-
|{{c|*i++}}|| {{c|reference}} || ||  
|{{c|*i++}}
|{{|}}
|
|-
|-
|}
|}


可变向前迭代器 (''mutable'' {{named req/core|ForwardIterator}}) 是额外满足 {{named req|OutputIterator}} 要求的 {{named req/core|ForwardIterator}} 。
向前迭代器{{|}} {{|}}的
 
{{
/|
 
}}


===多趟保证===
===多趟保证===
给定 {{tt|a}} 和 {{tt|b}} ，类型 {{tt|It}} 的可解引用迭代器
{{|a}} 和
{{tt|}} 类型
{{|}}


* 若 {{tt|a}} 与 {{tt|b}} 比较相等（ {{ttb|1=a == b}} 可按语境转换为 {{tt|true}} ），则要么都是不可解引用，要么 {{tt|*a}} 与 {{tt|*b}} 是绑定到同一对象的引用
* 通过可变 {{tt|ForwardIterator}} 迭代器赋值不能非法化该迭代器（隐含地因为 {{tt|reference}} 定义为真引用）
* 自增 {{tt|a}} 的副本不改变从 {{tt|a}} 读取的值（正式而言，要么 {{tt|It}} 是无修饰指针类型，要么表达式 {{c|(void)++It(a), *a}} 等价于表达式 {{c|*a}} ）
* {{ttb|1=a == b}} 蕴含 {{ttb|1=++a == ++b}}


{{rrev|since=c++14|
{{rrev|since=c++20|
===孤立迭代器===
[[cpp/language/value_initialization|值初始化]]的 {{named req/core|ForwardIterator}} 表现类似某个未指定空容器的尾后迭代器：它与所有值初始化的同类型 {{named req/core|ForwardIterator}} 比较相等。
}}
{{rrev | since=c++20 |
===概念===
===概念===
为 {{lc|std::iterator_traits}} 的定义，定义以下仅为说明的概念：
为{{lc|std::iterator_traits}}，定义以下仅的概念：
 
{{dcl begin}}
{{dcl begin}}
{{dcl|1=
{{dcl|1=
template<class I>
template<class >
concept __LegacyForwardIterator<!-- 标准中称为 cpp17-forward-iterator --> =
concept __LegacyForwardIterator<!-- cpp17-forward-iterator --> =
  __LegacyInputIterator<I> && std::Constructible<I> &&
__LegacyInputIterator<> && std::<> &&
  std::is_lvalue_reference_v<std::iter_reference_t<I>> &&
std::<std::iter_reference_t<>> &&
  std::Same<std::remove_cvref_t<std::iter_reference_t<I>>, typename std::readable_traits<I>::value_type> &&
std::<
  requires(I i) {
std::remove_cvref_t<std::iter_reference_t<>>,
    {  i++ } -> const I&;
typename std::<>::value_type> &&
    { *i++ } -> std::Same<std::iter_reference_t<I>>;
requires() {
  };
{  ++ } -> const &;
{ *++ } -> std::<std::iter_reference_t<>>;
};
}}
}}
{{dcl end}}
{{dcl end}}


其中仅为说明的概念 {{tt|__LegacyInputIterator<T>}} 描述于 {{rlp|InputIterator#概念|LegacyInputIterator#概念}}。
其中仅的概念 {{tt|__LegacyInputIterator<T>}} 描述于 {{rlp|InputIterator#概念|LegacyInputIterator}}。
}}
}}


===参阅===
===参阅===
{{dsc begin}}
{{dsc begin}}
{{dsc inc | cpp/experimental/ranges/iterator/dsc ForwardIterator}}
{{dsc inc|cpp/iterator/dsc
}}
{{dsc end}}
{{dsc end}}
*[[cpp/iterator|迭代器库]]


{{langlinks|de|en|es|fr|it|ja|pt|ru}}
{{langlinks|de|en|es|fr|it|ja|pt|ru}}

2024年6月17日 (一) 09:26的最新版本


 
C++
 
C++ 具名要求
 

老式向前迭代器 (LegacyForwardIterator) 是能从所指向的元素读取数据的老式迭代器 (LegacyIterator) 。

与老式输入迭代器 (LegacyInputIterator) 和老式输出迭代器 (LegacyOutputIterator) 不同，它可被用于多趟算法。

如果某个老式向前迭代器 (LegacyForwardIterator) it 源自某个容器 (Container) ，那么 it 与该容器具有相同的值类型，因此解引用 (*it) 将获得该容器的值类型。

要求

类型 定义
X 向前迭代器类型
T X 的值类型（即 std::iterator_traits<X>::value_type）
Ref std::iterator_traits<X>::reference
值 定义
i, j X 或 const X 类型的值
r X& 类型的值

在满足以下所有条件时，X 是老式向前迭代器 (LegacyForwardIterator) ：

 表达式  类型 效果
r++ 可转换到 const X&  等价于 X x = r;
++r;
return x;。
*i++ Ref

相等性定义域

对于向前迭代器，== 的定义域是具有相同的底层序列的迭代器。

值初始化的向前迭代器也可以用来比较，而且必须与相同类型的其他值初始化的迭代器比较相等。

也就是说，值初始化的向前迭代器如同是指代相同的空序列的尾后位置的迭代器。

(C++14 起)

多趟保证

X 类型的两个可解引用的迭代器 a 和 b 在满足以下所有条件时提供多趟保证：

  • a == b 意味着 ++a == ++b。
  • 满足以下任意条件：
  • X 是指针类型。
  • 表达式 (void)++X(a), *a 等价于表达式 *a。


概念

为了定义 std::iterator_traits，定义了以下仅用于阐述的概念： 

template<class It>
concept __LegacyForwardIterator =
    __LegacyInputIterator<It> && std::constructible_from<It> &&
    std::is_reference_v<std::iter_reference_t<It>> &&
    std::same_as<
        std::remove_cvref_t<std::iter_reference_t<It>>,
        typename std::indirectly_readable_traits<It>::value_type> &&
    requires(It it) {
        {  it++ } -> std::convertible_to<const It&>;
        { *it++ } -> std::same_as<std::iter_reference_t<It>>;
    };

其中仅用于阐述的概念 __LegacyInputIterator<T> 描述于 LegacyInputIterator。

(C++20 起)

注解

与 std::forward_iterator 概念不同，老式向前迭代器 (LegacyForwardIterator) 要求解引用需要返回引用。

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 1212
(N3066) 		C++98 *i++ 的类型与老式双向迭代器 (LegacyBidirectionalIterator)
要求的 *i-- 的类型不匹配 		将类型改为 Ref
LWG 1311
(N3066) 		C++98 “a == b 意味着 ++a == ++b”不足以提供多趟保证[1] 也要求“a == b 意味着 ++a != b”[2]
LWG 3798 C++20 __LegacyForwardIterator 要求
std::iter_reference_t<It> 是左值引用类型 		也允许右值引用类型
  1. ↑ 例如在 a 和 b 使用相同的底层迭代器的情况下，对表达式 ++a == ++b 进行求值会将底层迭代器自增两次，但求值结果依然是 true。
  2. ↑ 正式而言也要求蕴含 ++b != a。

参阅

(C++20)
 指定 input_iterator 为向前迭代器，支持相等比较与多趟操作
(概念) [编辑]
迭代器库 提供迭代器的定义、迭代器表征、适配器和工具函数