std:: forward_iterator

Ce concept affine std::input_iterator en exigeant que I modélise également std::incrementable (le rendant ainsi adapté aux algorithmes multi-pass), et garantit que deux itérateurs sur la même plage peuvent être comparés l'un à l'autre.

Détermination du concept d'itérateur

La définition de ce concept est spécifiée via un alias template d'exposition uniquement /*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 désigne un type, /*ITER_CONCEPT*/ < I > dénote ce type.
• Sinon, si ITER_TRAITS < I > :: iterator_category est valide et désigne 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:: forward_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

I modélise std::forward_iterator si, et seulement si I modélise tous les concepts qu'il subsume, et étant donné des objets i et j de type I :

• Comparaison entre les itérateurs i et j a un résultat défini si

• i et j sont des itérateurs vers la même séquence sous-jacente, ou
• les deux i et j sont initialisés par valeur, auquel cas ils se comparent égaux.

• Les pointeurs et références obtenus à partir d'un itérateur avant dans une plage restent valides tant que la plage existe.
• Si i et j sont déréférençables, ils offrent la garantie multi-pass , c'est-à-dire :

• i == j implique ++ i == ++ j , et
• ( ( void ) [ ] ( auto x ) { ++ x ; } ( i ) , * i ) est équivalent à * i .

Notes

Contrairement aux LegacyForwardIterator exigences, le concept forward_iterator ne requiert pas que le déréférencement retourne une référence.

Exemple

Un itérateur avant minimum.

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

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Voir aussi