RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../utility/../iterator/forward_iterator.html below:

std::forward_iterator - cppreference.com

This concept refines std::input_iterator by requiring that I also model std::incrementable (thereby making it suitable for multi-pass algorithms), and guaranteeing that two iterators to the same range can be compared against each other.

[edit] Iterator concept determination

Definition of this concept is specified via an exposition-only alias template /*ITER_CONCEPT*/.

In order to determine /*ITER_CONCEPT*/, let ITER_TRAITS denote I if the specialization std::iterator_traits is generated from the primary template, or std::iterator_traits otherwise:

If ITER_TRAITS::iterator_concept is valid and names a type, /*ITER_CONCEPT*/ denotes the type.
Otherwise, if ITER_TRAITS::iterator_category is valid and names a type, /*ITER_CONCEPT*/ denotes the type.
Otherwise, if std::iterator_traits is generated from the primary template, /*ITER_CONCEPT*/ denotes std::random_access_iterator_tag.
(That is, std::derived_from</*ITER_CONCEPT*/, std::forward_iterator_tag> is assumed to be true.)
Otherwise, /*ITER_CONCEPT*/ does not denote a type and results in a substitution failure.

[edit] Semantic requirements

I models std::forward_iterator if, and only if I models all the concepts it subsumes, and given objects i and j of type I:

Comparison between iterators i and j has a defined result if

i and j are iterators to the same underlying sequence, or
both i and j are value-initialized, in which case they compare equal.

Pointers and references obtained from a forward iterator into a range remain valid while the range exists.
If i and j are dereferenceable, they offer the multi-pass guarantee, that is:

i == j implies ++i == ++j, and
((void)[](auto x){ ++x; }(i), *i) is equivalent to *i.

[edit] Notes

Unlike the LegacyForwardIterator requirements, the forward_iterator concept does not require dereference to return a reference.

[edit] Example

A minimum forward iterator.

#include <cstddef>
#include <iterator>
 
class SimpleForwardIterator
{
public:
    using difference_type = std::ptrdiff_t;
    using value_type = int;
 
    SimpleForwardIterator();
    SimpleForwardIterator(const SimpleForwardIterator&);
 
    SimpleForwardIterator& operator=(const SimpleForwardIterator&);
 
    int operator*() const;
 
    SimpleForwardIterator& operator++();
 
    SimpleForwardIterator operator++(int)
    {
        auto tmp = *this;
        ++*this;
        return tmp;
    }
 
    bool operator==(const SimpleForwardIterator&) const;
};
 
static_assert(std::forward_iterator<SimpleForwardIterator>);

[edit] See also specifies that a type is an input iterator, that is, its referenced values can be read and it can be both pre- and post-incremented
(concept) [edit] specifies that a forward_iterator is a bidirectional iterator, supporting movement backwards
(concept) [edit]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4