Output iterator

Discussion in 'C++' started by Anders, Jun 29, 2003.

  1. Anders

    Anders Guest

    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
    Anders, Jun 29, 2003
    #1
    1. Advertising

  2. Anders

    Anders Guest

    And yes, I know that I should be using preincrement instead - it's faster:
    ---
    test = 1;
    ++test = 2;
    ++test = 3;
    ++test = 4;
    ---


    //Anders
    Anders, Jun 29, 2003
    #2
    1. Advertising

  3. In article <3eff61ac$0$32546$>, Anders
    <> wrote:

    | 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++().

    --
    Howard Hinnant
    Metrowerks
    Howard Hinnant, Jun 29, 2003
    #3
  4. Anders

    Rolf Magnus Guest

    Howard Hinnant wrote:

    > In article <3eff61ac$0$32546$>, Anders
    > <> wrote:
    >
    > | 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.
    Rolf Magnus, Jun 29, 2003
    #4
  5. Anders

    Rolf Magnus Guest

    Howard Hinnant wrote:

    > In article <bdnq3o$unr$01$-online.com>, Rolf Magnus
    > <> wrote:
    >
    > | 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.
    Rolf Magnus, Jun 30, 2003
    #5
  6. In article <bdnuim$20g$01$-online.com>, Rolf Magnus
    <> wrote:

    | 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! :)

    --
    Howard Hinnant
    Metrowerks
    Howard Hinnant, Jun 30, 2003
    #6
    1. Advertising

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

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Hendrik Maryns
    Replies:
    18
    Views:
    1,399
  2. greg
    Replies:
    6
    Views:
    444
    Dietmar Kuehl
    Jul 17, 2003
  3. Replies:
    6
    Views:
    627
    Jim Langston
    Oct 30, 2005
  4. Steven D'Aprano

    What makes an iterator an iterator?

    Steven D'Aprano, Apr 18, 2007, in forum: Python
    Replies:
    28
    Views:
    1,131
    Steven D'Aprano
    Apr 20, 2007
  5. David Bilsby
    Replies:
    5
    Views:
    2,024
    David Bilsby
    Oct 9, 2007
Loading...

Share This Page