Namespaces
Variants
Views
Actions

std::experimental::ranges::ForwardIterator

From cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals 2 TS)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Concepts (concepts TS)
Ranges (ranges TS)
Special mathematical functions (special math TR)
 
 
Iterators library
Iterator concepts
Indirect callable concepts
                                                  
                                                  
                                                  
Common algorithm requirements
                                                  
Concept utilities
Iterator utilities and operations
Iterator traits
Iterator adaptors
Stream iterators
 
template < class I >

concept bool ForwardIterator =
  ranges::InputIterator<I> &&
  ranges::DerivedFrom<ranges::iterator_category_t<I>, ranges::forward_iterator_tag> &&
  ranges::Incrementable<I> &&

  ranges::Sentinel<I, I>;
(ranges TS)

The concept ForwardIterator<I> refines InputIterator by adding equality comparison and the multi-pass guarantee.

The domain of == for forward iterators is that of iterators over the same underlying sequence, except that value-initialized iterators of the same type may be compared with each other and shall compare equal.

Pointers and references obtained from a forward iterator into a range [i, s) must remain valid while [i, s) continues to denote a range.

Let a and b be two deferenceable iterators of type I. ForwardIterator<I> is satisfied only if:

  • a == b implies ++a == ++b; and
  • The expression ([](X x){++x;}(a), *a) is equivalent to *a, i.e., incrementing a copy of a has no effect on the result of dereferencing a.

This is known as the multi-pass guarantee.

[edit] Notes

A forward iterator cannot be "stashing": it cannot return a reference to an object within itself, because such references would be invalidated by the destruction of the forward iterator.