C++ named requirements: LegacyOutputIterator

Un LegacyOutputIterator es un LegacyIterator que puede escribir al elemento apuntado.

Un ejemplo de un tipo que implementa LegacyOutputIterator es std::ostream_iterator .

Cuando un LegacyForwardIterator , LegacyBidirectionalIterator , o LegacyRandomAccessIterator satisface los requisitos de LegacyOutputIterator además de sus propios requisitos, se describe como mutable .

Contenidos 1 Requisitos 2 Notas 3 Biblioteca estándar 4 Véase también

Requisitos

El tipo X satisface LegacyOutputIterator si

• El tipo X satisface LegacyIterator
• X es un tipo de clase o un tipo de puntero

Y, dado

• o , un valor de algún tipo que se puede escribir en el iterador de salida (puede haber múltiples tipos que se puedan escribir, por ejemplo, si operator = puede ser una plantilla. No existe el concepto de value_type como para los iteradores de entrada)
• r , un valor-l de tipo X ,

Las siguientes expresiones deben ser válidas y tener sus efectos especificados

Expresión	Retorno	Expresión equivalente	Precondición	Postcondiciones	Notas
* r = o	(no se utiliza)		r es dereferenciable	r es incrementable	Después de esta operación r no requiere ser dereferenciable y cualquier copia del valor anterior de r ya no requiere ser dereferenciable o incrementable.
++ r	X &		r es incrementable	r y ++ r designan el mismo objeto iterador, r es dereferenciable o past-the-end	Después de esta operación r no requiere ser incrementable y cualquier copia del valor anterior de r ya no requiere ser dereferenciable o incrementable.
r ++	convertible a const X &	X temp = r ; ++ r ; return temp ;
* r ++ = o	(no se utiliza)	* r = o ; ++ r ;

Notas

El único uso válido de operator * con un iterador de salida es a la izquierda de una asignación: operator * puede devolver un objeto proxy, que define un miembro operator = (que puede ser una plantilla).

La igualdad y la desigualdad pueden no estar definidas para los iteradores de salida. Incluso si se define un operator == , x == y no necesariamente implica ++ x == ++ y .

La asignación a través del mismo valor de un iterador de salida ocurre solo una vez: los algoritmos en iteradores de salida deben ser algoritmos de una sola pasada.

La asignación a través de un iterador de salida debe alternarse con el incremento. El doble incremento es comportamiento indefinido (el estándar de C++ actualmente afirma que el doble incremento está soportado, en contradicción con la documentación de STL; esto es LWG issue 2035 ).

Se permite que un iterador de solo salida puro declare su iterator_traits < X > :: value_type , iterator_traits < X > :: difference_type , iterator_traits < X > :: pointer , y iterator_traits < X > :: reference como void (e iteradores como std::back_insert_iterator hacen exactamente eso excepto por difference_type , que ahora está definido para satisfacer std::output_iterator (desde C++20) ).

Biblioteca estándar

Los siguientes iteradores de la biblioteca estándar son iteradores de salida que no son iteradores hacia adelante:

ostream_iterator	iterador de salida que escribe en std::basic_ostream (plantilla de clase)
ostreambuf_iterator	iterador de salida que escribe en std::basic_streambuf (plantilla de clase)
insert_iterator	adaptador de iterador para inserción en un contenedor (plantilla de clase)
back_insert_iterator	adaptador de iterador para inserción al final de un contenedor (plantilla de clase)
front_insert_iterator	adaptador de iterador para inserción al frente de un contenedor (plantilla de clase)

Véase también

output_iterator (C++20)	especifica que un tipo es un iterador de salida para un tipo de valor dado, es decir, se pueden escribir valores de ese tipo en él y puede ser pre-incrementado y post-incrementado (concepto)
Biblioteca de iteradores	proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de utilidad