Namespaces
Variants

std:: forward_iterator

From cppreference.net
C++
Iterator library
Iterator concepts
forward_iterator
(C++20)
(C++20)
(C++20)
(C++20)


Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Definiert im Header <iterator>
template < class I >

concept forward_iterator =
std:: input_iterator < I > &&
std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: forward_iterator_tag > &&
std:: incrementable < I > &&

std:: sentinel_for < I, I > ;
(seit C++20)

Dieses Konzept verfeinert std::input_iterator durch die Anforderung, dass I ebenfalls std::incrementable modelliert (wodurch es für Multi-Pass-Algorithmen geeignet wird), und gewährleistet, dass zwei Iteratoren desselben Bereichs miteinander verglichen werden können.

Inhaltsverzeichnis

Iterator-Konzeptbestimmung

Die Definition dieses Konzepts wird über eine nur zur Darstellung dienende Alias-Vorlage /*ITER_CONCEPT*/ spezifiziert.

Um /*ITER_CONCEPT*/ < I > zu bestimmen, sei ITER_TRAITS < I > definiert als I falls die Spezialisierung std:: iterator_traits < I > von der Primärvorlage generiert wird, andernfalls als std:: iterator_traits < I > :

  • Falls ITER_TRAITS < I > :: iterator_concept gültig ist und einen Typ benennt, bezeichnet /*ITER_CONCEPT*/ < I > diesen Typ.
  • Andernfalls, falls ITER_TRAITS < I > :: iterator_category gültig ist und einen Typ benennt, bezeichnet /*ITER_CONCEPT*/ < I > diesen Typ.
  • Andernfalls, falls std:: iterator_traits < I > von der primären Template-Spezialisierung generiert wird, bezeichnet /*ITER_CONCEPT*/ < I > std::random_access_iterator_tag .
    (Das heißt, std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: forward_iterator_tag > wird als true angenommen.)
  • Andernfalls bezeichnet /*ITER_CONCEPT*/ < I > keinen Typ und führt zu einem Substitutionsfehler.

Semantische Anforderungen

I modelliert std::forward_iterator genau dann, wenn I alle Konzepte modelliert, die es subsumiert, und für gegebene Objekte i und j vom Typ I :

  • Vergleich zwischen Iteratoren i und j hat ein definiertes Ergebnis, wenn
  • i und j sind Iteratoren auf dieselbe zugrundeliegende Sequenz, oder
  • sowohl i als auch j sind wertinitialisiert, in welchem Fall sie als gleich verglichen werden.
  • Zeiger und Referenzen, die von einem Forward-Iterator aus einem Bereich erhalten wurden, bleiben gültig, solange der Bereich existiert.
  • Wenn i und j dereferenzierbar sind, bieten sie die Multi-Pass-Garantie , das heißt:
  • i == j impliziert ++ i == ++ j , und
  • ( ( void ) [ ] ( auto x ) { ++ x ; } ( i ) , * i ) ist äquivalent zu * i .

Hinweise

Im Gegensatz zu den LegacyForwardIterator -Anforderungen erfordert das forward_iterator -Konzept nicht, dass die Dereferenzierung eine Referenz zurückgibt.

Beispiel

Ein minimaler 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>);

Siehe auch

(C++20)
spezifiziert, dass ein Typ ein Input-Iterator ist, d.h. seine referenzierten Werte können gelesen werden und er kann sowohl prä- als auch post-inkrementiert werden
(Konzept)
(C++20)
spezifiziert, dass ein forward_iterator ein bidirektionaler Iterator ist, der Rückwärtsbewegung unterstützt
(Konzept)