Requisitos denominados de C++: OutputIterator
Un IteradorDeSalidaLegado es un IteradorLegado que puede escribir al elemento al que se apunta.
Un ejemplo de un tipo que implementa a IteradorDeSalidaLegado es std::ostream_iterator.
Cuando un IteradorDeAvanceLegado, IteradorBidireccionalLegado, o IteradorDeAccesoAleatorioLegado satisface los requisitos de IteradorDeSalidaLegado además de sus propios requisitos, se describe como mutable.
Requisitos
El tipo X satisface a IteradorDeSalidaLegado si
- El tipo
Xsatisface a IteradorLegado, Xes un tipo de clase o un tipo de puntero.
Y, dado
o, un valor de algún tipo al cual se puede escribir en el iterador de salida (pueden existir múltiples tipos a los que se puede escribir, p. ej., sioperator=fuera una plantilla. No existe noción devalue_typea diferencia de los iteradores de entrada)r, un l-valor de tipoX,
Las siguientes expresiones deben ser válidas y tener sus efectos especificados
| Expresión | Tipo de retorno | Expresión equivalente | Precondición | Poscondiciones | Notas |
|---|---|---|---|---|---|
*r = o
|
(no usado) | r es desreferenciable
|
r es incrementable
|
Después de esta operación, no se requiere que r sea desreferenciable y cualquier copia del valor anterior de r ya no se requiere que sea desreferenciable o incrementable.
| |
++r
|
X&
|
r es incrementable
|
r y ++r designan el mismo objeto de iterador, r es desreferenciable o está pasado del final.
|
Después de esta operación, no se requiere que r sea incrementable y cualquier copia del valor anterior de r ya no se requiere que sea desreferenciable o incrementable.
| |
r++
|
convertible a const X&
|
X temp = r; ++r; return temp;
|
|||
*r++ = o
|
(no usado) | *r = o; ++r;
|
Notas
El único uso válido de operator* con un iterador de salida está 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 los iteradores de salida deben ser algoritmos de paso único.
Se espera que la asignación a través de un iterador de salida se alterne con incrementos. El incremento doble es un comportamiento indefinido (el estándar de C++ actualmente afirma que se admite el incremento doble, contrario a la documentación de STL; esto es Asunto LWG 2035).
Se permite a un iterador de salida pura que declare que sus iterator_traits<X>::value_type, iterator_traits<X>::difference_type, iterator_traits<X>::pointer, y iterator_traits<X>::reference sean void (e iteradores como std::back_insert_iterator hacen exactamente eso excepto para 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 de avance:
- std::ostream_iterator
- std::ostreambuf_iterator
- std::insert_iterator
- std::back_insert_iterator
- std::front_insert_iterator
Véase también
(C++20) |
especifica que un tipo es un iterador de salida para un valor dado, es decir, se pueden escribir valores de este tipo en el y se puede pre y posincrementar (concepto) |
| Biblioteca de iteradores | Proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de servicio. |