std:: forward_iterator

Este concepto refina std::input_iterator al requerir que I también modele std::incrementable (haciéndolo así adecuado para algoritmos multipase), y garantizando que dos iteradores del mismo rango puedan compararse entre sí.

Determinación del concepto de iterador

La definición de este concepto se especifica mediante una plantilla de alias solo para exposición /*ITER_CONCEPT*/ .

Para determinar /*ITER_CONCEPT*/ < I > , sea ITER_TRAITS < I > igual a I si la especialización std:: iterator_traits < I > está generada desde la plantilla principal, o std:: iterator_traits < I > en caso contrario:

• Si ITER_TRAITS < I > :: iterator_concept es válido y nombra un tipo, /*ITER_CONCEPT*/ < I > denota el tipo.
• En caso contrario, si ITER_TRAITS < I > :: iterator_category es válido y nombra un tipo, /*ITER_CONCEPT*/ < I > denota el tipo.
• En caso contrario, si std:: iterator_traits < I > se genera desde la plantilla principal, /*ITER_CONCEPT*/ < I > denota std::random_access_iterator_tag .
  (Es decir, std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: forward_iterator_tag > se asume que es true .)
• En caso contrario, /*ITER_CONCEPT*/ < I > no denota un tipo y resulta en un fallo de sustitución.

Requisitos semánticos

I modela std::forward_iterator si, y solo si I modela todos los conceptos que subsume, y dados objetos i y j de tipo I :

• Comparación entre iteradores i y j tiene un resultado definido si

• i y j son iteradores hacia la misma secuencia subyacente, o
• ambos i y j están inicializados por valor, en cuyo caso se comparan como iguales.

• Los punteros y referencias obtenidos de un iterador de avance en un rango permanecen válidos mientras exista el rango.
• Si i y j son desreferenciables, ofrecen la garantía multipase , es decir:

• i == j implica ++ i == ++ j , y
• ( ( void ) [ ] ( auto x ) { ++ x ; } ( i ) , * i ) es equivalente a * i .

Notas

A diferencia de los LegacyForwardIterator requirements, el concepto forward_iterator no requiere que la desreferenciación devuelva una referencia.

Ejemplo

Un iterador hacia adelante mínimo.

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

Véase también