Espacios de nombres
Variantes

    Requisitos denominados de C++: InputIterator

    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 IteradorDeEntradaLegado es un IteradorLegado que puede leer del elemento al que se apunta. Los IteradorDeEntradaLegado solamente garantizan la validez para algoritmos de una sola pasada: una vez que un IteradorDeEntradaLegado i se ha incrementado, todas las copias de su valor previo pueden haberse invalidado.

    Requisitos

    Tipo Definición
    X Un tipo iterador de entrada.
    T El value type de X (por ejemplo, std::iterator_traits<X>::value_type).
    R std::iterator_traits<X>::reference
    Valor Definición
    i, j Valores de tipo X o const X.
    r Un valor de tipo X&.
    Otros Definición
    m Un identificador que puede denotar un miembro de datos o una función miembro.

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

     Expresión  Tipo Semántica
    i != j
    un tipo que satisface ComprobableBooleano (hasta C++20)
    un tipo que modela comprobable-booleano (desde C++20)
    		 Precondición i y j están en el dominio de ==.
    Efecto Equivalente a !(i == j).
    *i R, convertible a T Precondición i es desreferenciable.
    Efecto
    • La expresión (void)*i, *i es equivalente a *i.
    • Si i y j están en el dominio de ==, y i == j, entonces *i es equivalente a *j.
    i->m Precondición i es desreferenciable.
    Efecto Equivalente a (*i).m.
    ++r X& Precondición r es desreferenciable.
    Poscondición 
    • r es desreferenciable o r está más allá del final.
    • Ya no se requiere que ninguna copia del valor anterior de r sea desreferenciable ni que esté en el dominio de ==.
    (void)r++ Efecto Equivalente a (void)++r.
    *r++ convertible a T Efecto Equivalente a T x = *r; ++r; return x;.


    Dominio de la igualdad

    El termino dominio de == se usa en el sentido matemático ordinario para indicar el conjunto de valores que se pueden comparar usando ==. Este conjunto puede cambiar con el tiempo.

    Cada algoritmo impone requisitos adicionales en el dominio de igualdad para los valores de iterador que usa. Estos requisitos se pueden inferir a partir de los usos que hace el algoritmo de == y !=.

    Notas

    Para un iterador de entrada X que no es un IteradorDeAvanceLegado, std::iterator_traits<X>::reference no tiene que ser un tipo referencia: desreferenciar un iterador de entrada puede devolver un objeto proxy o std::iterator_traits<X>::value_type en sí mismo por valor (como en el caso de std::istreambuf_iterator).


    Concepto

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

    <tbody> </tbody>
    template<class I> concept __LegacyInputIterator = __LegacyIterator<I> && std::equality_comparable<I> && requires(I i) { typename std::incrementable_traits<I>::difference_type; typename std::indirectly_readable_traits<I>::value_type; typename std::common_reference_t<std::iter_reference_t<I>&&, typename std::indirectly_readable_traits<I>::value_type&>; *i++; typename std::common_reference_t<decltype(*i++)&&, typename std::indirectly_readable_traits<I>::value_type&>; requires std::signed_integral<typename std::incrementable_traits<I>::difference_type>; };

    donde el concepto solo para exposición __LegacyIterator se describe en IteradorLegado.

    		(desde C++20)

    Informes de defectos

    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
    LWG 98 C++98 Se requería que el tipo de retorno de *i++ fuera T. Puede ser cualquier tipo convertible a T.
    P2167R3 C++98 La convertibilidad a bool era demasiado débil
    para reflejar la expectativa de las implementaciones     		Se refuerzan los requisitos.

    Véase también

    (C++20)
    		 Especifica que un tipo es un iterador de entrada, es decir, los valores a los que hace referencia se pueden leer y se pueden preincrementar y posincrementar.
    (concepto) [editar]
    Biblioteca de iteradores Proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de servicio.