Espacios de nombres
Variantes
Acciones

Requisitos denominados de C++: InputIterator

De cppreference.com
< cpp‎ | named req
 
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

 

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.

Contenido

[editar] 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;.


[editar] 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 !=.

[editar] 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.

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)

[editar] 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.

[editar] 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.
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/named_req/InputIterator&oldid=45887»