[iterator.primitives] - C++14 → C++17

Files changed (1) hide show

tmp/tmp4ep4lvqb/{from.md → to.md} +45 -66

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

@@ -35,52 +35,56 @@ iterator_traits<Iterator>::reference
 iterator_traits<Iterator>::pointer
 ```
 may be defined as `void`.
-The template `iterator_traits<Iterator>` is defined as
 ``` cpp
-namespace std {
- template<class Iterator> struct iterator_traits {
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::iterator_category iterator_category;
-  };
-}
 ```
 It is specialized for pointers as
 ``` cpp
 namespace std {
   template<class T> struct iterator_traits<T*> {
- typedef ptrdiff_t difference_type;
- typedef T value_type;
- typedef T* pointer;
- typedef T& reference;
- typedef random_access_iterator_tag iterator_category;
   };
 }
 ```
 and for pointers to const as
 ``` cpp
 namespace std {
   template<class T> struct iterator_traits<const T*> {
- typedef ptrdiff_t difference_type;
- typedef T value_type;
- typedef const T* pointer;
- typedef const T& 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>
@@ -96,28 +100,11 @@ void reverse(BidirectionalIterator first, BidirectionalIterator last) {
     n -= 2;
   }
 }
 ```
-### Basic iterator <a id="iterator.basic">[[iterator.basic]]</a>
-The `iterator` template may be used as a base class to ease the
-definition of required types for new iterators.
-``` cpp
-namespace std {
-  template<class Category, class T, class Distance = ptrdiff_t,
-    class Pointer = T*, class Reference = T&>
-  struct iterator {
-    typedef T         value_type;
-    typedef Distance  difference_type;
-    typedef Pointer   pointer;
-    typedef Reference reference;
-    typedef Category  iterator_category;
-  };
-}
-```
 ### Standard iterator tags <a id="std.iterator.tags">[[std.iterator.tags]]</a>
 It is often desirable for a function template specialization to find out
 what is the most specific category of its iterator argument, so that the
@@ -138,26 +125,29 @@ namespace std {
   struct bidirectional_iterator_tag: public forward_iterator_tag { };
   struct random_access_iterator_tag: public bidirectional_iterator_tag { };
 }
 ```
 For a program-defined iterator `BinaryTreeIterator`, it could be
 included into the bidirectional iterator category by specializing the
 `iterator_traits` template:
 ``` cpp
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
- typedef std::ptrdiff_t difference_type;
- typedef T value_type;
- typedef T* pointer;
- typedef T& reference;
- typedef bidirectional_iterator_tag iterator_category;
 };
 ```
-Typically, however, it would be easier to derive `BinaryTreeIterator<T>`
-from `iterator<bidirectional_iterator_tag,T,ptrdiff_t,T*,T&>`.
 If `evolve()` is well defined for bidirectional iterators, but can be
 implemented more efficiently for random access iterators, then the
 implementation is as follows:
@@ -180,22 +170,11 @@ void evolve(RandomAccessIterator first, RandomAccessIterator last,
   random_access_iterator_tag) {
   // more efficient, but less generic algorithm
 }
 ```
-If a C++program wants to define a bidirectional iterator for some data
-structure containing `double` and such that it works on a large memory
-model of the implementation, it can do so with:
-``` cpp
-class MyIterator :
-  public iterator<bidirectional_iterator_tag, double, long, T*, T&> {
-  // code implementing ++, etc.
-};
-```
-Then there is no need to specialize the `iterator_traits` template.
 ### Iterator operations <a id="iterator.operations">[[iterator.operations]]</a>
 Since only random access iterators provide `+` and `-` operators, the
 library provides two function templates `advance` and `distance`. These
@@ -203,22 +182,22 @@ function templates use `+` and `-` for random access iterators (and are,
 therefore, constant time for them); for input, forward and bidirectional
 iterators they use `++` to provide linear time implementations.
 ``` cpp
 template <class InputIterator, class Distance>
-  void advance(InputIterator& i, Distance n);
 ```
 *Requires:* `n` shall be negative only for bidirectional and random
 access iterators.
 *Effects:* Increments (or decrements for negative `n`) iterator
 reference `i` by `n`.
 ``` cpp
 template <class InputIterator>
- typename iterator_traits<InputIterator>::difference_type
     distance(InputIterator first, InputIterator last);
 ```
 *Effects:* If `InputIterator` meets the requirements of random access
 iterator, returns `(last - first)`; otherwise, returns the number of
@@ -228,20 +207,20 @@ increments needed to get from `first` to `last`.
 iterator, `last` shall be reachable from `first` or `first` shall be
 reachable from `last`; otherwise, `last` shall be reachable from
 `first`.
 ``` cpp
-template <class ForwardIterator>
- ForwardIterator next(ForwardIterator x,
-    typename std::iterator_traits<ForwardIterator>::difference_type n = 1);
 ```
-*Effects:* Equivalent to `advance(x, n); return x;`
 ``` cpp
 template <class BidirectionalIterator>
-  BidirectionalIterator prev(BidirectionalIterator x,
-    typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1);
 ```
-*Effects:* Equivalent to `advance(x, -n); return x;`

 iterator_traits<Iterator>::pointer
 ```
 may be defined as `void`.
+If `Iterator` has valid ([[temp.deduct]]) member types
+`difference_type`, `value_type`, `pointer`, `reference`, and
+`iterator_category`, `iterator_traits<Iterator>` shall have the
+following as publicly accessible members:
 ``` cpp
+using difference_type   = typename Iterator::difference_type;
+ using value_type        = typename Iterator::value_type;
+  using pointer           = typename Iterator::pointer;
+  using reference         = typename Iterator::reference;
+  using iterator_category = typename Iterator::iterator_category;
 ```
+Otherwise, `iterator_traits<Iterator>` shall have no members by any of
+the above names.
 It is specialized for pointers as
 ``` cpp
 namespace std {
   template<class T> struct iterator_traits<T*> {
+ using difference_type   = ptrdiff_t;
+ using value_type        = T;
+ using pointer           = T*;
+ using reference         = T&;
+ using iterator_category = random_access_iterator_tag;
   };
 }
 ```
 and for pointers to const as
 ``` cpp
 namespace std {
   template<class T> struct iterator_traits<const T*> {
+ using difference_type   = ptrdiff_t;
+ using value_type        = T;
+ using pointer           = const T*;
+ using reference         = const T&;
+ using iterator_category = random_access_iterator_tag;
   };
 }
 ```
+[*Example 1*:
 To implement a generic `reverse` function, a C++program can do the
 following:
 ``` cpp
 template <class BidirectionalIterator>
     n -= 2;
   }
 }
 ```
+— *end example*]
 ### Standard iterator tags <a id="std.iterator.tags">[[std.iterator.tags]]</a>
 It is often desirable for a function template specialization to find out
 what is the most specific category of its iterator argument, so that the
   struct bidirectional_iterator_tag: public forward_iterator_tag { };
   struct random_access_iterator_tag: public bidirectional_iterator_tag { };
 }
 ```
+[*Example 1*:
 For a program-defined iterator `BinaryTreeIterator`, it could be
 included into the bidirectional iterator category by specializing the
 `iterator_traits` template:
 ``` cpp
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
+ using iterator_category = bidirectional_iterator_tag;
+ using difference_type   = ptrdiff_t;
+ using value_type        = T;
+ using pointer           = T*;
+ using reference         = T&;
 };
 ```
+— *end example*]
+[*Example 2*:
 If `evolve()` is well defined for bidirectional iterators, but can be
 implemented more efficiently for random access iterators, then the
 implementation is as follows:
   random_access_iterator_tag) {
   // more efficient, but less generic algorithm
 }
 ```
+— *end example*]
 ### Iterator operations <a id="iterator.operations">[[iterator.operations]]</a>
 Since only random access iterators provide `+` and `-` operators, the
 library provides two function templates `advance` and `distance`. These
 therefore, constant time for them); for input, forward and bidirectional
 iterators they use `++` to provide linear time implementations.
 ``` cpp
 template <class InputIterator, class Distance>
+ constexpr void advance(InputIterator& i, Distance n);
 ```
 *Requires:* `n` shall be negative only for bidirectional and random
 access iterators.
 *Effects:* Increments (or decrements for negative `n`) iterator
 reference `i` by `n`.
 ``` cpp
 template <class InputIterator>
+  constexpr typename iterator_traits<InputIterator>::difference_type
     distance(InputIterator first, InputIterator last);
 ```
 *Effects:* If `InputIterator` meets the requirements of random access
 iterator, returns `(last - first)`; otherwise, returns the number of
 iterator, `last` shall be reachable from `first` or `first` shall be
 reachable from `last`; otherwise, `last` shall be reachable from
 `first`.
 ``` cpp
+template <class InputIterator>
+ constexpr InputIterator next(InputIterator x,
+    typename iterator_traits<InputIterator>::difference_type n = 1);
 ```
+*Effects:* Equivalent to: `advance(x, n); return x;`
 ``` cpp
 template <class BidirectionalIterator>
+ constexpr BidirectionalIterator prev(BidirectionalIterator x,
+    typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
 ```
+*Effects:* Equivalent to: `advance(x, -n); return x;`

Diff to HTML by rtfpessoa