Espacios de nombres
Variantes

    Requisitos denominados de C++: IteradorDeAvanceLegado

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Requisitos denominados de C++
    Números aleatorios
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    Concurrencia
    (C++11)
    (C++11)
    (C++11)
    (C++14)
    (C++14)
    (C++11)
    (C++11)
    (C++17)
    (C++14)
    Rangos
    (C++20)
    (C++20)
    Vista multidimensional
    (C++23)
    (C++23)
    (C++23)
    Otros

     
    See More

    Un IteradorDeAvanceLegado es un IteradorLegado que puede leer datos del elemento al que se apunta.

    A diferencia de un IteradorDeEntradaLegado y un IteradorDeSalidaLegado, puede usarse en algoritmos de múltiples pasadas.

    Si un IteradorDeAvanceLegado it se origina a partir de un Contenedor, entonces el tipo de valor de it es el mismo que el del contenedor, por lo que al referenciar (*it) se obtiene el tipo de valor del contenedor.

    Requisitos

    Tipo Definición
    X Un tipo iterador de avance
    T El tipo valor de X (por ejemplo, std::iterator_traits<X>::value_type)
    Ref std::iterator_traits<X>::reference
    Valor Definición
    i, j Valores de tipo X o const X
    r Un valor de tipo X&

    X satisface a IteradorDeAvanceLegado si se satisfacen todas las condiciones siguientes:

    • X satisface a IteradorDeEntradaLegado.
    • X satisface a ConstruiblePorDefecto.
    • Si X es un iterador mutable, Ref es una referencia a T.
    • Si X es un iterador constante, Ref es una referencia a const T.
    • Objetos del tipo X proporcionan garantía de múltiples pasadas.
    • Si i y j son iguales, entonces i y j son ambos dereferenciables o ninguno de ellos los es.
    • Si i y j son desreferenciables, entonces i == j si y solo si *i y *j están enlazados al mismo objeto.
    • Las siguientes expresiones deben ser válidas y tener los efectos especificados:
     Expresión  Tipo Efectos
    r++ convertible a const X&  Equivalente a X x = r;
    ++r;
    return x;    .
    *i++ Ref

    Dominio de la igualdad

    El dominio de == para iteradores de avance es el de los iteradores sobre la misma secuencia subyacente.

    Sin embargo, los iteradores de avance inicializados por valor se pueden comparar, y deben compararse igual a otros iteradores inicializados por valor del mismo tipo.

    En otras palabra, los iteradores de avance inicializados por valor se comportan como si hicieran referencia más allá del final de la misma secuencia vacía.

    		(desde C++14)


    Garantía de múltiples pasadas

    Dos iteradores desreferenciables, a y b de tipo X ofrecen garantía de múltiples pasadas si se satisfacen todas las condiciones siguientes:

    • a == b implica ++a == ++b.
    • Cualquiera de las condiciones siguientes se satisface:
    • X es un tipo puntero.
    • La expresión (void)++X(a), *a es equivalente a la expresión *a.

    Concepto

    Para la definición de std::iterator_traits, se define el siguiente concepto solo para exposición.

    <tbody> </tbody>
    template<class It> concept __LegacyForwardIterator = __LegacyInputIterator<It> && std::constructible_from<It> && std::is_reference_v<std::iter_reference_t<It>> && std::same_as< std::remove_cvref_t<std::iter_reference_t<It>>, typename std::indirectly_readable_traits<It>::value_type> && requires(It it) { { it++ } -> std::convertible_to<const It&>; { *it++ } -> std::same_as<std::iter_reference_t<It>>; };

    donde el concepto solo para exposición __LegacyInputIterator<T> se describe en IteradorDeEntradaLegado.

    		(desde C++20)

    Notas

    Al contrario del concepto std::forward_iterator, los requisitos de IteradorDeAvanceLegado requieren una desreferencia para devolver una referencia.

    Informes de defectoss

    Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

    ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
    N3066 C++98 el tipo de *i++ no coincide con el tipo de
    *i-- requerido por IteradorBidireccionalLegado     		cambió el
    tipo a Ref
    N3066 C++98 “a == b implica ++a == ++b” por sí solo
    no ofrecía garantía multipaso[1]     		también se requiere “a == b
    implica ++a != b”[2]
    LWG 3798 C++20 se requiere que __LegacyForwardIterator std::iter_reference_t<It>
    sea un tipo de referencia a l-valor     		También se permiten
    tipos referencia a r-valor
    1. ↑ En el escenario donde a y b usan el mismo iterador subyacente, evaluar la expresión ++a == ++b incrementa el contenedor subyacente dos vece en realidad, pero el resultado sigue siendo true.
    2. ↑ Formalmente también requiere implicar ++b != a.

    Véase también

    (C++20)
    		 Especifica que un input_iterator es un iterador de avance, que admite la comparación de igualdad y múltiples pasadas.
    (concepto) [editar]
    Biblioteca de iteradores Proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de servicio.