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

Files changed (1) hide show

tmp/tmpb98v2f9f/{from.md → to.md} +69 -77

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

@@ -9,94 +9,91 @@ identity: `&*(reverse_iterator(i)) == &*(i - 1)`.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Iterator>
-  class reverse_iterator : public
-        iterator<typename iterator_traits<Iterator>::iterator_category,
-        typename iterator_traits<Iterator>::value_type,
-        typename iterator_traits<Iterator>::difference_type,
-        typename iterator_traits<Iterator>::pointer,
-        typename iterator_traits<Iterator>::reference> {
   public:
- typedef Iterator                                            iterator_type;
- typedef typename iterator_traits<Iterator>::difference_type difference_type;
- typedef typename iterator_traits<Iterator>::reference       reference;
- typedef typename iterator_traits<Iterator>::pointer         pointer;
-    reverse_iterator();
-    explicit reverse_iterator(Iterator x);
-    template <class U> reverse_iterator(const reverse_iterator<U>& u);
-    template <class U> reverse_iterator& operator=(const reverse_iterator<U>& u);
-    Iterator base() const;      // explicit
-    reference operator*() const;
-    pointer   operator->() const;
-    reverse_iterator& operator++();
-    reverse_iterator  operator++(int);
-    reverse_iterator& operator--();
-    reverse_iterator  operator--(int);
-    reverse_iterator  operator+ (difference_type n) const;
-    reverse_iterator& operator+=(difference_type n);
-    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<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator!=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<=(
       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>
 The template parameter `Iterator` shall meet all the requirements of a
 Bidirectional Iterator ([[bidirectional.iterators]]).
-Additionally, `Iterator` shall meet the requirements of a Random Access
-Iterator ([[random.access.iterators]]) if any of the members
 `operator+` ([[reverse.iter.op+]]), `operator-` (
 [[reverse.iter.op-]]), `operator+=` ([[reverse.iter.op+=]]),
 `operator-=` ([[reverse.iter.op-=]]), `operator[]` (
-[[reverse.iter.opindex]]), or the global operators `operator<` (
 [[reverse.iter.op<]]), `operator>` ([[reverse.iter.op>]]),
 `operator<=` ([[reverse.iter.op<=]]), `operator>=` (
 [[reverse.iter.op>=]]), `operator-` ([[reverse.iter.opdiff]]) or
 `operator+` ([[reverse.iter.opsum]]) are referenced in a way that
 requires instantiation ([[temp.inst]]).
@@ -104,256 +101,251 @@ requires instantiation ([[temp.inst]]).
 #### `reverse_iterator` operations <a id="reverse.iter.ops">[[reverse.iter.ops]]</a>
 ##### `reverse_iterator` constructor <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
 ``` cpp
-reverse_iterator();
 ```
-*Effects:* Value initializes `current`. Iterator operations applied to
 the resulting iterator have defined behavior if and only if the
 corresponding operations are defined on a value-initialized iterator of
 type `Iterator`.
 ``` cpp
-explicit reverse_iterator(Iterator x);
 ```
 *Effects:* Initializes `current` with `x`.
 ``` cpp
-template <class U> reverse_iterator(const reverse_iterator<U> &u);
 ```
 *Effects:* Initializes `current` with `u.current`.
 ##### `reverse_iterator::operator=` <a id="reverse.iter.op=">[[reverse.iter.op=]]</a>
 ``` cpp
 template <class U>
-reverse_iterator&
   operator=(const reverse_iterator<U>& u);
 ```
 *Effects:* Assigns `u.base()` to current.
 *Returns:* `*this`.
 ##### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
-Iterator base() const;          // explicit
 ```
 *Returns:* `current`.
 ##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
 ``` cpp
-reference operator*() const;
 ```
-*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++();
 ```
-*Effects:* `current;`
 *Returns:* `*this`.
 ``` cpp
-reverse_iterator operator++(int);
 ```
-*Effects:*
 ``` cpp
 reverse_iterator tmp = *this;
 --current;
 return tmp;
 ```
 \[reverse.iter.op\]`operator\dcr`
 ``` cpp
-reverse_iterator& operator--();
 ```
-*Effects:* `++current`
 *Returns:* `*this`.
 ``` cpp
-reverse_iterator operator--(int);
 ```
-*Effects:*
 ``` cpp
 reverse_iterator tmp = *this;
 ++current;
 return tmp;
 ```
 ##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
 ``` cpp
-reverse_iterator
-operator+(typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current-n)`.
 ##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
 ``` cpp
-reverse_iterator&
-operator+=(typename reverse_iterator<Iterator>::difference_type n);
 ```
-*Effects:* `current -= n;`
 *Returns:* `*this`.
 ##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
 ``` cpp
-reverse_iterator
-operator-(typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current+n)`.
 ##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
 ``` cpp
-reverse_iterator&
-operator-=(typename reverse_iterator<Iterator>::difference_type n);
 ```
-*Effects:* `current += n;`
 *Returns:* `*this`.
 ##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
 ``` cpp
-unspecified operator[](
-    typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `current[-n-1]`.
 ##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator==(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current == y.current`.
 ##### `operator<` <a id="reverse.iter.op<">[[reverse.iter.op<]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator<(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current > y.current`.
 ##### `operator!=` <a id="reverse.iter.op!=">[[reverse.iter.op!=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator!=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current != y.current`.
 ##### `operator>` <a id="reverse.iter.op>">[[reverse.iter.op>]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator>(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current < y.current`.
 ##### `operator>=` <a id="reverse.iter.op>=">[[reverse.iter.op>=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator>=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current <= y.current`.
 ##### `operator<=` <a id="reverse.iter.op<=">[[reverse.iter.op<=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  bool operator<=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current >= y.current`.
 ##### `operator-` <a id="reverse.iter.opdiff">[[reverse.iter.opdiff]]</a>
 ``` 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>
 ``` cpp
 template <class Iterator>
-  reverse_iterator<Iterator> operator+(
     typename reverse_iterator<Iterator>::difference_type n,
     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)`.

 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Iterator>
+  class reverse_iterator {
   public:
+ using iterator_type     = Iterator;
+ using iterator_category = typename iterator_traits<Iterator>::iterator_category;
+ using value_type        = typename iterator_traits<Iterator>::value_type;
+ using difference_type   = typename iterator_traits<Iterator>::difference_type;
+    using pointer           = typename iterator_traits<Iterator>::pointer;
+    using reference         = typename iterator_traits<Iterator>::reference;
+ constexpr reverse_iterator();
+ constexpr explicit reverse_iterator(Iterator x);
+    template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
+    template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
+ constexpr Iterator base() const;      // explicit
+ constexpr reference operator*() const;
+ constexpr pointer   operator->() const;
+ constexpr reverse_iterator& operator++();
+ constexpr reverse_iterator  operator++(int);
+ constexpr reverse_iterator& operator--();
+ constexpr reverse_iterator  operator--(int);
+ constexpr reverse_iterator  operator+ (difference_type n) const;
+ constexpr reverse_iterator& operator+=(difference_type n);
+ constexpr reverse_iterator  operator- (difference_type n) const;
+ constexpr reverse_iterator& operator-=(difference_type n);
+ constexpr unspecified operator[](difference_type n) const;
   protected:
     Iterator current;
   };
   template <class Iterator1, class Iterator2>
+ constexpr bool operator==(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr bool operator<(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr bool operator!=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr bool operator>(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr bool operator>=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr bool operator<=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
+ constexpr auto operator-(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
   template <class Iterator>
+ constexpr reverse_iterator<Iterator> operator+(
       typename reverse_iterator<Iterator>::difference_type n,
       const reverse_iterator<Iterator>& x);
   template <class Iterator>
+ constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 }
 ```
 #### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
 The template parameter `Iterator` shall meet all the requirements of a
 Bidirectional Iterator ([[bidirectional.iterators]]).
+Additionally, `Iterator` shall meet the requirements of a random access
+iterator ([[random.access.iterators]]) if any of the members
 `operator+` ([[reverse.iter.op+]]), `operator-` (
 [[reverse.iter.op-]]), `operator+=` ([[reverse.iter.op+=]]),
 `operator-=` ([[reverse.iter.op-=]]), `operator[]` (
+[[reverse.iter.opindex]]), or the non-member operators `operator<` (
 [[reverse.iter.op<]]), `operator>` ([[reverse.iter.op>]]),
 `operator<=` ([[reverse.iter.op<=]]), `operator>=` (
 [[reverse.iter.op>=]]), `operator-` ([[reverse.iter.opdiff]]) or
 `operator+` ([[reverse.iter.opsum]]) are referenced in a way that
 requires instantiation ([[temp.inst]]).
 #### `reverse_iterator` operations <a id="reverse.iter.ops">[[reverse.iter.ops]]</a>
 ##### `reverse_iterator` constructor <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
 ``` cpp
+constexpr reverse_iterator();
 ```
+*Effects:* Value-initializes `current`. Iterator operations applied to
 the resulting iterator have defined behavior if and only if the
 corresponding operations are defined on a value-initialized iterator of
 type `Iterator`.
 ``` cpp
+constexpr explicit reverse_iterator(Iterator x);
 ```
 *Effects:* Initializes `current` with `x`.
 ``` cpp
+template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
 *Effects:* Initializes `current` with `u.current`.
 ##### `reverse_iterator::operator=` <a id="reverse.iter.op=">[[reverse.iter.op=]]</a>
 ``` cpp
 template <class U>
+constexpr reverse_iterator&
   operator=(const reverse_iterator<U>& u);
 ```
 *Effects:* Assigns `u.base()` to current.
 *Returns:* `*this`.
 ##### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
+constexpr Iterator base() const;          // explicit
 ```
 *Returns:* `current`.
 ##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
 ``` cpp
+constexpr reference operator*() const;
 ```
+*Effects:* As if by:
 ``` cpp
 Iterator tmp = current;
 return *--tmp;
 ```
 ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
 ``` cpp
+constexpr pointer operator->() const;
 ```
+*Returns:* `addressof(operator*())`.
 ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
 ``` cpp
+constexpr reverse_iterator& operator++();
 ```
+*Effects:* As if by: `current;`
 *Returns:* `*this`.
 ``` cpp
+constexpr reverse_iterator operator++(int);
 ```
+*Effects:* As if by:
 ``` cpp
 reverse_iterator tmp = *this;
 --current;
 return tmp;
 ```
 \[reverse.iter.op\]`operator\dcr`
 ``` cpp
+constexpr reverse_iterator& operator--();
 ```
+*Effects:* As if by `++current`.
 *Returns:* `*this`.
 ``` cpp
+constexpr reverse_iterator operator--(int);
 ```
+*Effects:* As if by:
 ``` cpp
 reverse_iterator tmp = *this;
 ++current;
 return tmp;
 ```
 ##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
 ``` cpp
+constexpr reverse_iterator operator+(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current-n)`.
 ##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
 ``` cpp
+constexpr reverse_iterator& operator+=(difference_type n);
 ```
+*Effects:* As if by: `current -= n;`
 *Returns:* `*this`.
 ##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
 ``` cpp
+constexpr reverse_iterator operator-(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current+n)`.
 ##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
 ``` cpp
+constexpr reverse_iterator& operator-=(difference_type n);
 ```
+*Effects:* As if by: `current += n;`
 *Returns:* `*this`.
 ##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
 ``` cpp
+constexpr unspecified operator[](difference_type n) const;
 ```
 *Returns:* `current[-n-1]`.
 ##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator==(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current == y.current`.
 ##### `operator<` <a id="reverse.iter.op<">[[reverse.iter.op<]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator<(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current > y.current`.
 ##### `operator!=` <a id="reverse.iter.op!=">[[reverse.iter.op!=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator!=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current != y.current`.
 ##### `operator>` <a id="reverse.iter.op>">[[reverse.iter.op>]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator>(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current < y.current`.
 ##### `operator>=` <a id="reverse.iter.op>=">[[reverse.iter.op>=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator>=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current <= y.current`.
 ##### `operator<=` <a id="reverse.iter.op<=">[[reverse.iter.op<=]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr bool operator<=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
 *Returns:* `x.current >= y.current`.
 ##### `operator-` <a id="reverse.iter.opdiff">[[reverse.iter.opdiff]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
+ constexpr 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>
 ``` cpp
 template <class Iterator>
+ constexpr reverse_iterator<Iterator> operator+(
     typename reverse_iterator<Iterator>::difference_type n,
     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>
+ constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 ```
 *Returns:* `reverse_iterator<Iterator>(i)`.

Diff to HTML by rtfpessoa