Espacios de nombres
Variantes
Acciones

Requisitos denominados de C++: IteradorDeAvanceLegado

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 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.

Contenido

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

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


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

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)

[editar] Notas

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

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

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