std:: bidirectional_iterator

El concepto bidirectional_iterator refina forward_iterator añadiendo la capacidad de mover un iterador hacia atrás.

Determinación del concepto de iterador

La definición de este concepto se especifica mediante un alias de plantilla 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:: bidirectional_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

Un iterador bidireccional r se dice que es decrementable si y solo si existe algún s tal que ++ s == r .

std :: bidirectional_iterator < I > se modela solo si todos los conceptos que subsume están modelados, y dados dos objetos a y b de tipo I :

• Si a es decrementable, a está en el dominio de las expresiones -- a y a -- .
• El pre-decremento produce un lvalue que se refiere al operando: std:: addressof ( -- a ) == std:: addressof ( a ) .
• El post-decremento produce el valor anterior del operando: si bool ( a == b ) , entonces bool ( a -- == b ) .
• El post-decremento y el pre-decremento realizan la misma modificación en su operando: Si bool ( a == b ) , entonces después de evaluar tanto a -- como -- b , bool ( a == b ) aún se cumple.
• El incremento y el decremento son inversos entre sí:

• Si a es incrementable y bool ( a == b ) , entonces bool ( -- ( ++ a ) == b ) .
• Si a es decrementable y bool ( a == b ) , entonces bool ( ++ ( -- a ) == b ) .

Preservación de la igualdad

Las expresiones declaradas en las requires expressions de los conceptos de la biblioteca estándar deben ser equality-preserving (excepto cuando se indique lo contrario).

Notas

A diferencia de los LegacyBidirectionalIterator requirements, el concepto bidirectional_iterator no requiere que la desreferenciación devuelva un lvalue.

Ejemplo

Un iterador bidireccional mínimo.

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

Véase también