Re: C++ FAQ

In article <4A482EDC.1000302@bawi.org>, musiphil@bawi.org says...

[ ... ]


First of all, given that each iteration of the loop does an output
operation, there's essentially no chance at all that the conditional
in the loop is going to make a measurable difference in speed -- just
in really round numbers, conditional tests take on the order of
nanoseconds and I/O operations take on the order of microseconds to
milliseconds.

Second, it's not really true anyway. This basic type of example (a
loop and a half) is well known, and it's equally well known that
avoiding the goto involves nothing more than duplicating a bit of
code. If the code you have to duplicate is sufficiently substantial,
it can be worthwhile, but in this case it's quite trivial:

template <typename Iter>
void join_print(
    Iter begin,
    Iter end,
    std::ostream& os,
    const char* delim)
{
    if (begin!=end) {
        os << *begin++;
        for (;begin!=end; ++begin)
            os << delim << *begin;
    }
}

Of course, I'd prefer to separate concerns, and use std::copy with
the infix_ostream_iterator that was recent posted to comp.lang.c++:

// Warning: only minimally tested.
// infix_iterator.h
// Lifted from Jerry Coffin's 's prefix_ostream_iterator
#if !defined(INFIX_ITERATOR_H_)
#define INFIX_ITERATOR_H_
#include <ostream>
#include <iterator>

template <class T,
class charT=char,
class traits=std::char_traits<charT> >

class infix_ostream_iterator :
    public std::iterator
<std::output_iterator_tag,void,void,void,void>
{
    std::basic_ostream<charT,traits> *os;
    charT const* delimiter;
    bool first_elem;
public:
    typedef charT char_type;
    typedef traits traits_type;
    typedef std::basic_ostream<charT,traits> ostream_type;

    infix_ostream_iterator(ostream_type& s)
        : os(&s),delimiter(0), first_elem(true)
    {}
    infix_ostream_iterator(ostream_type& s, charT const *d)
        : os(&s),delimiter(d), first_elem(true)
    {}
    infix_ostream_iterator<T,charT,traits>& operator=(T const &item)
    {
        if (!first_elem && delimiter != 0)
            *os << delimiter;
        *os << item;
        first_elem = false;
        return *this;
    }

    infix_ostream_iterator<T,charT,traits> &operator*() {
        return *this;
    }
    infix_ostream_iterator<T,charT,traits> &operator++() {
        return *this;
    }
    infix_ostream_iterator<T,charT,traits> &operator++(int) {
        return *this;
    }
};
#endif

Using this, a call to join_print like this:

    join_print(vect.begin(), vect.end(), std::cout, "|");

would be replaced with a call to copy, like this:

    std::copy(vect.begin(), vect.end(),
        std::infix_ostream_iterator<whatever>(std::cout, "|"));

While that's slightly longer, it's also considerably more flexible:
it's an ostream_iterator that can be used with any algorith that
would work with another ostream_iterator.

--
    Later,
    Jerry.

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]