A LegacyOutputIterator is a LegacyIterator that can write to the pointed-to element.
An example of a type that implements LegacyOutputIterator is std::ostream_iterator.
When LegacyForwardIterator, LegacyBidirectionalIterator, or LegacyRandomAccessIterator satisfies the LegacyOutputIterator requirements in addition to its own requirements, it is described as mutable.
The type X
satisfies LegacyOutputIterator if.
X
satisfies LegacyIterator X
is a class type or a pointer type And, given.
o
, a value of some type that is writable to the output iterator (there may be multiple types that are writable, e.g. if operator=
may be a template. There is no notion of value_type
as for the input iterators) r
, an lvalue of type X
, The following expressions must be valid and have their specified effects.
Expression | Return | Equivalent expression | Pre-condition | Post-conditions | Notes |
---|---|---|---|---|---|
*r = o | (not used) |
r is dereferencable |
r is incrementable | After this operation r is not required to be dereferenceable and any copies of the previous value of r are no longer required to be dereferenceable or incrementable. |
|
++r |
X& |
r is incrementable |
r and ++r designate the same iterator object, r is dereferencable or past-the-end | After this operation r is not required to be incrementable and any copies of the previous value of r are no longer required to be dereferenceable or incrementable. |
|
r++ | convertible to const X& |
X temp = r; ++r; return temp; | |||
*r++ = o | (not used) |
*r = o; ++r; |
The only valid use of operator*
with an output iterator is on the left of an assignment: operator*
may return a proxy object, which defines a member operator=
(which may be a template).
Equality and inequality may not be defined for output iterators. Even if an operator==
is defined, x == y
need not imply ++x == ++y
.
Assignment through the same value of an output iterator happens only once: algorithms on output iterators must be single-pass algorithms.
Assignment through an output iterator is expected to alternate with incrementing. Double-increment is undefined behavior (C++ standard currently claims that double increment is supported, contrary to the STL documentation; this is LWG #2035).
Pure output-only iterator is allowed to declare its iterator_traits<X>::value_type
, iterator_traits<X>::difference_type
, iterator_traits<X>::pointer
, and iterator_traits<X>::reference
to be void
(and iterators such as std::back_insert_iterator
do just that).
The following standard library iterators are output iterators that are not forward iterators:
std::ostream_iterator
std::ostreambuf_iterator
std::insert_iterator
std::back_insert_iterator
std::front_insert_iterator
specifies that a type is an output iterator for a given value type, that is, values of that type can be written to it and it can be both pre- and post-incremented (concept) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/named_req/OutputIterator