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

Files changed (1) hide show

tmp/tmpq1wj1vm9/{from.md → to.md} +127 -159

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

@@ -17,31 +17,13 @@ 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
-constructed, and every time `++` is used, the iterator reads and stores
-a value of `T`. If the iterator fails to read and store a value of `T`
-(`fail()` on the stream returns `true`), the iterator becomes equal to
-the *end-of-stream* iterator value. The constructor with no arguments
-`istream_iterator()` always constructs an end-of-stream input iterator
-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. 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>
@@ -55,107 +37,117 @@ namespace std {
     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
   };
-  template <class T, class charT, class traits, class Distance>
-    bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
-            const istream_iterator<T,charT,traits,Distance>& y);
-  template <class T, class charT, class traits, class Distance>
-    bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
-            const istream_iterator<T,charT,traits,Distance>& y);
 }
 ```
-#### `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
 template<class T, class charT, class traits, class Distance>
   bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
@@ -163,104 +155,82 @@ template <class T, class charT, class traits, class Distance>
 ```
 *Returns:* `x.in_stream == y.in_stream`.
 ``` cpp
-template <class T, class charT, class traits, class Distance>
-  bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
-                  const istream_iterator<T,charT,traits,Distance>& y);
 ```
-*Returns:* `!(x == y)`
 ### Class template `ostream_iterator` <a id="ostream.iterator">[[ostream.iterator]]</a>
 `ostream_iterator` writes (using `operator<<`) successive elements onto
 the output stream from which it was constructed. If it was constructed
 with `charT*` as a constructor argument, this string, called a
 *delimiter string*, is written to the stream after every `T` is written.
-It is not possible to get a value out of the output iterator. Its only
-use is as an output iterator in situations like
-``` cpp
-while (first != last)
-  *result++ = *first++;
-```
-`ostream_iterator`
-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
   };
 }
 ```
-#### `ostream_iterator` constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
 ``` 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);
-```
-*Effects:* Constructs a copy of `x`.
-``` cpp
-~ostream_iterator();
-```
-*Effects:* The iterator is destroyed.
-#### `ostream_iterator` operations <a id="ostream.iterator.ops">[[ostream.iterator.ops]]</a>
 ``` cpp
 ostream_iterator& operator=(const T& value);
 ```
 *Effects:* As if by:
 ``` cpp
 *out_stream << value;
-if (delim != 0)
   *out_stream << delim;
 return *this;
 ```
 ``` cpp
@@ -276,22 +246,23 @@ ostream_iterator& operator++(int);
 *Returns:* `*this`.
 ### 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.
@@ -312,64 +283,63 @@ namespace std {
     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
   };
-  template <class charT, class traits>
-    bool operator==(const istreambuf_iterator<charT,traits>& a,
-            const istreambuf_iterator<charT,traits>& b);
-  template <class charT, class traits>
-    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
-    charT keep_;
-    basic_streambuf<charT,traits>* sbuf_;
-    proxy(charT c, basic_streambuf<charT,traits>* sbuf)
-      : keep_(c), sbuf_(sbuf) { }
-  public:
-    charT operator*() { return keep_; }
-  };
-}
-```
 Class `istreambuf_iterator<charT,traits>::proxy` is for exposition only.
 An implementation is permitted to provide equivalent functionality
 without providing a class with this name. Class
 `istreambuf_iterator<charT, traits>::proxy` provides a temporary
 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>
-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
@@ -388,14 +358,14 @@ istreambuf_iterator(streambuf_type* s) noexcept;
 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()`.
@@ -409,11 +379,11 @@ istreambuf_iterator& operator++();
 ``` cpp
 proxy operator++(int);
 ```
-*Returns:* `proxy(sbuf_->sbumpc(), sbuf_)`.
 ``` cpp
 bool equal(const istreambuf_iterator& b) const;
 ```
@@ -428,72 +398,70 @@ template <class charT, class traits>
 ```
 *Returns:* `a.equal(b)`.
 ``` cpp
-template <class charT, class traits>
-  bool operator!=(const istreambuf_iterator<charT,traits>& a,
-                  const istreambuf_iterator<charT,traits>& b);
 ```
-*Returns:* `!a.equal(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*();
-    ostreambuf_iterator& operator++();
-    ostreambuf_iterator& operator++(int);
-    bool failed() const noexcept;
-  private:
-    streambuf_type* sbuf_;                // exposition only
-  };
-}
-```
 The class template `ostreambuf_iterator` writes successive *characters*
-onto the output stream from which it was constructed. It is not possible
-to get a character value out of the output iterator.
-#### `ostreambuf_iterator` constructors <a id="ostreambuf.iter.cons">[[ostreambuf.iter.cons]]</a>
 ``` cpp
 ostreambuf_iterator(ostream_type& s) noexcept;
 ```
-*Requires:* `s.rdbuf()` shall not be a null pointer.
 *Effects:* Initializes `sbuf_` with `s.rdbuf()`.
 ``` cpp
 ostreambuf_iterator(streambuf_type* s) noexcept;
 ```
-*Requires:* `s` shall not be a null pointer.
 *Effects:* Initializes `sbuf_` with `s`.
-#### `ostreambuf_iterator` operations <a id="ostreambuf.iter.ops">[[ostreambuf.iter.ops]]</a>
 ``` cpp
 ostreambuf_iterator& operator=(charT c);
 ```

 — *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 successive elements from the input stream
+for which it was constructed.
 ``` cpp
 namespace std {
   template<class T, class charT = char, class traits = char_traits<charT>,
            class Distance = ptrdiff_t>
     using char_type         = charT;
     using traits_type       = traits;
     using istream_type      = basic_istream<charT,traits>;
     constexpr istream_iterator();
+    constexpr istream_iterator(default_sentinel_t);
     istream_iterator(istream_type& s);
     istream_iterator(const istream_iterator& x) = default;
     ~istream_iterator() = default;
+    istream_iterator& operator=(const istream_iterator&) = default;
     const T& operator*() const;
     const T* operator->() const;
     istream_iterator& operator++();
     istream_iterator  operator++(int);
+    friend bool operator==(const istream_iterator& i, default_sentinel_t);
   private:
     basic_istream<charT,traits>* in_stream; // exposition only
     T value;                                // exposition only
   };
 }
 ```
+The type `T` shall meet the *Cpp17DefaultConstructible*,
+*Cpp17CopyConstructible*, and *Cpp17CopyAssignable* requirements.
+#### Constructors and destructor <a id="istream.iterator.cons">[[istream.iterator.cons]]</a>
 ``` cpp
 constexpr istream_iterator();
+constexpr istream_iterator(default_sentinel_t);
 ```
+*Effects:* Constructs the end-of-stream iterator, value-initializing
+`value`.
+*Ensures:* `in_stream == nullptr` is `true`.
+*Remarks:* If the initializer `T()` in the declaration `auto x = T();`
+is a constant initializer [[expr.const]], then these constructors are
+`constexpr` constructors.
 ``` cpp
 istream_iterator(istream_type& s);
 ```
+*Effects:* Initializes `in_stream` with `addressof(s)`,
+value-initializes `value`, and then calls `operator++()`.
 ``` cpp
 istream_iterator(const istream_iterator& x) = default;
 ```
+*Ensures:* `in_stream == x.in_stream` is `true`.
+*Remarks:* If `is_trivially_copy_constructible_v<T>` is `true`, then
+this constructor is trivial.
 ``` cpp
 ~istream_iterator() = default;
 ```
+*Remarks:* If `is_trivially_destructible_v<T>` is `true`, then this
+destructor is trivial.
+#### Operations <a id="istream.iterator.ops">[[istream.iterator.ops]]</a>
 ``` cpp
 const T& operator*() const;
 ```
+*Preconditions:* `in_stream != nullptr` is `true`.
 *Returns:* `value`.
 ``` cpp
 const T* operator->() const;
 ```
+*Preconditions:* `in_stream != nullptr` is `true`.
+*Returns:* `addressof(value)`.
 ``` cpp
 istream_iterator& operator++();
 ```
+*Preconditions:* `in_stream != nullptr` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (!(*in_stream >> value))
+  in_stream = nullptr;
+```
 *Returns:* `*this`.
 ``` cpp
 istream_iterator operator++(int);
 ```
+*Preconditions:* `in_stream != nullptr` is `true`.
+*Effects:* Equivalent to:
 ``` cpp
 istream_iterator tmp = *this;
+++*this;
+return tmp;
 ```
 ``` cpp
 template<class T, class charT, class traits, class Distance>
   bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
 ```
 *Returns:* `x.in_stream == y.in_stream`.
 ``` cpp
+friend bool operator==(const istream_iterator& i, default_sentinel_t);
 ```
+*Returns:* `!i.in_stream`.
 ### Class template `ostream_iterator` <a id="ostream.iterator">[[ostream.iterator]]</a>
 `ostream_iterator` writes (using `operator<<`) successive elements onto
 the output stream from which it was constructed. If it was constructed
 with `charT*` as a constructor argument, this string, called a
 *delimiter string*, is written to the stream after every `T` is written.
 ``` 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   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using char_type         = charT;
     using traits_type       = traits;
     using ostream_type      = basic_ostream<charT,traits>;
+    constexpr ostream_iterator() noexcept = default;
     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 ostream_iterator&) = default;
     ostream_iterator& operator=(const T& value);
     ostream_iterator& operator*();
     ostream_iterator& operator++();
     ostream_iterator& operator++(int);
   private:
+    basic_ostream<charT,traits>* out_stream = nullptr; // exposition only
+    const charT* delim = nullptr; // exposition only
   };
 }
 ```
+#### Constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
 ``` cpp
 ostream_iterator(ostream_type& s);
 ```
 *Effects:* Initializes `out_stream` with `addressof(s)` and `delim` with
+`nullptr`.
 ``` cpp
 ostream_iterator(ostream_type& s, const charT* delimiter);
 ```
 *Effects:* Initializes `out_stream` with `addressof(s)` and `delim` with
 `delimiter`.
+#### Operations <a id="ostream.iterator.ops">[[ostream.iterator.ops]]</a>
 ``` cpp
 ostream_iterator& operator=(const T& value);
 ```
 *Effects:* As if by:
 ``` cpp
 *out_stream << value;
+if (delim)
   *out_stream << delim;
 return *this;
 ```
 ``` cpp
 *Returns:* `*this`.
 ### 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(nullptr)` 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.
     using istream_type      = basic_istream<charT,traits>;
     class proxy;                          // exposition only
     constexpr istreambuf_iterator() noexcept;
+    constexpr istreambuf_iterator(default_sentinel_t) 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;
+    istreambuf_iterator& operator=(const istreambuf_iterator&) noexcept = default;
     charT operator*() const;
     istreambuf_iterator& operator++();
     proxy operator++(int);
     bool equal(const istreambuf_iterator& b) const;
+    friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s);
   private:
     streambuf_type* sbuf_;              // exposition only
   };
 }
 ```
+#### Class `istreambuf_iterator::proxy` <a id="istreambuf.iterator.proxy">[[istreambuf.iterator.proxy]]</a>
 Class `istreambuf_iterator<charT,traits>::proxy` is for exposition only.
 An implementation is permitted to provide equivalent functionality
 without providing a class with this name. Class
 `istreambuf_iterator<charT, traits>::proxy` provides a temporary
 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.
+``` cpp
+namespace std {
+  template<class charT, class traits>
+  class istreambuf_iterator<charT, traits>::proxy { // exposition only
+    charT keep_;
+    basic_streambuf<charT,traits>* sbuf_;
+    proxy(charT c, basic_streambuf<charT,traits>* sbuf)
+      : keep_(c), sbuf_(sbuf) { }
+  public:
+    charT operator*() { return keep_; }
+  };
+}
+```
+#### Constructors <a id="istreambuf.iterator.cons">[[istreambuf.iterator.cons]]</a>
+For each `istreambuf_iterator` constructor in this subclause, 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;
+constexpr istreambuf_iterator(default_sentinel_t) noexcept;
 ```
 *Effects:* Initializes `sbuf_` with `nullptr`.
 ``` cpp
 istreambuf_iterator(const proxy& p) noexcept;
 ```
 *Effects:* Initializes `sbuf_` with `p.sbuf_`.
+#### 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
 proxy operator++(int);
 ```
+*Returns:* *`proxy`*`(sbuf_->sbumpc(), sbuf_)`.
 ``` cpp
 bool equal(const istreambuf_iterator& b) const;
 ```
 ```
 *Returns:* `a.equal(b)`.
 ``` cpp
+friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s);
 ```
+*Returns:* `i.equal(s)`.
 ### Class template `ostreambuf_iterator` <a id="ostreambuf.iterator">[[ostreambuf.iterator]]</a>
 The class template `ostreambuf_iterator` writes successive *characters*
+onto the output stream from which it was constructed.
+``` 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   = ptrdiff_t;
+    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>;
+    constexpr ostreambuf_iterator() noexcept = default;
+    ostreambuf_iterator(ostream_type& s) noexcept;
+    ostreambuf_iterator(streambuf_type* s) noexcept;
+    ostreambuf_iterator& operator=(charT c);
+    ostreambuf_iterator& operator*();
+    ostreambuf_iterator& operator++();
+    ostreambuf_iterator& operator++(int);
+    bool failed() const noexcept;
+  private:
+    streambuf_type* sbuf_ = nullptr;    // exposition only
+  };
+}
+```
+#### Constructors <a id="ostreambuf.iter.cons">[[ostreambuf.iter.cons]]</a>
 ``` cpp
 ostreambuf_iterator(ostream_type& s) noexcept;
 ```
+*Preconditions:* `s.rdbuf()` is not a null pointer.
 *Effects:* Initializes `sbuf_` with `s.rdbuf()`.
 ``` cpp
 ostreambuf_iterator(streambuf_type* s) noexcept;
 ```
+*Preconditions:* `s` is not a null pointer.
 *Effects:* Initializes `sbuf_` with `s`.
+#### Operations <a id="ostreambuf.iter.ops">[[ostreambuf.iter.ops]]</a>
 ``` cpp
 ostreambuf_iterator& operator=(charT c);
 ```

Diff to HTML by rtfpessoa