Namespaces
Variants

C++ named requirements: LegacyInputIterator

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

Un LegacyInputIterator es un LegacyIterator que puede leer desde el elemento apuntado. Los LegacyInputIterator solo garantizan validez para algoritmos de paso único: una vez que un LegacyInputIterator i ha sido incrementado, todas las copias de su valor anterior pueden quedar invalidados.

Contenidos

Requisitos

Tipo Definición
X Un tipo de iterador de entrada
T El tipo de valor de X (es decir, 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 posiblemente denota un miembro de datos o función miembro


X satisface LegacyInputIterator si se cumplen todas las siguientes condiciones:

Expresión Tipo Semántica
i ! = j
un tipo que satisface BooleanTestable (hasta C++20)
un tipo que modela boolean-testable (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 dereferenciable .
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 dereferenciable.
Efecto Equivalente a ( * i ) . m .
++ r X& Precondición r es dereferenciable.
Postcondición
  • r es dereferenciable o r está más allá del final.
  • Cualquier copia del valor anterior de r ya no necesita ser dereferenciable ni estar 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 igualdad

El término el dominio de == se utiliza en el sentido matemático ordinario para denotar el conjunto de valores que pueden compararse usando == . Este conjunto puede cambiar con el tiempo.

Cada algoritmo impone requisitos adicionales en el dominio de igualdad para los valores de iterador que utiliza. Estos requisitos pueden inferirse de los usos que el algoritmo hace de == y ! = .

Notas

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

Concept

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

(desde C++20)

Informes de defectos

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

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 98 C++98 el tipo de retorno de * i ++ era requerido ser T puede ser cualquier tipo convertible a T
LWG 2114
( P2167R3 ) 		C++98 la convertibilidad a bool era demasiado débil para
reflejar las expectativas de las implementaciones 		requisitos fortalecidos

Véase también

(C++20)
especifica que un tipo es un input iterator, es decir, que sus valores referenciados pueden leerse y puede ser pre- y post-incrementado
(concept)
Iterator library proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de utilidad