std:: bidirectional_iterator

Das Konzept bidirectional_iterator verfeinert forward_iterator durch die Fähigkeit, einen Iterator rückwärts zu bewegen.

Iterator-Konzeptbestimmung

Die Definition dieses Konzepts wird über einen nur zur Darstellung dienenden Alias-Template /*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ärvorlage generiert wird, bezeichnet /*ITER_CONCEPT*/ < I > std::random_access_iterator_tag .
  (Das heißt, std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: bidirectional_iterator_tag > wird als true angenommen.)
• Andernfalls bezeichnet /*ITER_CONCEPT*/ < I > keinen Typ und führt zu einem Substitutionsfehler.

Semantische Anforderungen

Ein bidirektionaler Iterator r wird als dekrementierbar bezeichnet genau dann, wenn ein s existiert, so dass ++ s == r .

std :: bidirectional_iterator < I > wird nur dann modelliert, wenn alle Konzepte, die es subsumiert, modelliert sind, und gegeben zwei Objekte a und b vom Typ I :

• Wenn a dekrementierbar ist, gehört a zum Definitionsbereich der Ausdrücke -- a und a -- .
• Prädekrement liefert einen L-Wert, der auf den Operanden verweist: std:: addressof ( -- a ) == std:: addressof ( a ) .
• Postdekrement liefert den vorherigen Wert des Operanden: wenn bool ( a == b ) , dann bool ( a -- == b ) .
• Postdekrement und Prädekrement führen dieselbe Modifikation am Operanden durch: Wenn bool ( a == b ) , dann gilt nach Auswertung von sowohl a -- als auch -- b weiterhin bool ( a == b ) .
• Inkrement und Dekrement sind zueinander invers:

• Wenn a inkrementierbar ist und bool ( a == b ) , dann bool ( -- ( ++ a ) == b ) .
• Wenn a dekrementierbar ist und bool ( a == b ) , dann bool ( ++ ( -- a ) == b ) .

Gleichheitserhaltung

Ausdrücke, die in requires expressions der Standardbibliothek-Konzepte deklariert werden, müssen equality-preserving sein (sofern nicht anders angegeben).

Hinweise

Im Gegensatz zu den LegacyBidirectionalIterator -Anforderungen erfordert das bidirectional_iterator -Konzept nicht, dass die Dereferenzierung einen L-Wert zurückgibt.

Beispiel

Ein minimaler bidirektionaler Iterator.

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

` und `` Tags wurde gemäß den Anweisungen nicht übersetzt, da es sich um C++-Code handelt. Die HTML-Tags und Attribute wurden ebenfalls unverändert beibehalten.

Siehe auch