[stream.iterators] - C++14 → C++17

Files changed (1) hide show

tmp/tmps465kd98/{from.md → to.md} +116 -97

tmp/tmps465kd98/{from.md → to.md} RENAMED Viewed

@@ -2,19 +2,23 @@
 To make it possible for algorithmic templates to work directly with
 input/output streams, appropriate iterator-like class templates are
 provided.
 ``` cpp
 partial_sum(istream_iterator<double, char>(cin),
   istream_iterator<double, char>(),
   ostream_iterator<double, char>(cout, "\n"));
 ```
-reads a file containing floating point numbers from `cin`, and prints
 the partial sums onto `cout`.
 ### Class template `istream_iterator` <a id="istream.iterator">[[istream.iterator]]</a>
 The class template `istream_iterator` is an input iterator (
 [[input.iterators]]) that reads (using `operator>>`) successive elements
 from the input stream for which it was constructed. After it is
@@ -27,35 +31,42 @@ object, which is the only legitimate iterator to be used for the end
 condition. The result of `operator*` on an end-of-stream iterator is not
 defined. For any other iterator value a `const T&` is returned. The
 result of `operator->` on an end-of-stream iterator is not defined. For
 any other iterator value a `const T*` is returned. The behavior of a
 program that applies `operator++()` to an end-of-stream iterator is
-undefined. It is impossible to store things into istream iterators.
 Two end-of-stream iterators are always equal. An end-of-stream iterator
 is not equal to a non-end-of-stream iterator. Two non-end-of-stream
 iterators are equal when they are constructed from the same stream.
 ``` cpp
 namespace std {
   template <class T, class charT = char, class traits = char_traits<charT>,
       class Distance = ptrdiff_t>
-  class istream_iterator:
-    public iterator<input_iterator_tag, T, Distance, const T*, const T&> {
   public:
- typedef charT char_type;
- typedef traits traits_type;
- typedef basic_istream<charT,traits> istream_type;
- see below istream_iterator();
     istream_iterator(istream_type& s);
     istream_iterator(const istream_iterator& x) = default;
     ~istream_iterator() = default;
     const T& operator*() const;
     const T* operator->() const;
-    istream_iterator<T,charT,traits,Distance>& operator++();
-    istream_iterator<T,charT,traits,Distance>  operator++(int);
   private:
     basic_istream<charT,traits>* in_stream; // exposition only
     T value;                                // exposition only
   };
@@ -69,77 +80,80 @@ namespace std {
 ```
 #### `istream_iterator` constructors and destructor <a id="istream.iterator.cons">[[istream.iterator.cons]]</a>
 ``` cpp
-see below istream_iterator();
 ```
-*Effects:* Constructs the end-of-stream iterator. If `T` is a literal
-type, then this constructor shall be a `constexpr` constructor.
-`in_stream == 0`.
 ``` cpp
 istream_iterator(istream_type& s);
 ```
-*Effects:* Initializes *in_stream* with `&s`. *value* may be initialized
-during construction or the first time it is referenced.
-`in_stream == &s`.
 ``` cpp
 istream_iterator(const istream_iterator& x) = default;
 ```
-*Effects:* Constructs a copy of `x`. If `T` is a literal type, then this
-constructor shall be a trivial copy constructor.
-`in_stream == x.in_stream`.
 ``` cpp
 ~istream_iterator() = default;
 ```
-*Effects:* The iterator is destroyed. If `T` is a literal type, then
-this destructor shall be a trivial destructor.
 #### `istream_iterator` operations <a id="istream.iterator.ops">[[istream.iterator.ops]]</a>
 ``` cpp
 const T& operator*() const;
 ```
-*Returns:* *value*.
 ``` cpp
 const T* operator->() const;
 ```
-*Returns:* `&(operator*())`.
 ``` cpp
-istream_iterator<T,charT,traits,Distance>& operator++();
 ```
 *Requires:* `in_stream != 0`.
-*Effects:* `*in_stream >>value`.
 *Returns:* `*this`.
 ``` cpp
-istream_iterator<T,charT,traits,Distance> operator++(int);
 ```
 *Requires:* `in_stream != 0`.
-*Effects:*
 ``` cpp
-istream_iterator<T,charT,traits,Distance> tmp = *this;
 *in_stream >> value;
 return (tmp);
 ```
 ``` cpp
@@ -177,25 +191,30 @@ while (first != last)
 is defined as:
 ``` cpp
 namespace std {
   template <class T, class charT = char, class traits = char_traits<charT>>
-  class ostream_iterator:
-    public iterator<output_iterator_tag, void, void, void, void> {
   public:
- typedef charT char_type;
- typedef traits traits_type;
- typedef basic_ostream<charT,traits> ostream_type;
     ostream_iterator(ostream_type& s);
     ostream_iterator(ostream_type& s, const charT* delimiter);
-    ostream_iterator(const ostream_iterator<T,charT,traits>& x);
     ~ostream_iterator();
-    ostream_iterator<T,charT,traits>& operator=(const T& value);
-    ostream_iterator<T,charT,traits>& operator*();
-    ostream_iterator<T,charT,traits>& operator++();
-    ostream_iterator<T,charT,traits>& operator++(int);
   private:
     basic_ostream<charT,traits>* out_stream;  // exposition only
     const charT* delim;                       // exposition only
   };
 }
@@ -205,17 +224,18 @@ namespace std {
 ``` cpp
 ostream_iterator(ostream_type& s);
 ```
-*Effects:* Initializes *out_stream* with `&s` and *delim* with null.
 ``` cpp
 ostream_iterator(ostream_type& s, const charT* delimiter);
 ```
-*Effects:* Initializes *out_stream* with `&s` and *delim* with
 `delimiter`.
 ``` cpp
 ostream_iterator(const ostream_iterator& x);
 ```
@@ -232,11 +252,11 @@ ostream_iterator(const ostream_iterator& x);
 ``` cpp
 ostream_iterator& operator=(const T& value);
 ```
-*Effects:*
 ``` cpp
 *out_stream << value;
 if (delim != 0)
   *out_stream << delim;
@@ -259,49 +279,50 @@ ostream_iterator& operator++(int);
 ### Class template `istreambuf_iterator` <a id="istreambuf.iterator">[[istreambuf.iterator]]</a>
 The class template `istreambuf_iterator` defines an input iterator (
 [[input.iterators]]) that reads successive *characters* from the
 streambuf for which it was constructed. `operator*` provides access to
-the current input character, if any. `operator->` may return a proxy.
-Each time `operator++` is evaluated, the iterator advances to the next
-input character. If the end of stream is reached
-(`streambuf_type::sgetc()` returns `traits::eof()`), the iterator
-becomes equal to the *end-of-stream* iterator value. The default
-constructor `istreambuf_iterator()` and the constructor
-`istreambuf_iterator(0)` both construct an end-of-stream iterator object
-suitable for use as an end-of-range. All specializations of
-`istreambuf_iterator` shall have a trivial copy constructor, a
 `constexpr` default constructor, and a trivial destructor.
 The result of `operator*()` on an end-of-stream iterator is undefined.
 For any other iterator value a `char_type` value is returned. It is
 impossible to assign a character via an input iterator.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
-  class istreambuf_iterator
-     : public iterator<input_iterator_tag, charT,
-                       typename traits::off_type, unspecified, charT> {
   public:
- typedef charT                         char_type;
- typedef traits                        traits_type;
- typedef typename traits::int_type     int_type;
- typedef basic_streambuf<charT,traits> streambuf_type;
- typedef basic_istream<charT,traits>   istream_type;
     class proxy;                          // exposition only
     constexpr istreambuf_iterator() noexcept;
     istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
     ~istreambuf_iterator() = default;
     istreambuf_iterator(istream_type& s) noexcept;
     istreambuf_iterator(streambuf_type* s) noexcept;
     istreambuf_iterator(const proxy& p) noexcept;
     charT operator*() const;
- pointer operator->() const;
-    istreambuf_iterator<charT,traits>& operator++();
     proxy operator++(int);
     bool equal(const istreambuf_iterator& b) const;
   private:
     streambuf_type* sbuf_;                // exposition only
   };
@@ -313,11 +334,11 @@ namespace std {
     bool operator!=(const istreambuf_iterator<charT,traits>& a,
             const istreambuf_iterator<charT,traits>& b);
 }
 ```
-#### Class template `istreambuf_iterator::proxy` <a id="istreambuf.iterator::proxy">[[istreambuf.iterator::proxy]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class istreambuf_iterator<charT, traits>::proxy { // exposition only
@@ -339,81 +360,77 @@ placeholder as the return value of the post-increment operator
 (`operator++`). It keeps the character pointed to by the previous value
 of the iterator for some possible future access to get the character.
 #### `istreambuf_iterator` constructors <a id="istreambuf.iterator.cons">[[istreambuf.iterator.cons]]</a>
 ``` cpp
 constexpr istreambuf_iterator() noexcept;
 ```
-*Effects:* Constructs the end-of-stream iterator.
 ``` cpp
-istreambuf_iterator(basic_istream<charT,traits>& s) noexcept;
-istreambuf_iterator(basic_streambuf<charT,traits>* s) noexcept;
 ```
-*Effects:* Constructs an `istreambuf_iterator<>` that uses the
-`basic_streambuf<>` object `*(s.rdbuf())`, or `*s`, respectively.
-Constructs an end-of-stream iterator if `s.rdbuf()` is null.
 ``` cpp
 istreambuf_iterator(const proxy& p) noexcept;
 ```
-*Effects:* Constructs a `istreambuf_iterator<>` that uses the
-`basic_streambuf<>` object pointed to by the `proxy` object’s
-constructor argument `p`.
-#### `istreambuf_iterator::operator*` <a id="istreambuf.iterator::op*">[[istreambuf.iterator::op*]]</a>
 ``` cpp
 charT operator*() const
 ```
 *Returns:* The character obtained via the `streambuf` member
 `sbuf_->sgetc()`.
-#### `istreambuf_iterator::operator++` <a id="istreambuf.iterator::op++">[[istreambuf.iterator::op++]]</a>
 ``` cpp
-istreambuf_iterator<charT,traits>&
-    istreambuf_iterator<charT,traits>::operator++();
 ```
-*Effects:* `sbuf_->sbumpc()`.
 *Returns:* `*this`.
 ``` cpp
-proxy istreambuf_iterator<charT,traits>::operator++(int);
 ```
 *Returns:* `proxy(sbuf_->sbumpc(), sbuf_)`.
-#### `istreambuf_iterator::equal` <a id="istreambuf.iterator::equal">[[istreambuf.iterator::equal]]</a>
 ``` cpp
-bool equal(const istreambuf_iterator<charT,traits>& b) const;
 ```
 *Returns:* `true` if and only if both iterators are at end-of-stream, or
 neither is at end-of-stream, regardless of what `streambuf` object they
 use.
-#### `operator==` <a id="istreambuf.iterator::op==">[[istreambuf.iterator::op==]]</a>
 ``` cpp
 template <class charT, class traits>
   bool operator==(const istreambuf_iterator<charT,traits>& a,
                   const istreambuf_iterator<charT,traits>& b);
 ```
 *Returns:* `a.equal(b)`.
-#### `operator!=` <a id="istreambuf.iterator::op!=">[[istreambuf.iterator::op!=]]</a>
 ``` cpp
 template <class charT, class traits>
   bool operator!=(const istreambuf_iterator<charT,traits>& a,
                   const istreambuf_iterator<charT,traits>& b);
 ```
@@ -423,19 +440,22 @@ template <class charT, class traits>
 ### Class template `ostreambuf_iterator` <a id="ostreambuf.iterator">[[ostreambuf.iterator]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
-  class ostreambuf_iterator :
-    public iterator<output_iterator_tag, void, void, void, void> {
   public:
- typedef charT                         char_type;
- typedef traits                        traits_type;
- typedef basic_streambuf<charT,traits> streambuf_type;
- typedef basic_ostream<charT,traits>   ostream_type;
-  public:
     ostreambuf_iterator(ostream_type& s) noexcept;
     ostreambuf_iterator(streambuf_type* s) noexcept;
     ostreambuf_iterator& operator=(charT c);
     ostreambuf_iterator& operator*();
@@ -472,28 +492,27 @@ ostreambuf_iterator(streambuf_type* s) noexcept;
 *Effects:* Initializes `sbuf_` with `s`.
 #### `ostreambuf_iterator` operations <a id="ostreambuf.iter.ops">[[ostreambuf.iter.ops]]</a>
 ``` cpp
-ostreambuf_iterator<charT,traits>&
-  operator=(charT c);
 ```
 *Effects:* If `failed()` yields `false`, calls `sbuf_->sputc(c)`;
 otherwise has no effect.
 *Returns:* `*this`.
 ``` cpp
-ostreambuf_iterator<charT,traits>& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
-ostreambuf_iterator<charT,traits>& operator++();
-ostreambuf_iterator<charT,traits>& operator++(int);
 ```
 *Returns:* `*this`.
 ``` cpp

 To make it possible for algorithmic templates to work directly with
 input/output streams, appropriate iterator-like class templates are
 provided.
+[*Example 1*:
 ``` cpp
 partial_sum(istream_iterator<double, char>(cin),
   istream_iterator<double, char>(),
   ostream_iterator<double, char>(cout, "\n"));
 ```
+reads a file containing floating-point numbers from `cin`, and prints
 the partial sums onto `cout`.
+— *end example*]
 ### Class template `istream_iterator` <a id="istream.iterator">[[istream.iterator]]</a>
 The class template `istream_iterator` is an input iterator (
 [[input.iterators]]) that reads (using `operator>>`) successive elements
 from the input stream for which it was constructed. After it is
 condition. The result of `operator*` on an end-of-stream iterator is not
 defined. For any other iterator value a `const T&` is returned. The
 result of `operator->` on an end-of-stream iterator is not defined. For
 any other iterator value a `const T*` is returned. The behavior of a
 program that applies `operator++()` to an end-of-stream iterator is
+undefined. It is impossible to store things into istream iterators. The
+type `T` shall meet the `DefaultConstructible`, `CopyConstructible`, and
+`CopyAssignable` requirements.
 Two end-of-stream iterators are always equal. An end-of-stream iterator
 is not equal to a non-end-of-stream iterator. Two non-end-of-stream
 iterators are equal when they are constructed from the same stream.
 ``` cpp
 namespace std {
   template <class T, class charT = char, class traits = char_traits<charT>,
       class Distance = ptrdiff_t>
+  class istream_iterator {
   public:
+ using iterator_category = input_iterator_tag;
+ using value_type        = T;
+ using difference_type   = Distance;
+ using pointer           = const T*;
+    using reference         = const T&;
+    using char_type         = charT;
+    using traits_type       = traits;
+    using istream_type      = basic_istream<charT,traits>;
+    constexpr istream_iterator();
     istream_iterator(istream_type& s);
     istream_iterator(const istream_iterator& x) = default;
     ~istream_iterator() = default;
     const T& operator*() const;
     const T* operator->() const;
+    istream_iterator& operator++();
+    istream_iterator  operator++(int);
   private:
     basic_istream<charT,traits>* in_stream; // exposition only
     T value;                                // exposition only
   };
 ```
 #### `istream_iterator` constructors and destructor <a id="istream.iterator.cons">[[istream.iterator.cons]]</a>
 ``` cpp
+constexpr istream_iterator();
 ```
+*Effects:* Constructs the end-of-stream iterator. If
+`is_trivially_default_constructible_v<T>` is `true`, then this
+constructor is a constexpr constructor.
+*Postconditions:* `in_stream == 0`.
 ``` cpp
 istream_iterator(istream_type& s);
 ```
+*Effects:* Initializes `in_stream` with `addressof(s)`. `value` may be
+initialized during construction or the first time it is referenced.
+*Postconditions:* `in_stream == addressof(s)`.
 ``` cpp
 istream_iterator(const istream_iterator& x) = default;
 ```
+*Effects:* Constructs a copy of `x`. If
+`is_trivially_copy_constructible_v<T>` is `true`, then this constructor
+is a trivial copy constructor.
+*Postconditions:* `in_stream == x.in_stream`.
 ``` cpp
 ~istream_iterator() = default;
 ```
+*Effects:* The iterator is destroyed. If
+`is_trivially_destructible_v<T>` is `true`, then this destructor is a
+trivial destructor.
 #### `istream_iterator` operations <a id="istream.iterator.ops">[[istream.iterator.ops]]</a>
 ``` cpp
 const T& operator*() const;
 ```
+*Returns:* `value`.
 ``` cpp
 const T* operator->() const;
 ```
+*Returns:* `addressof(operator*())`.
 ``` cpp
+istream_iterator& operator++();
 ```
 *Requires:* `in_stream != 0`.
+*Effects:* As if by: `*in_stream >> value;`
 *Returns:* `*this`.
 ``` cpp
+istream_iterator operator++(int);
 ```
 *Requires:* `in_stream != 0`.
+*Effects:* As if by:
 ``` cpp
+istream_iterator tmp = *this;
 *in_stream >> value;
 return (tmp);
 ```
 ``` cpp
 is defined as:
 ``` cpp
 namespace std {
   template <class T, class charT = char, class traits = char_traits<charT>>
+  class ostream_iterator {
   public:
+ using iterator_category = output_iterator_tag;
+ using value_type        = void;
+ using difference_type   = void;
+    using pointer           = void;
+    using reference         = void;
+    using char_type         = charT;
+    using traits_type       = traits;
+    using ostream_type      = basic_ostream<charT,traits>;
     ostream_iterator(ostream_type& s);
     ostream_iterator(ostream_type& s, const charT* delimiter);
+    ostream_iterator(const ostream_iterator& x);
     ~ostream_iterator();
+    ostream_iterator& operator=(const T& value);
+    ostream_iterator& operator*();
+    ostream_iterator& operator++();
+    ostream_iterator& operator++(int);
   private:
     basic_ostream<charT,traits>* out_stream;  // exposition only
     const charT* delim;                       // exposition only
   };
 }
 ``` cpp
 ostream_iterator(ostream_type& s);
 ```
+*Effects:* Initializes `out_stream` with `addressof(s)` and `delim` with
+null.
 ``` cpp
 ostream_iterator(ostream_type& s, const charT* delimiter);
 ```
+*Effects:* Initializes `out_stream` with `addressof(s)` and `delim` with
 `delimiter`.
 ``` cpp
 ostream_iterator(const ostream_iterator& x);
 ```
 ``` cpp
 ostream_iterator& operator=(const T& value);
 ```
+*Effects:* As if by:
 ``` cpp
 *out_stream << value;
 if (delim != 0)
   *out_stream << delim;
 ### Class template `istreambuf_iterator` <a id="istreambuf.iterator">[[istreambuf.iterator]]</a>
 The class template `istreambuf_iterator` defines an input iterator (
 [[input.iterators]]) that reads successive *characters* from the
 streambuf for which it was constructed. `operator*` provides access to
+the current input character, if any. Each time `operator++` is
+evaluated, the iterator advances to the next input character. If the end
+of stream is reached (`streambuf_type::sgetc()` returns
+`traits::eof()`), the iterator becomes equal to the *end-of-stream*
+iterator value. The default constructor `istreambuf_iterator()` and the
+constructor `istreambuf_iterator(0)` both construct an end-of-stream
+iterator object suitable for use as an end-of-range. All specializations
+of `istreambuf_iterator` shall have a trivial copy constructor, a
 `constexpr` default constructor, and a trivial destructor.
 The result of `operator*()` on an end-of-stream iterator is undefined.
 For any other iterator value a `char_type` value is returned. It is
 impossible to assign a character via an input iterator.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
+  class istreambuf_iterator {
   public:
+ using iterator_category = input_iterator_tag;
+ using value_type        = charT;
+ using difference_type   = typename traits::off_type;
+ using pointer           = unspecified;
+ using reference         = charT;
+    using char_type         = charT;
+    using traits_type       = traits;
+    using int_type          = typename traits::int_type;
+    using streambuf_type    = basic_streambuf<charT,traits>;
+    using istream_type      = basic_istream<charT,traits>;
     class proxy;                          // exposition only
     constexpr istreambuf_iterator() noexcept;
     istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
     ~istreambuf_iterator() = default;
     istreambuf_iterator(istream_type& s) noexcept;
     istreambuf_iterator(streambuf_type* s) noexcept;
     istreambuf_iterator(const proxy& p) noexcept;
     charT operator*() const;
+ istreambuf_iterator& operator++();
     proxy operator++(int);
     bool equal(const istreambuf_iterator& b) const;
   private:
     streambuf_type* sbuf_;                // exposition only
   };
     bool operator!=(const istreambuf_iterator<charT,traits>& a,
             const istreambuf_iterator<charT,traits>& b);
 }
 ```
+#### Class template `istreambuf_iterator::proxy` <a id="istreambuf.iterator.proxy">[[istreambuf.iterator.proxy]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class istreambuf_iterator<charT, traits>::proxy { // exposition only
 (`operator++`). It keeps the character pointed to by the previous value
 of the iterator for some possible future access to get the character.
 #### `istreambuf_iterator` constructors <a id="istreambuf.iterator.cons">[[istreambuf.iterator.cons]]</a>
+For each `istreambuf_iterator` constructor in this section, an
+end-of-stream iterator is constructed if and only if the exposition-only
+member `sbuf_` is initialized with a null pointer value.
 ``` cpp
 constexpr istreambuf_iterator() noexcept;
 ```
+*Effects:* Initializes `sbuf_` with `nullptr`.
 ``` cpp
+istreambuf_iterator(istream_type& s) noexcept;
 ```
+*Effects:* Initializes `sbuf_` with `s.rdbuf()`.
+``` cpp
+istreambuf_iterator(streambuf_type* s) noexcept;
+```
+*Effects:* Initializes `sbuf_` with `s`.
 ``` cpp
 istreambuf_iterator(const proxy& p) noexcept;
 ```
+*Effects:* Initializes `sbuf_` with `p.sbuf_`.
+#### `istreambuf_iterator` operations <a id="istreambuf.iterator.ops">[[istreambuf.iterator.ops]]</a>
 ``` cpp
 charT operator*() const
 ```
 *Returns:* The character obtained via the `streambuf` member
 `sbuf_->sgetc()`.
 ``` cpp
+istreambuf_iterator& operator++();
 ```
+*Effects:* As if by `sbuf_->sbumpc()`.
 *Returns:* `*this`.
 ``` cpp
+proxy operator++(int);
 ```
 *Returns:* `proxy(sbuf_->sbumpc(), sbuf_)`.
 ``` cpp
+bool equal(const istreambuf_iterator& b) const;
 ```
 *Returns:* `true` if and only if both iterators are at end-of-stream, or
 neither is at end-of-stream, regardless of what `streambuf` object they
 use.
 ``` cpp
 template <class charT, class traits>
   bool operator==(const istreambuf_iterator<charT,traits>& a,
                   const istreambuf_iterator<charT,traits>& b);
 ```
 *Returns:* `a.equal(b)`.
 ``` cpp
 template <class charT, class traits>
   bool operator!=(const istreambuf_iterator<charT,traits>& a,
                   const istreambuf_iterator<charT,traits>& b);
 ```
 ### Class template `ostreambuf_iterator` <a id="ostreambuf.iterator">[[ostreambuf.iterator]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
+  class ostreambuf_iterator {
   public:
+ using iterator_category = output_iterator_tag;
+ using value_type        = void;
+ using difference_type   = void;
+ using pointer           = void;
+    using reference         = void;
+    using char_type         = charT;
+    using traits_type       = traits;
+    using streambuf_type    = basic_streambuf<charT,traits>;
+    using ostream_type      = basic_ostream<charT,traits>;
     ostreambuf_iterator(ostream_type& s) noexcept;
     ostreambuf_iterator(streambuf_type* s) noexcept;
     ostreambuf_iterator& operator=(charT c);
     ostreambuf_iterator& operator*();
 *Effects:* Initializes `sbuf_` with `s`.
 #### `ostreambuf_iterator` operations <a id="ostreambuf.iter.ops">[[ostreambuf.iter.ops]]</a>
 ``` cpp
+ostreambuf_iterator& operator=(charT c);
 ```
 *Effects:* If `failed()` yields `false`, calls `sbuf_->sputc(c)`;
 otherwise has no effect.
 *Returns:* `*this`.
 ``` cpp
+ostreambuf_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+ostreambuf_iterator& operator++();
+ostreambuf_iterator& operator++(int);
 ```
 *Returns:* `*this`.
 ``` cpp

Diff to HTML by rtfpessoa