Namespaces
Variants

C++ named requirements: LegacyForwardIterator

From cppreference.net
C++
C++ named requirements

Un LegacyForwardIterator es un LegacyIterator que puede leer datos del elemento apuntado.

A diferencia de LegacyInputIterator y LegacyOutputIterator , puede utilizarse en algoritmos multipase.

Si un LegacyForwardIterator it proviene de un Container , entonces el tipo de valor de it es el mismo que el del contenedor, por lo que desreferenciar ( * it ) obtiene el tipo de valor del contenedor.

Contenidos

Requisitos

Tipo Definición
X Un tipo de iterador de avance
T El tipo de valor de X (es decir, 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 LegacyForwardIterator si se cumplen todas las siguientes condiciones:

Expresión Tipo Efectos
r ++ convertible a const X & Equivalente a X x = r ;
++ r ;
return x ; .
* i ++ Ref

Dominio de igualdad

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

Sin embargo, los iteradores forward value-initialized pueden compararse, y deben ser iguales a otros iteradores value-initialized del mismo tipo.

En otras palabras, los iteradores forward value-initialized se comportan como si hicieran referencia más allá del final de la misma secuencia vacía.

(since C++14)

Garantía de múltiples pasadas

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

  • a == b implica ++ a == ++ b .
  • Se satisface cualquiera de las siguientes condiciones:
  • 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 de 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 de exposición __LegacyInputIterator<T> se describe en LegacyInputIterator .

(desde C++20)

Notas

A diferencia del concepto std::forward_iterator , los requisitos de LegacyForwardIterator exigen que la desreferenciación devuelva una referencia.

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 1212
( N3066 ) 		C++98 el tipo de * i ++ no coincidía con el tipo de
* i -- requerido por LegacyBidirectionalIterator 		se cambió el
tipo a Ref
LWG 1311
( N3066 ) 		C++98 " a == b implica ++ a == ++ b " únicamente
no ofrecía garantía multipase [1] 		también requiere " a == b
implica ++ a ! = b " [2]
LWG 3798 C++20 __LegacyForwardIterator requería
std:: iter_reference_t < It > fuera un tipo de referencia lvalue 		también permite tipos de
referencia rvalue
  1. ↑ En el escenario donde a y b utilizan el mismo iterador subyacente, evaluar la expresión ++ a == ++ b realmente incrementa el contenedor subyacente dos veces, pero el resultado sigue siendo true .
  2. ↑ Formalmente también requiere que implique ++ b ! = a .

Véase también

(C++20)
especifica que un input_iterator es un iterador de avance, que admite comparación de igualdad y múltiples pasadas
(concepto)
Biblioteca de iteradores proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de utilidad