std::experimental::ostream_joiner(3)

NAME
std::experimental::ostream_joiner - std::experimental::ostream_joiner

Synopsis
   Defined in header <experimental/iterator>
   template<
       class DelimT,
       class CharT = char, (library fundamentals TS v2)
       class Traits = std::char_traits<CharT>
   >
   class ostream_joiner;
   std::experimental::ostream_joiner is a single-pass LegacyOutputIterator that writes
   successive objects into the std::basic_ostream object for which it was constructed,
   using operator<<, separated by a delimiter. The delimiter is written to the output
   stream between every two objects that are written. The write operation is performed
   when the iterator (whether dereferenced or not) is assigned to. Incrementing the
   ostream_joiner is a no-op.
   In a typical implementation, the only data members of ostream_joiner are a pointer
   to the associated std::basic_ostream, the delimiter, and a bool member that
   indicates whether the next write is for the first element in the sequence.
   Compared to std::ostream_iterator, ostream_joiner prints the delimiter sequence one
   fewer time, and is not templated on the type of the object to be printed.

Member types
   Member type Definition
   char_type CharT
   traits_type Traits
   ostream_type std::basic_ostream<CharT, Traits>
   value_type void
   difference_type void
   pointer void
   reference void
   iterator_category std::output_iterator_tag

Member functions
   constructor constructs a new ostream_joiner
                        (public member function)
   destructor destructs an ostream_joiner
   (implicitly declared) (public member function)
   operator= writes an object to the associated output sequence
                        (public member function)
   operator* no-op
                        (public member function)
   operator++ no-op
   operator++(int) (public member function)

Non-member functions
                       creates an ostream_joiner object, deducing the template's type
   make_ostream_joiner arguments from the function arguments
                       (function template)

Example
// Run this code
 #include <algorithm>
 #include <experimental/iterator>
 #include <iostream>
 #include <iterator>
 int main()
 {
     int i[] = {1, 2, 3, 4, 5};
     std::copy(std::begin(i),
               std::end(i),
               std::experimental::make_ostream_joiner(std::cout, ", "));
 }

Output:
 1, 2, 3, 4, 5

See also
   ostreambuf_iterator output iterator that writes to std::basic_streambuf
                       (class template)
   ostream_iterator output iterator that writes to std::basic_ostream
                       (class template)
   istream_iterator input iterator that reads from std::basic_istream
                       (class template)