基于C++标准草案n4659，前向迭代器的多遍遍历保证强度如何？

Great question! Let's break down how strong the multi-pass traversal guarantees are for forward iterators, using the definition from section [forward.iterators]/27.2.5 of the n4659 C++ standard draft.

First, let's recap the core requirements a type X must meet to qualify as a forward iterator:

• X must satisfy all input iterator requirements (section 27.2.3)
• X must be DefaultConstructible (section 20.5.3.1)
• For mutable forward iterators: the reference type is a non-const reference to T; for const forward iterators, reference is const T&
• All expressions listed in Table 97 of the standard must be valid and behave as specified

Now, the critical distinction that enables multi-pass traversal (compared to input iterators) is stable, independent iterator state. Here's what this guarantee entails in practice:

• You can create copies of a forward iterator, and each copy will traverse the same sequence starting from the exact same position, completely independently of other copies.
• Incrementing one iterator copy has no effect on the state of any other copies.
• Even after you've incremented an iterator to move forward in the sequence, you can still use an earlier copy of the iterator to revisit elements you've already passed (as long as the underlying sequence hasn't been modified in a way that invalidates iterators).
• Unlike input iterators, forward iterators guarantee that dereferencing an iterator multiple times (without modifying the sequence or incrementing it) will return the same value each time.

To put this in context: input iterators are strictly single-pass—once you increment an input iterator, copies of its previous state are no longer guaranteed to be valid, and you can't reliably reuse them to retrace steps. Forward iterators eliminate this restriction, making them suitable for algorithms that require multiple passes over a sequence (like std::count followed by std::find, or recursive algorithms that need to backtrack using saved iterator positions).

The expressions in Table 97 reinforce this guarantee: they specify that equality comparisons between iterators remain valid even after increments, and that copying an iterator produces an equivalent, independent iterator that can be used to traverse the sequence on its own.

Keep in mind: this stability only holds when the underlying sequence is not modified in iterator-invalidating ways (e.g., erasing elements from a std::vector while holding iterators to it). But the iterator itself guarantees stable, copyable state for multi-pass use when the sequence is intact.

内容的提问来源于stack exchange，提问作者Bruno