From Jason Turner

[iterator.synopsis]

C++14 → C++17 9.7 KB 108 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp38_cbq1r/{from.md → to.md} +56 -47
tmp/tmp38_cbq1r/{from.md → to.md} RENAMED
@@ -1,75 +1,73 @@
1
  ## Header `<iterator>` synopsis <a id="iterator.synopsis">[[iterator.synopsis]]</a>
2
 
3
  ``` cpp
4
  namespace std {
5
- // [iterator.primitives], primitives:
6
  template<class Iterator> struct iterator_traits;
7
  template<class T> struct iterator_traits<T*>;
8
-
9
- template<class Category, class T, class Distance = ptrdiff_t,
10
- class Pointer = T*, class Reference = T&> struct iterator;
11
 
12
  struct input_iterator_tag { };
13
  struct output_iterator_tag { };
14
  struct forward_iterator_tag: public input_iterator_tag { };
15
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
16
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
17
 
18
- // [iterator.operations], iterator operations:
19
  template <class InputIterator, class Distance>
20
- void advance(InputIterator& i, Distance n);
21
  template <class InputIterator>
22
- typename iterator_traits<InputIterator>::difference_type
23
  distance(InputIterator first, InputIterator last);
24
- template <class ForwardIterator>
25
- ForwardIterator next(ForwardIterator x,
26
- typename std::iterator_traits<ForwardIterator>::difference_type n = 1);
27
  template <class BidirectionalIterator>
28
- BidirectionalIterator prev(BidirectionalIterator x,
29
- typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1);
30
 
31
- // [predef.iterators], predefined iterators:
32
  template <class Iterator> class reverse_iterator;
33
 
34
  template <class Iterator1, class Iterator2>
35
- bool operator==(
36
  const reverse_iterator<Iterator1>& x,
37
  const reverse_iterator<Iterator2>& y);
38
  template <class Iterator1, class Iterator2>
39
- bool operator<(
40
  const reverse_iterator<Iterator1>& x,
41
  const reverse_iterator<Iterator2>& y);
42
  template <class Iterator1, class Iterator2>
43
- bool operator!=(
44
  const reverse_iterator<Iterator1>& x,
45
  const reverse_iterator<Iterator2>& y);
46
  template <class Iterator1, class Iterator2>
47
- bool operator>(
48
  const reverse_iterator<Iterator1>& x,
49
  const reverse_iterator<Iterator2>& y);
50
  template <class Iterator1, class Iterator2>
51
- bool operator>=(
52
  const reverse_iterator<Iterator1>& x,
53
  const reverse_iterator<Iterator2>& y);
54
  template <class Iterator1, class Iterator2>
55
- bool operator<=(
56
  const reverse_iterator<Iterator1>& x,
57
  const reverse_iterator<Iterator2>& y);
58
 
59
  template <class Iterator1, class Iterator2>
60
- auto operator-(
61
  const reverse_iterator<Iterator1>& x,
62
  const reverse_iterator<Iterator2>& y) ->decltype(y.base() - x.base());
63
  template <class Iterator>
64
- reverse_iterator<Iterator>
65
  operator+(
66
  typename reverse_iterator<Iterator>::difference_type n,
67
  const reverse_iterator<Iterator>& x);
68
 
69
  template <class Iterator>
70
- reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
71
 
72
  template <class Container> class back_insert_iterator;
73
  template <class Container>
74
  back_insert_iterator<Container> back_inserter(Container& x);
75
 
@@ -81,39 +79,39 @@ namespace std {
81
  template <class Container>
82
  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
83
 
84
  template <class Iterator> class move_iterator;
85
  template <class Iterator1, class Iterator2>
86
- bool operator==(
87
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
88
  template <class Iterator1, class Iterator2>
89
- bool operator!=(
90
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
91
  template <class Iterator1, class Iterator2>
92
- bool operator<(
93
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
94
  template <class Iterator1, class Iterator2>
95
- bool operator<=(
96
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
97
  template <class Iterator1, class Iterator2>
98
- bool operator>(
99
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
100
  template <class Iterator1, class Iterator2>
101
- bool operator>=(
102
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
103
 
104
  template <class Iterator1, class Iterator2>
105
- auto operator-(
106
  const move_iterator<Iterator1>& x,
107
  const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
108
  template <class Iterator>
109
- move_iterator<Iterator> operator+(
110
  typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
111
  template <class Iterator>
112
- move_iterator<Iterator> make_move_iterator(Iterator i);
113
 
114
- // [stream.iterators], stream iterators:
115
  template <class T, class charT = char, class traits = char_traits<charT>,
116
  class Distance = ptrdiff_t>
117
  class istream_iterator;
118
  template <class T, class charT, class traits, class Distance>
119
  bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
@@ -135,29 +133,40 @@ namespace std {
135
  const istreambuf_iterator<charT,traits>& b);
136
 
137
  template <class charT, class traits = char_traits<charT>>
138
  class ostreambuf_iterator;
139
 
140
- // [iterator.range], range access:
141
- template <class C> auto begin(C& c) -> decltype(c.begin());
142
- template <class C> auto begin(const C& c) -> decltype(c.begin());
143
- template <class C> auto end(C& c) -> decltype(c.end());
144
- template <class C> auto end(const C& c) -> decltype(c.end());
145
  template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
146
  template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
147
  template <class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
148
  -> decltype(std::begin(c));
149
  template <class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
150
  -> decltype(std::end(c));
151
- template <class C> auto rbegin(C& c) -> decltype(c.rbegin());
152
- template <class C> auto rbegin(const C& c) -> decltype(c.rbegin());
153
- template <class C> auto rend(C& c) -> decltype(c.rend());
154
- template <class C> auto rend(const C& c) -> decltype(c.rend());
155
- template <class T, size_t N> reverse_iterator<T*> rbegin(T (&array)[N]);
156
- template <class T, size_t N> reverse_iterator<T*> rend(T (&array)[N]);
157
- template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il);
158
- template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);
159
- template <class C> auto crbegin(const C& c) -> decltype(std::rbegin(c));
160
- template <class C> auto crend(const C& c) -> decltype(std::rend(c));
 
 
 
 
 
 
 
 
 
 
 
161
  }
162
  ```
163
 
 
1
  ## Header `<iterator>` synopsis <a id="iterator.synopsis">[[iterator.synopsis]]</a>
2
 
3
  ``` cpp
4
  namespace std {
5
+ // [iterator.primitives], primitives
6
  template<class Iterator> struct iterator_traits;
7
  template<class T> struct iterator_traits<T*>;
8
+ template<class T> struct iterator_traits<const T*>;
 
 
9
 
10
  struct input_iterator_tag { };
11
  struct output_iterator_tag { };
12
  struct forward_iterator_tag: public input_iterator_tag { };
13
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
14
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
15
 
16
+ // [iterator.operations], iterator operations
17
  template <class InputIterator, class Distance>
18
+ constexpr void advance(InputIterator& i, Distance n);
19
  template <class InputIterator>
20
+ constexpr typename iterator_traits<InputIterator>::difference_type
21
  distance(InputIterator first, InputIterator last);
22
+ template <class InputIterator>
23
+ constexpr InputIterator next(InputIterator x,
24
+ typename iterator_traits<InputIterator>::difference_type n = 1);
25
  template <class BidirectionalIterator>
26
+ constexpr BidirectionalIterator prev(BidirectionalIterator x,
27
+ typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
28
 
29
+ // [predef.iterators], predefined iterators
30
  template <class Iterator> class reverse_iterator;
31
 
32
  template <class Iterator1, class Iterator2>
33
+ constexpr bool operator==(
34
  const reverse_iterator<Iterator1>& x,
35
  const reverse_iterator<Iterator2>& y);
36
  template <class Iterator1, class Iterator2>
37
+ constexpr bool operator<(
38
  const reverse_iterator<Iterator1>& x,
39
  const reverse_iterator<Iterator2>& y);
40
  template <class Iterator1, class Iterator2>
41
+ constexpr bool operator!=(
42
  const reverse_iterator<Iterator1>& x,
43
  const reverse_iterator<Iterator2>& y);
44
  template <class Iterator1, class Iterator2>
45
+ constexpr bool operator>(
46
  const reverse_iterator<Iterator1>& x,
47
  const reverse_iterator<Iterator2>& y);
48
  template <class Iterator1, class Iterator2>
49
+ constexpr bool operator>=(
50
  const reverse_iterator<Iterator1>& x,
51
  const reverse_iterator<Iterator2>& y);
52
  template <class Iterator1, class Iterator2>
53
+ constexpr bool operator<=(
54
  const reverse_iterator<Iterator1>& x,
55
  const reverse_iterator<Iterator2>& y);
56
 
57
  template <class Iterator1, class Iterator2>
58
+ constexpr auto operator-(
59
  const reverse_iterator<Iterator1>& x,
60
  const reverse_iterator<Iterator2>& y) ->decltype(y.base() - x.base());
61
  template <class Iterator>
62
+ constexpr reverse_iterator<Iterator>
63
  operator+(
64
  typename reverse_iterator<Iterator>::difference_type n,
65
  const reverse_iterator<Iterator>& x);
66
 
67
  template <class Iterator>
68
+ constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
69
 
70
  template <class Container> class back_insert_iterator;
71
  template <class Container>
72
  back_insert_iterator<Container> back_inserter(Container& x);
73
 
 
79
  template <class Container>
80
  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
81
 
82
  template <class Iterator> class move_iterator;
83
  template <class Iterator1, class Iterator2>
84
+ constexpr bool operator==(
85
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
86
  template <class Iterator1, class Iterator2>
87
+ constexpr bool operator!=(
88
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
89
  template <class Iterator1, class Iterator2>
90
+ constexpr bool operator<(
91
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
92
  template <class Iterator1, class Iterator2>
93
+ constexpr bool operator<=(
94
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
95
  template <class Iterator1, class Iterator2>
96
+ constexpr bool operator>(
97
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
98
  template <class Iterator1, class Iterator2>
99
+ constexpr bool operator>=(
100
  const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
101
 
102
  template <class Iterator1, class Iterator2>
103
+ constexpr auto operator-(
104
  const move_iterator<Iterator1>& x,
105
  const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
106
  template <class Iterator>
107
+ constexpr move_iterator<Iterator> operator+(
108
  typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
109
  template <class Iterator>
110
+ constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
111
 
112
+ // [stream.iterators], stream iterators
113
  template <class T, class charT = char, class traits = char_traits<charT>,
114
  class Distance = ptrdiff_t>
115
  class istream_iterator;
116
  template <class T, class charT, class traits, class Distance>
117
  bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
 
133
  const istreambuf_iterator<charT,traits>& b);
134
 
135
  template <class charT, class traits = char_traits<charT>>
136
  class ostreambuf_iterator;
137
 
138
+ // [iterator.range], range access
139
+ template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
140
+ template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
141
+ template <class C> constexpr auto end(C& c) -> decltype(c.end());
142
+ template <class C> constexpr auto end(const C& c) -> decltype(c.end());
143
  template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
144
  template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
145
  template <class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
146
  -> decltype(std::begin(c));
147
  template <class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
148
  -> decltype(std::end(c));
149
+ template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
150
+ template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
151
+ template <class C> constexpr auto rend(C& c) -> decltype(c.rend());
152
+ template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());
153
+ template <class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]);
154
+ template <class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);
155
+ template <class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
156
+ template <class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
157
+ template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
158
+ template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
159
+
160
+ // [iterator.container], container access
161
+ template <class C> constexpr auto size(const C& c) -> decltype(c.size());
162
+ template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept;
163
+ template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
164
+ template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
165
+ template <class E> constexpr bool empty(initializer_list<E> il) noexcept;
166
+ template <class C> constexpr auto data(C& c) -> decltype(c.data());
167
+ template <class C> constexpr auto data(const C& c) -> decltype(c.data());
168
+ template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;
169
+ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
170
  }
171
  ```
172