Output iterator

A

Anders

Hello there.

Can anyone tell me why the ++-operator is defined for ostream_iterator ? I
can't see the difference between:

ostream_iterator<int> test(cout);
test++ = 1;
test++ = 2;
test++ = 3;
test++ = 4;

and:

ostream_iterator<int> test(cout);
test = 1;
test = 2;
test = 3;
test = 4;

//Anders
 
H

Howard Hinnant

| Hello there.
|
| Can anyone tell me why the ++-operator is defined for ostream_iterator ? I
| can't see the difference between:
|
| ostream_iterator<int> test(cout);
| test++ = 1;
| test++ = 2;
| test++ = 3;
| test++ = 4;
|
| and:
|
| ostream_iterator<int> test(cout);
| test = 1;
| test = 2;
| test = 3;
| test = 4;

It is so that generic code will work with ostream_iterator. For
example:

template <class InputIterator, class OutputIterator>
OutputIterator
copy(InputIterator first, InputIterator last, OutputIterator result)
{
for (; first != last; ++first, ++result)
*result = *first;
return result;
}

If you put an ostream_iterator into copy as the OutputIterator, you
really do want it to compile and "do the right thing", which in this
case is nothing for operator++().
 
R

Rolf Magnus

Howard said:
| Hello there.
|
| Can anyone tell me why the ++-operator is defined for
| ostream_iterator ? I can't see the difference between:
|
| ostream_iterator<int> test(cout);
| test++ = 1;
| test++ = 2;
| test++ = 3;
| test++ = 4;
|
| and:
|
| ostream_iterator<int> test(cout);
| test = 1;
| test = 2;
| test = 3;
| test = 4;

It is so that generic code will work with ostream_iterator. For
example:

template <class InputIterator, class OutputIterator>
OutputIterator
copy(InputIterator first, InputIterator last, OutputIterator result)
{
for (; first != last; ++first, ++result)
*result = *first;
return result;
}

If you put an ostream_iterator into copy as the OutputIterator, you
really do want it to compile and "do the right thing", which in this
case is nothing for operator++().

Actually, you must use operator++ to increment the iterator for each
read/write operation, since the implementation might choose to actually
rely on this.
 
R

Rolf Magnus

Howard said:
| Howard Hinnant wrote:
|
| > If you put an ostream_iterator into copy as the OutputIterator,
| > you really do want it to compile and "do the right thing", which
| > in this case is nothing for operator++().
|
| Actually, you must use operator++ to increment the iterator for each
| read/write operation, since the implementation might choose to
| actually rely on this.

<nod> It might. But the C++ standard says in section 24.5.2.2 -
ostream_iterator operations, paragraph 3:

| ostream_iterator& operator++();
| ostream_iterator& operatot++(int);
|
| -3- Returns: *this

(i.e. do nothing)

Does that mean the same as if it specifically said that the operator
does nothing?
I certainly would never write code that used ostream_iterator in an
unconventional manner that took advantage of this detail. And I'm not
suggesting anybody should. But if you want to get picky,
ostream_iterator::eek:perator++() is defined by the C++ standard to do
nothing but return *this.

I didn't read in the standard, but in TC++PL3, which says:

"The ++ operation might trigger an actual output operation, or it might
have no effect. Different implementations will use different
implementation strategies. Consequently, for code to be portable, a ++
must occur between every two assignments to an ostream_iterator."
And the main reason that ostream_iterator
has all of these "extra" operations that do nothing is so that it can
be used seamlessly as any other iterator that supports the semantics
required by output_iterator_tag (i.e. output, forward, bidirectional
and random access iterators).

Ack.
 
H

Howard Hinnant

| Howard Hinnant wrote:
|
| > <nod> It might. But the C++ standard says in section 24.5.2.2 -
| > ostream_iterator operations, paragraph 3:
| >
| > | ostream_iterator& operator++();
| > | ostream_iterator& operatot++(int);
| > |
| > | -3- Returns: *this
| >
| > (i.e. do nothing)
|
| Does that mean the same as if it specifically said that the operator
| does nothing?

Hmm... no, I think you're right. It could have other effects, though
I'm having trouble coming up with a quick realistic example. Maybe
some kind of debugging info?

| > I certainly would never write code that used ostream_iterator in an
| > unconventional manner that took advantage of this detail. And I'm not
| > suggesting anybody should. But if you want to get picky,
| > ostream_iterator::eek:perator++() is defined by the C++ standard to do
| > nothing but return *this.
|
| I didn't read in the standard, but in TC++PL3, which says:
|
| "The ++ operation might trigger an actual output operation, or it might
| have no effect. Different implementations will use different
| implementation strategies. Consequently, for code to be portable, a ++
| must occur between every two assignments to an ostream_iterator."

Well, the standard explicitly says that the output will occur under
op=(const T&) operator:

| ostream_iterator& operator=(const T& value );
|
| -1- Effects:
| *out_stream << value;
| if(delim != 0) * out_stream << delim;
| return (*this);

So I don't see how the op++ could also trigger output without really
messing things up.

| Ack.

Bill? Bill The Cat? Is that you?!! We've missed you soooo much! :)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,482
Members
44,901
Latest member
Noble71S45

Latest Threads

Top