[iterators] - C++11 → C++14

Files changed (1) hide show

tmp/tmpu9_vh3x3/{from.md → to.md} +137 -62

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

@@ -200,11 +200,14 @@ iterator if
 - the expressions in Table  [[tab:iterator.forward.requirements]] are
   valid and have the indicated semantics, and
 - objects of type `X` offer the multi-pass guarantee, described below.
 The domain of == for forward iterators is that of iterators over the
-same underlying sequence.
 Two dereferenceable iterators `a` and `b` of type `X` offer the
 *multi-pass guarantee* if:
 - `a == b` implies `++a == ++b` and
@@ -306,10 +309,13 @@ namespace std {
     reverse_iterator<Iterator>
       operator+(
     typename reverse_iterator<Iterator>::difference_type n,
     const reverse_iterator<Iterator>& x);
   template <class Container> class back_insert_iterator;
   template <class Container>
     back_insert_iterator<Container> back_inserter(Container& x);
   template <class Container> class front_insert_iterator;
@@ -346,11 +352,11 @@ namespace std {
     const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
   template <class Iterator>
     move_iterator<Iterator> operator+(
       typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
   template <class Iterator>
-    move_iterator<Iterator> make_move_iterator(const Iterator& i);
   // [stream.iterators], stream iterators:
   template <class T, class charT = char, class traits = char_traits<charT>,
       class Distance = ptrdiff_t>
   class istream_iterator;
@@ -379,12 +385,26 @@ namespace std {
   // [iterator.range], range access:
   template <class C> auto begin(C& c) -> decltype(c.begin());
   template <class C> auto begin(const C& c) -> decltype(c.begin());
   template <class C> auto end(C& c) -> decltype(c.end());
   template <class C> auto end(const C& c) -> decltype(c.end());
-  template <class T, size_t N> T* begin(T (&array)[N]);
-  template <class T, size_t N> T* end(T (&array)[N]);
 }
 ```
 ## Iterator primitives <a id="iterator.primitives">[[iterator.primitives]]</a>
@@ -465,24 +485,10 @@ namespace std {
     typedef random_access_iterator_tag iterator_category;
   };
 }
 ```
-If there is an additional pointer type ` \xname{far}` such that the
-difference of two ` \xname{far}` is of type `long`, an implementation
-may define
-``` cpp
-template<class T> struct iterator_traits<T __far*> {
-    typedef long difference_type;
-    typedef T value_type;
-    typedef T __far* pointer;
-    typedef T __far& reference;
-    typedef random_access_iterator_tag iterator_category;
-  };
-```
 To implement a generic `reverse` function, a C++program can do the
 following:
 ``` cpp
 template <class BidirectionalIterator>
@@ -693,12 +699,10 @@ namespace std {
     reverse_iterator  operator- (difference_type n) const;
     reverse_iterator& operator-=(difference_type n);
     unspecified operator[](difference_type n) const;
   protected:
     Iterator current;
-  private:
-    Iterator deref_tmp;         // exposition only
   };
   template <class Iterator1, class Iterator2>
     bool operator==(
       const reverse_iterator<Iterator1>& x,
@@ -724,15 +728,18 @@ namespace std {
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
     auto operator-(
       const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y) -> decltype(y.current - x.current);
   template <class Iterator>
     reverse_iterator<Iterator> operator+(
       typename reverse_iterator<Iterator>::difference_type n,
       const reverse_iterator<Iterator>& x);
 }
 ```
 #### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
@@ -803,27 +810,21 @@ reference operator*() const;
 ```
 *Effects:*
 ``` cpp
-deref_tmp = current;
---deref_tmp;
-return *deref_tmp;
 ```
-This operation must use an auxiliary member variable rather than a
-temporary variable to avoid returning a reference that persists beyond
-the lifetime of its associated iterator.
-(See  [[iterator.requirements]].)
 ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
 ``` cpp
 pointer operator->() const;
 ```
-*Returns:* `&(operator*())`.
 ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
 ``` cpp
 reverse_iterator& operator++();
@@ -986,11 +987,11 @@ template <class Iterator1, class Iterator2>
 ``` cpp
 template <class Iterator1, class Iterator2>
     auto operator-(
     const reverse_iterator<Iterator1>& x,
-    const reverse_iterator<Iterator2>& y) -> decltype(y.current - x.current);
 ```
 *Returns:* `y.current - x.current`.
 ##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
@@ -1002,10 +1003,19 @@ template <class Iterator>
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator> (x.current - n)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
@@ -1069,11 +1079,11 @@ namespace std {
 ``` cpp
 explicit back_insert_iterator(Container& x);
 ```
-*Effects:* Initializes `container` with `&x`.
 ##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
 ``` cpp
 back_insert_iterator<Container>&
@@ -1153,11 +1163,11 @@ namespace std {
 ``` cpp
 explicit front_insert_iterator(Container& x);
 ```
-*Effects:* Initializes `container` with `&x`.
 ##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
 ``` cpp
 front_insert_iterator<Container>&
@@ -1238,11 +1248,12 @@ namespace std {
 ``` cpp
 insert_iterator(Container& x, typename Container::iterator i);
 ```
-*Effects:* Initializes `container` with `&x` and `iter` with `i`.
 ##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
 ``` cpp
 insert_iterator<Container>&
@@ -1299,13 +1310,13 @@ template <class Container>
 *Returns:* `insert_iterator<Container>(x, i)`.
 ### Move iterators <a id="move.iterators">[[move.iterators]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
-behavior as the underlying iterator except that its dereference operator
 implicitly converts the value returned by the underlying iterator’s
-dereference operator to an rvalue reference. Some generic algorithms can
 be called with move iterators to replace copying with moving.
 ``` cpp
 list<string> s;
 // populate the list s
@@ -1377,11 +1388,11 @@ namespace std {
       const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
   template <class Iterator>
     move_iterator<Iterator> operator+(
       typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
   template <class Iterator>
-    move_iterator<Iterator> make_move_iterator(const Iterator& i);
 }
 ```
 #### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
@@ -1606,11 +1617,11 @@ template <class Iterator>
 *Returns:* `x + n`.
 ``` cpp
 template <class Iterator>
-move_iterator<Iterator> make_move_iterator(const Iterator& i);
 ```
 *Returns:* `move_iterator<Iterator>(i)`.
 ## Stream iterators <a id="stream.iterators">[[stream.iterators]]</a>
@@ -1618,11 +1629,11 @@ move_iterator<Iterator> make_move_iterator(const Iterator& i);
 To make it possible for algorithmic templates to work directly with
 input/output streams, appropriate iterator-like class templates are
 provided.
 ``` cpp
-partial_sum_copy(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
@@ -1809,11 +1820,11 @@ namespace std {
     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 onlyr
   };
 }
 ```
 #### `ostream_iterator` constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
@@ -1853,11 +1864,11 @@ ostream_iterator& operator=(const T& value);
 ``` cpp
 *out_stream << value;
 if (delim != 0)
   *out_stream << delim;
-return (*this);
 ```
 ``` cpp
 ostream_iterator& operator*();
 ```
@@ -1877,17 +1888,17 @@ 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.
@@ -1933,15 +1944,14 @@ namespace std {
 #### 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 {
     charT keep_;
     basic_streambuf<charT,traits>* sbuf_;
-    proxy(charT c,
-      basic_streambuf<charT,traits>* sbuf)
       : keep_(c), sbuf_(sbuf) { }
   public:
     charT operator*() { return keep_; }
   };
 }
@@ -1985,28 +1995,28 @@ constructor argument `p`.
 ``` 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;
@@ -2073,30 +2083,30 @@ to get a character value out of the output iterator.
 ``` cpp
 ostreambuf_iterator(ostream_type& s) noexcept;
 ```
-*Requires:* `s.rdbuf()` shall not null pointer.
-*Effects:* `:sbuf_(s.rdbuf()) {}`.
 ``` cpp
 ostreambuf_iterator(streambuf_type* s) noexcept;
 ```
 *Requires:* `s` shall not be a null pointer.
-*Effects:* `: `*`sbuf_`*`(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
@@ -2115,13 +2125,13 @@ ostreambuf_iterator<charT,traits>& operator++(int);
 ``` cpp
 bool failed() const noexcept;
 ```
 *Returns:* `true` if in any prior use of member `operator=`, the call to
-*`sbuf_`*`->sputc()` returned `traits::eof()`; or `false` otherwise.
-### range access <a id="iterator.range">[[iterator.range]]</a>
 In addition to being available via inclusion of the `<iterator>` header,
 the function templates in [[iterator.range]] are available when any of
 the following headers are included: `<array>`, `<deque>`,
 `<forward_list>`, `<list>`, `<map>`, `<regex>`, `<set>`, `<string>`,
@@ -2140,21 +2150,85 @@ template <class C> auto end(const C& c) -> decltype(c.end());
 ```
 *Returns:* `c.end()`.
 ``` cpp
-template <class T, size_t N> T* begin(T (&array)[N]);
 ```
 *Returns:* `array`.
 ``` cpp
-template <class T, size_t N> T* end(T (&array)[N]);
 ```
 *Returns:* `array + N`.
 <!-- Link reference definitions -->
 [back.insert.iter.cons]: #back.insert.iter.cons
 [back.insert.iter.op*]: #back.insert.iter.op*
 [back.insert.iter.op++]: #back.insert.iter.op++
 [back.insert.iter.op=]: #back.insert.iter.op=
@@ -2232,10 +2306,11 @@ template <class T, size_t N> T* end(T (&array)[N]);
 [output.iterators]: #output.iterators
 [predef.iterators]: #predef.iterators
 [random.access.iterators]: #random.access.iterators
 [reverse.iter.cons]: #reverse.iter.cons
 [reverse.iter.conv]: #reverse.iter.conv
 [reverse.iter.op!=]: #reverse.iter.op!=
 [reverse.iter.op+]: #reverse.iter.op+
 [reverse.iter.op++]: #reverse.iter.op++
 [reverse.iter.op+=]: #reverse.iter.op+=
 [reverse.iter.op-]: #reverse.iter.op-

 - the expressions in Table  [[tab:iterator.forward.requirements]] are
   valid and have the indicated semantics, and
 - objects of type `X` offer the multi-pass guarantee, described below.
 The domain of == for forward iterators is that of iterators over the
+same underlying sequence. However, value-initialized iterators may be
+compared and shall compare equal to other value-initialized iterators of
+the same type. value initialized iterators behave as if they refer past
+the end of the same empty sequence
 Two dereferenceable iterators `a` and `b` of type `X` offer the
 *multi-pass guarantee* if:
 - `a == b` implies `++a == ++b` and
     reverse_iterator<Iterator>
       operator+(
     typename reverse_iterator<Iterator>::difference_type n,
     const reverse_iterator<Iterator>& x);
+  template <class Iterator>
+    reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
   template <class Container> class back_insert_iterator;
   template <class Container>
     back_insert_iterator<Container> back_inserter(Container& x);
   template <class Container> class front_insert_iterator;
     const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
   template <class Iterator>
     move_iterator<Iterator> operator+(
       typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
   template <class Iterator>
+    move_iterator<Iterator> make_move_iterator(Iterator i);
   // [stream.iterators], stream iterators:
   template <class T, class charT = char, class traits = char_traits<charT>,
       class Distance = ptrdiff_t>
   class istream_iterator;
   // [iterator.range], range access:
   template <class C> auto begin(C& c) -> decltype(c.begin());
   template <class C> auto begin(const C& c) -> decltype(c.begin());
   template <class C> auto end(C& c) -> decltype(c.end());
   template <class C> auto end(const C& c) -> decltype(c.end());
+  template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
+  template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
+  template <class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
+    -> decltype(std::begin(c));
+  template <class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
+    -> decltype(std::end(c));
+  template <class C> auto rbegin(C& c) -> decltype(c.rbegin());
+  template <class C> auto rbegin(const C& c) -> decltype(c.rbegin());
+  template <class C> auto rend(C& c) -> decltype(c.rend());
+  template <class C> auto rend(const C& c) -> decltype(c.rend());
+  template <class T, size_t N> reverse_iterator<T*> rbegin(T (&array)[N]);
+  template <class T, size_t N> reverse_iterator<T*> rend(T (&array)[N]);
+  template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il);
+  template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);
+  template <class C> auto crbegin(const C& c) -> decltype(std::rbegin(c));
+  template <class C> auto crend(const C& c) -> decltype(std::rend(c));
 }
 ```
 ## Iterator primitives <a id="iterator.primitives">[[iterator.primitives]]</a>
     typedef random_access_iterator_tag iterator_category;
   };
 }
 ```
 To implement a generic `reverse` function, a C++program can do the
 following:
 ``` cpp
 template <class BidirectionalIterator>
     reverse_iterator  operator- (difference_type n) const;
     reverse_iterator& operator-=(difference_type n);
     unspecified operator[](difference_type n) const;
   protected:
     Iterator current;
   };
   template <class Iterator1, class Iterator2>
     bool operator==(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
     auto operator-(
       const reverse_iterator<Iterator1>& x,
+      const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
   template <class Iterator>
     reverse_iterator<Iterator> operator+(
       typename reverse_iterator<Iterator>::difference_type n,
       const reverse_iterator<Iterator>& x);
+  template <class Iterator>
+    reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 }
 ```
 #### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
 ```
 *Effects:*
 ``` cpp
+Iterator tmp = current;
+return *--tmp;
 ```
 ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
 ``` cpp
 pointer operator->() const;
 ```
+*Returns:* `std::addressof(operator*())`.
 ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
 ``` cpp
 reverse_iterator& operator++();
 ``` cpp
 template <class Iterator1, class Iterator2>
     auto operator-(
     const reverse_iterator<Iterator1>& x,
+    const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
 ```
 *Returns:* `y.current - x.current`.
 ##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator> (x.current - n)`.
+##### Non-member function `make_reverse_iterator()` <a id="reverse.iter.make">[[reverse.iter.make]]</a>
+``` cpp
+template <class Iterator>
+  reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
+```
+*Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
 ``` cpp
 explicit back_insert_iterator(Container& x);
 ```
+*Effects:* Initializes `container` with `std::addressof(x)`.
 ##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
 ``` cpp
 back_insert_iterator<Container>&
 ``` cpp
 explicit front_insert_iterator(Container& x);
 ```
+*Effects:* Initializes `container` with `std::addressof(x)`.
 ##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
 ``` cpp
 front_insert_iterator<Container>&
 ``` cpp
 insert_iterator(Container& x, typename Container::iterator i);
 ```
+*Effects:* Initializes `container` with `std::addressof(x)` and `iter`
+with `i`.
 ##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
 ``` cpp
 insert_iterator<Container>&
 *Returns:* `insert_iterator<Container>(x, i)`.
 ### Move iterators <a id="move.iterators">[[move.iterators]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
+behavior as the underlying iterator except that its indirection operator
 implicitly converts the value returned by the underlying iterator’s
+indirection operator to an rvalue reference. Some generic algorithms can
 be called with move iterators to replace copying with moving.
 ``` cpp
 list<string> s;
 // populate the list s
       const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
   template <class Iterator>
     move_iterator<Iterator> operator+(
       typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
   template <class Iterator>
+    move_iterator<Iterator> make_move_iterator(Iterator i);
 }
 ```
 #### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
 *Returns:* `x + n`.
 ``` cpp
 template <class Iterator>
+move_iterator<Iterator> make_move_iterator(Iterator i);
 ```
 *Returns:* `move_iterator<Iterator>(i)`.
 ## Stream iterators <a id="stream.iterators">[[stream.iterators]]</a>
 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
     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
   };
 }
 ```
 #### `ostream_iterator` constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
 ``` cpp
 *out_stream << value;
 if (delim != 0)
   *out_stream << delim;
+return *this;
 ```
 ``` cpp
 ostream_iterator& operator*();
 ```
 [[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.
 #### 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_; }
   };
 }
 ``` 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;
 ``` 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<charT,traits>&
   operator=(charT c);
 ```
+*Effects:* If `failed()` yields `false`, calls `sbuf_->sputc(c)`;
 otherwise has no effect.
 *Returns:* `*this`.
 ``` cpp
 ``` cpp
 bool failed() const noexcept;
 ```
 *Returns:* `true` if in any prior use of member `operator=`, the call to
+`sbuf_->sputc()` returned `traits::eof()`; or `false` otherwise.
+## range access <a id="iterator.range">[[iterator.range]]</a>
 In addition to being available via inclusion of the `<iterator>` header,
 the function templates in [[iterator.range]] are available when any of
 the following headers are included: `<array>`, `<deque>`,
 `<forward_list>`, `<list>`, `<map>`, `<regex>`, `<set>`, `<string>`,
 ```
 *Returns:* `c.end()`.
 ``` cpp
+template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
 ```
 *Returns:* `array`.
 ``` cpp
+template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
 ```
 *Returns:* `array + N`.
+``` cpp
+template <class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
+  -> decltype(std::begin(c));
+```
+*Returns:* `std::begin(c)`.
+``` cpp
+template <class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
+  -> decltype(std::end(c));
+```
+*Returns:* `std::end(c)`.
+``` cpp
+template <class C> auto rbegin(C& c) -> decltype(c.rbegin());
+template <class C> auto rbegin(const C& c) -> decltype(c.rbegin());
+```
+*Returns:* `c.rbegin()`.
+``` cpp
+template <class C> auto rend(C& c) -> decltype(c.rend());
+template <class C> auto rend(const C& c) -> decltype(c.rend());
+```
+*Returns:* `c.rend()`.
+``` cpp
+template <class T, size_t N> reverse_iterator<T*> rbegin(T (&array)[N]);
+```
+*Returns:* `reverse_iterator<T*>(array + N)`.
+``` cpp
+template <class T, size_t N> reverse_iterator<T*> rend(T (&array)[N]);
+```
+*Returns:* `reverse_iterator<T*>(array)`.
+``` cpp
+template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il);
+```
+*Returns:* `reverse_iterator<const E*>(il.end())`.
+``` cpp
+template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);
+```
+*Returns:* `reverse_iterator<const E*>(il.begin())`.
+``` cpp
+template <class C> auto crbegin(const C& c) -> decltype(std::rbegin(c));
+```
+*Returns:* `std::rbegin(c)`.
+``` cpp
+template <class C> auto crend(const C& c) -> decltype(std::rend(c));
+```
+*Returns:* `std::rend(c)`.
 <!-- Link reference definitions -->
 [back.insert.iter.cons]: #back.insert.iter.cons
 [back.insert.iter.op*]: #back.insert.iter.op*
 [back.insert.iter.op++]: #back.insert.iter.op++
 [back.insert.iter.op=]: #back.insert.iter.op=
 [output.iterators]: #output.iterators
 [predef.iterators]: #predef.iterators
 [random.access.iterators]: #random.access.iterators
 [reverse.iter.cons]: #reverse.iter.cons
 [reverse.iter.conv]: #reverse.iter.conv
+[reverse.iter.make]: #reverse.iter.make
 [reverse.iter.op!=]: #reverse.iter.op!=
 [reverse.iter.op+]: #reverse.iter.op+
 [reverse.iter.op++]: #reverse.iter.op++
 [reverse.iter.op+=]: #reverse.iter.op+=
 [reverse.iter.op-]: #reverse.iter.op-

Diff to HTML by rtfpessoa