std:: bidirectional_iterator

Le concept bidirectional_iterator affine forward_iterator en ajoutant la capacité de déplacer un itérateur vers l'arrière.

Détermination du concept d'itérateur

La définition de ce concept est spécifiée via un alias de modèle exposition-seulement /*ITER_CONCEPT*/ .

Afin de déterminer /*ITER_CONCEPT*/ < I > , soit ITER_TRAITS < I > dénotant I si la spécialisation std:: iterator_traits < I > est générée à partir du modèle primaire, ou std:: iterator_traits < I > sinon :

• Si ITER_TRAITS < I > :: iterator_concept est valide et nomme un type, /*ITER_CONCEPT*/ < I > dénote ce type.
• Sinon, si ITER_TRAITS < I > :: iterator_category est valide et nomme un type, /*ITER_CONCEPT*/ < I > dénote ce type.
• Sinon, si std:: iterator_traits < I > est généré à partir du modèle primaire, /*ITER_CONCEPT*/ < I > dénote std::random_access_iterator_tag .
  (C'est-à-dire que std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: bidirectional_iterator_tag > est supposé être true .)
• Sinon, /*ITER_CONCEPT*/ < I > ne dénote pas un type et entraîne un échec de substitution.

Exigences sémantiques

Un itérateur bidirectionnel r est dit décrémentable si et seulement s'il existe un certain s tel que ++ s == r .

std :: bidirectional_iterator < I > est modélisé seulement si tous les concepts qu'il subsume sont modélisés, et étant donné deux objets a et b de type I :

• Si a est décrémentable, a est dans le domaine des expressions -- a et a -- .
• Le pré-décrément produit une lvalue qui se réfère à l'opérande : std:: addressof ( -- a ) == std:: addressof ( a ) .
• Le post-décrément produit la valeur précédente de l'opérande : si bool ( a == b ) , alors bool ( a -- == b ) .
• Le post-décrément et le pré-décrément effectuent la même modification sur leur opérande : Si bool ( a == b ) , alors après l'évaluation de a -- et -- b , bool ( a == b ) reste vrai.
• L'incrémentation et la décrémentation sont inverses l'une de l'autre :

• Si a est incrémentable et bool ( a == b ) , alors bool ( -- ( ++ a ) == b ) .
• Si a est décrémentable et bool ( a == b ) , alors bool ( ++ ( -- a ) == b ) .

Préservation de l'égalité

Les expressions déclarées dans les requires expressions des concepts de la bibliothèque standard doivent être equality-preserving (sauf indication contraire).

Notes

Contrairement aux LegacyBidirectionalIterator exigences, le concept bidirectional_iterator ne requiert pas que le déréférencement retourne une lvalue.

Exemple

Un itérateur bidirectionnel minimum.

#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>);

Voir aussi