I use this:
/*
* File: ostream_join_iterator.hpp
* Author: utnapistim :)
*
* Created on July 13, 2013, 1:14 AM
*/
#ifndef OSTREAM_JOIN_ITERATOR_HPP
#define OSTREAM_JOIN_ITERATOR_HPP
/**
* @brief Implements join functionality directing into an ostream
*
* This class provides an iterator for writing into an ostream.
* The type T is the only type written by this iterator and there must
* be an operator << (T) defined.
*
* @remarks This class implements functionality similar to
* std::ostream_iterator except it does not print a separator after the
* last element.
*
* @param Tp The type to write to the ostream.
* @param CharT The ostream char_type.
* @param Traits The ostream char_traits.
*/
template<typename T, typename C=char, typename Tr=std::char_traits<C> >
class ostream_join_iterator
: public std::iterator<std::output_iterator_tag, void, void, void, void>
{
public:
typedef C char_type;
typedef Tr traits_type;
typedef std::basic_string<C, Tr> splitter_type;
typedef std::basic_ostream<C, Tr> ostream_type;
private:
ostream_type *out_;
splitter_type splitter_;
bool at_first_;
public:
ostream_join_iterator(ostream_type& out)
: out_{&out}
, splitter_{}
, at_first_{true}
{
}
/**
* Construct from an ostream.
*
* @remarks The delimiter is not copied, and thus must not be destroyed
* while this iterator is in use.
*
* @param out Underlying ostream to write to.
* @param splitter CharT delimiter string to insert.
*/
ostream_join_iterator(ostream_type& out, const char_type* splitter)
: out_{&out}
, splitter_{splitter}
, at_first_{true}
{
}
/// Copy constructor.
ostream_join_iterator(const ostream_join_iterator& other)
: out_{other.out_}
, splitter_{other.splitter_}
, at_first_{other.at_first_}
{
}
ostream_join_iterator& operator=(const T& value)
{ // add separator before the value, if not at first element
if((not splitter_.empty()) and (not at_first_))
*out_ << splitter_;
*out_ << value;
at_first_ = false;
return *this;
}
ostream_join_iterator& operator=(ostream_join_iterator temp)
{
using std::swap;
swap(out_, temp.out_);
swap(splitter_, temp.splitter_);
swap(at_first_, temp.at_first_);
return *this;
}
ostream_join_iterator&
operator*() {
return *this;
}
ostream_join_iterator&
operator++() {
return *this;
}
ostream_join_iterator&
operator++(int) {
return *this;
}
};
template <typename T> using join = ostream_join_iterator<T>;
template <typename T> using wjoin = ostream_join_iterator<T, wchar_t>;
#endif /* OSTREAM_JOIN_ITERATOR_HPP */
Usage:
using namespace std;
ostringstream sql;
sql << "SELECT ";
transform(fields_.begin(), fields_.end(), join<string>{sql, ", "},
[](const field& f) { return f.escaped_name(); });
sql << " FROM " << name_;
The transform call can easily be paced into a convenience function.