From Jason Turner

[reverse.iter.ops]

C++14 → C++17 7.3 KB 76 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/tmph61l3po0/{from.md → to.md} +34 -39
tmp/tmph61l3po0/{from.md → to.md} RENAMED
@@ -1,256 +1,251 @@
1
  #### `reverse_iterator` operations <a id="reverse.iter.ops">[[reverse.iter.ops]]</a>
2
 
3
  ##### `reverse_iterator` constructor <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
4
 
5
  ``` cpp
6
- reverse_iterator();
7
  ```
8
 
9
- *Effects:* Value initializes `current`. Iterator operations applied to
10
  the resulting iterator have defined behavior if and only if the
11
  corresponding operations are defined on a value-initialized iterator of
12
  type `Iterator`.
13
 
14
  ``` cpp
15
- explicit reverse_iterator(Iterator x);
16
  ```
17
 
18
  *Effects:* Initializes `current` with `x`.
19
 
20
  ``` cpp
21
- template <class U> reverse_iterator(const reverse_iterator<U> &u);
22
  ```
23
 
24
  *Effects:* Initializes `current` with `u.current`.
25
 
26
  ##### `reverse_iterator::operator=` <a id="reverse.iter.op=">[[reverse.iter.op=]]</a>
27
 
28
  ``` cpp
29
  template <class U>
30
- reverse_iterator&
31
  operator=(const reverse_iterator<U>& u);
32
  ```
33
 
34
  *Effects:* Assigns `u.base()` to current.
35
 
36
  *Returns:* `*this`.
37
 
38
  ##### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
39
 
40
  ``` cpp
41
- Iterator base() const; // explicit
42
  ```
43
 
44
  *Returns:* `current`.
45
 
46
  ##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
47
 
48
  ``` cpp
49
- reference operator*() const;
50
  ```
51
 
52
- *Effects:*
53
 
54
  ``` cpp
55
  Iterator tmp = current;
56
  return *--tmp;
57
  ```
58
 
59
  ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
60
 
61
  ``` cpp
62
- pointer operator->() const;
63
  ```
64
 
65
- *Returns:* `std::addressof(operator*())`.
66
 
67
  ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
68
 
69
  ``` cpp
70
- reverse_iterator& operator++();
71
  ```
72
 
73
- *Effects:* `current;`
74
 
75
  *Returns:* `*this`.
76
 
77
  ``` cpp
78
- reverse_iterator operator++(int);
79
  ```
80
 
81
- *Effects:*
82
 
83
  ``` cpp
84
  reverse_iterator tmp = *this;
85
  --current;
86
  return tmp;
87
  ```
88
 
89
  \[reverse.iter.op\]`operator\dcr`
90
 
91
  ``` cpp
92
- reverse_iterator& operator--();
93
  ```
94
 
95
- *Effects:* `++current`
96
 
97
  *Returns:* `*this`.
98
 
99
  ``` cpp
100
- reverse_iterator operator--(int);
101
  ```
102
 
103
- *Effects:*
104
 
105
  ``` cpp
106
  reverse_iterator tmp = *this;
107
  ++current;
108
  return tmp;
109
  ```
110
 
111
  ##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
112
 
113
  ``` cpp
114
- reverse_iterator
115
- operator+(typename reverse_iterator<Iterator>::difference_type n) const;
116
  ```
117
 
118
  *Returns:* `reverse_iterator(current-n)`.
119
 
120
  ##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
121
 
122
  ``` cpp
123
- reverse_iterator&
124
- operator+=(typename reverse_iterator<Iterator>::difference_type n);
125
  ```
126
 
127
- *Effects:* `current -= n;`
128
 
129
  *Returns:* `*this`.
130
 
131
  ##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
132
 
133
  ``` cpp
134
- reverse_iterator
135
- operator-(typename reverse_iterator<Iterator>::difference_type n) const;
136
  ```
137
 
138
  *Returns:* `reverse_iterator(current+n)`.
139
 
140
  ##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
141
 
142
  ``` cpp
143
- reverse_iterator&
144
- operator-=(typename reverse_iterator<Iterator>::difference_type n);
145
  ```
146
 
147
- *Effects:* `current += n;`
148
 
149
  *Returns:* `*this`.
150
 
151
  ##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
152
 
153
  ``` cpp
154
- unspecified operator[](
155
- typename reverse_iterator<Iterator>::difference_type n) const;
156
  ```
157
 
158
  *Returns:* `current[-n-1]`.
159
 
160
  ##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
161
 
162
  ``` cpp
163
  template <class Iterator1, class Iterator2>
164
- bool operator==(
165
  const reverse_iterator<Iterator1>& x,
166
  const reverse_iterator<Iterator2>& y);
167
  ```
168
 
169
  *Returns:* `x.current == y.current`.
170
 
171
  ##### `operator<` <a id="reverse.iter.op<">[[reverse.iter.op<]]</a>
172
 
173
  ``` cpp
174
  template <class Iterator1, class Iterator2>
175
- bool operator<(
176
  const reverse_iterator<Iterator1>& x,
177
  const reverse_iterator<Iterator2>& y);
178
  ```
179
 
180
  *Returns:* `x.current > y.current`.
181
 
182
  ##### `operator!=` <a id="reverse.iter.op!=">[[reverse.iter.op!=]]</a>
183
 
184
  ``` cpp
185
  template <class Iterator1, class Iterator2>
186
- bool operator!=(
187
  const reverse_iterator<Iterator1>& x,
188
  const reverse_iterator<Iterator2>& y);
189
  ```
190
 
191
  *Returns:* `x.current != y.current`.
192
 
193
  ##### `operator>` <a id="reverse.iter.op>">[[reverse.iter.op>]]</a>
194
 
195
  ``` cpp
196
  template <class Iterator1, class Iterator2>
197
- bool operator>(
198
  const reverse_iterator<Iterator1>& x,
199
  const reverse_iterator<Iterator2>& y);
200
  ```
201
 
202
  *Returns:* `x.current < y.current`.
203
 
204
  ##### `operator>=` <a id="reverse.iter.op>=">[[reverse.iter.op>=]]</a>
205
 
206
  ``` cpp
207
  template <class Iterator1, class Iterator2>
208
- bool operator>=(
209
  const reverse_iterator<Iterator1>& x,
210
  const reverse_iterator<Iterator2>& y);
211
  ```
212
 
213
  *Returns:* `x.current <= y.current`.
214
 
215
  ##### `operator<=` <a id="reverse.iter.op<=">[[reverse.iter.op<=]]</a>
216
 
217
  ``` cpp
218
  template <class Iterator1, class Iterator2>
219
- bool operator<=(
220
  const reverse_iterator<Iterator1>& x,
221
  const reverse_iterator<Iterator2>& y);
222
  ```
223
 
224
  *Returns:* `x.current >= y.current`.
225
 
226
  ##### `operator-` <a id="reverse.iter.opdiff">[[reverse.iter.opdiff]]</a>
227
 
228
  ``` cpp
229
  template <class Iterator1, class Iterator2>
230
- auto operator-(
231
  const reverse_iterator<Iterator1>& x,
232
  const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
233
  ```
234
 
235
  *Returns:* `y.current - x.current`.
236
 
237
  ##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
238
 
239
  ``` cpp
240
  template <class Iterator>
241
- reverse_iterator<Iterator> operator+(
242
  typename reverse_iterator<Iterator>::difference_type n,
243
  const reverse_iterator<Iterator>& x);
244
  ```
245
 
246
  *Returns:* `reverse_iterator<Iterator> (x.current - n)`.
247
 
248
  ##### Non-member function `make_reverse_iterator()` <a id="reverse.iter.make">[[reverse.iter.make]]</a>
249
 
250
  ``` cpp
251
  template <class Iterator>
252
- reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
253
  ```
254
 
255
  *Returns:* `reverse_iterator<Iterator>(i)`.
256
 
 
1
  #### `reverse_iterator` operations <a id="reverse.iter.ops">[[reverse.iter.ops]]</a>
2
 
3
  ##### `reverse_iterator` constructor <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
4
 
5
  ``` cpp
6
+ constexpr reverse_iterator();
7
  ```
8
 
9
+ *Effects:* Value-initializes `current`. Iterator operations applied to
10
  the resulting iterator have defined behavior if and only if the
11
  corresponding operations are defined on a value-initialized iterator of
12
  type `Iterator`.
13
 
14
  ``` cpp
15
+ constexpr explicit reverse_iterator(Iterator x);
16
  ```
17
 
18
  *Effects:* Initializes `current` with `x`.
19
 
20
  ``` cpp
21
+ template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
22
  ```
23
 
24
  *Effects:* Initializes `current` with `u.current`.
25
 
26
  ##### `reverse_iterator::operator=` <a id="reverse.iter.op=">[[reverse.iter.op=]]</a>
27
 
28
  ``` cpp
29
  template <class U>
30
+ constexpr reverse_iterator&
31
  operator=(const reverse_iterator<U>& u);
32
  ```
33
 
34
  *Effects:* Assigns `u.base()` to current.
35
 
36
  *Returns:* `*this`.
37
 
38
  ##### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
39
 
40
  ``` cpp
41
+ constexpr Iterator base() const; // explicit
42
  ```
43
 
44
  *Returns:* `current`.
45
 
46
  ##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
47
 
48
  ``` cpp
49
+ constexpr reference operator*() const;
50
  ```
51
 
52
+ *Effects:* As if by:
53
 
54
  ``` cpp
55
  Iterator tmp = current;
56
  return *--tmp;
57
  ```
58
 
59
  ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
60
 
61
  ``` cpp
62
+ constexpr pointer operator->() const;
63
  ```
64
 
65
+ *Returns:* `addressof(operator*())`.
66
 
67
  ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
68
 
69
  ``` cpp
70
+ constexpr reverse_iterator& operator++();
71
  ```
72
 
73
+ *Effects:* As if by: `current;`
74
 
75
  *Returns:* `*this`.
76
 
77
  ``` cpp
78
+ constexpr reverse_iterator operator++(int);
79
  ```
80
 
81
+ *Effects:* As if by:
82
 
83
  ``` cpp
84
  reverse_iterator tmp = *this;
85
  --current;
86
  return tmp;
87
  ```
88
 
89
  \[reverse.iter.op\]`operator\dcr`
90
 
91
  ``` cpp
92
+ constexpr reverse_iterator& operator--();
93
  ```
94
 
95
+ *Effects:* As if by `++current`.
96
 
97
  *Returns:* `*this`.
98
 
99
  ``` cpp
100
+ constexpr reverse_iterator operator--(int);
101
  ```
102
 
103
+ *Effects:* As if by:
104
 
105
  ``` cpp
106
  reverse_iterator tmp = *this;
107
  ++current;
108
  return tmp;
109
  ```
110
 
111
  ##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
112
 
113
  ``` cpp
114
+ constexpr reverse_iterator operator+(difference_type n) const;
 
115
  ```
116
 
117
  *Returns:* `reverse_iterator(current-n)`.
118
 
119
  ##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
120
 
121
  ``` cpp
122
+ constexpr reverse_iterator& operator+=(difference_type n);
 
123
  ```
124
 
125
+ *Effects:* As if by: `current -= n;`
126
 
127
  *Returns:* `*this`.
128
 
129
  ##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
130
 
131
  ``` cpp
132
+ constexpr reverse_iterator operator-(difference_type n) const;
 
133
  ```
134
 
135
  *Returns:* `reverse_iterator(current+n)`.
136
 
137
  ##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
138
 
139
  ``` cpp
140
+ constexpr reverse_iterator& operator-=(difference_type n);
 
141
  ```
142
 
143
+ *Effects:* As if by: `current += n;`
144
 
145
  *Returns:* `*this`.
146
 
147
  ##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
148
 
149
  ``` cpp
150
+ constexpr unspecified operator[](difference_type n) const;
 
151
  ```
152
 
153
  *Returns:* `current[-n-1]`.
154
 
155
  ##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
156
 
157
  ``` cpp
158
  template <class Iterator1, class Iterator2>
159
+ constexpr bool operator==(
160
  const reverse_iterator<Iterator1>& x,
161
  const reverse_iterator<Iterator2>& y);
162
  ```
163
 
164
  *Returns:* `x.current == y.current`.
165
 
166
  ##### `operator<` <a id="reverse.iter.op<">[[reverse.iter.op<]]</a>
167
 
168
  ``` cpp
169
  template <class Iterator1, class Iterator2>
170
+ constexpr bool operator<(
171
  const reverse_iterator<Iterator1>& x,
172
  const reverse_iterator<Iterator2>& y);
173
  ```
174
 
175
  *Returns:* `x.current > y.current`.
176
 
177
  ##### `operator!=` <a id="reverse.iter.op!=">[[reverse.iter.op!=]]</a>
178
 
179
  ``` cpp
180
  template <class Iterator1, class Iterator2>
181
+ constexpr bool operator!=(
182
  const reverse_iterator<Iterator1>& x,
183
  const reverse_iterator<Iterator2>& y);
184
  ```
185
 
186
  *Returns:* `x.current != y.current`.
187
 
188
  ##### `operator>` <a id="reverse.iter.op>">[[reverse.iter.op>]]</a>
189
 
190
  ``` cpp
191
  template <class Iterator1, class Iterator2>
192
+ constexpr bool operator>(
193
  const reverse_iterator<Iterator1>& x,
194
  const reverse_iterator<Iterator2>& y);
195
  ```
196
 
197
  *Returns:* `x.current < y.current`.
198
 
199
  ##### `operator>=` <a id="reverse.iter.op>=">[[reverse.iter.op>=]]</a>
200
 
201
  ``` cpp
202
  template <class Iterator1, class Iterator2>
203
+ constexpr bool operator>=(
204
  const reverse_iterator<Iterator1>& x,
205
  const reverse_iterator<Iterator2>& y);
206
  ```
207
 
208
  *Returns:* `x.current <= y.current`.
209
 
210
  ##### `operator<=` <a id="reverse.iter.op<=">[[reverse.iter.op<=]]</a>
211
 
212
  ``` cpp
213
  template <class Iterator1, class Iterator2>
214
+ constexpr bool operator<=(
215
  const reverse_iterator<Iterator1>& x,
216
  const reverse_iterator<Iterator2>& y);
217
  ```
218
 
219
  *Returns:* `x.current >= y.current`.
220
 
221
  ##### `operator-` <a id="reverse.iter.opdiff">[[reverse.iter.opdiff]]</a>
222
 
223
  ``` cpp
224
  template <class Iterator1, class Iterator2>
225
+ constexpr auto operator-(
226
  const reverse_iterator<Iterator1>& x,
227
  const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
228
  ```
229
 
230
  *Returns:* `y.current - x.current`.
231
 
232
  ##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
233
 
234
  ``` cpp
235
  template <class Iterator>
236
+ constexpr reverse_iterator<Iterator> operator+(
237
  typename reverse_iterator<Iterator>::difference_type n,
238
  const reverse_iterator<Iterator>& x);
239
  ```
240
 
241
  *Returns:* `reverse_iterator<Iterator> (x.current - n)`.
242
 
243
  ##### Non-member function `make_reverse_iterator()` <a id="reverse.iter.make">[[reverse.iter.make]]</a>
244
 
245
  ``` cpp
246
  template <class Iterator>
247
+ constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
248
  ```
249
 
250
  *Returns:* `reverse_iterator<Iterator>(i)`.
251