From Jason Turner

[insert.iterators]

C++14 → C++17 9.2 KB 134 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game
C++ Weekly: Ep 14

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpc_x__efx/{from.md → to.md} +64 -61
tmp/tmpc_x__efx/{from.md → to.md} RENAMED
@@ -32,26 +32,29 @@ iterators out of a container.
32
  #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
33
 
34
  ``` cpp
35
  namespace std {
36
  template <class Container>
37
- class back_insert_iterator :
38
- public iterator<output_iterator_tag,void,void,void,void> {
39
  protected:
40
  Container* container;
41
 
42
  public:
43
- typedef Container container_type;
 
 
 
 
 
 
44
  explicit back_insert_iterator(Container& x);
45
- back_insert_iterator<Container>&
46
- operator=(const typename Container::value_type& value);
47
- back_insert_iterator<Container>&
48
- operator=(typename Container::value_type&& value);
49
 
50
- back_insert_iterator<Container>& operator*();
51
- back_insert_iterator<Container>& operator++();
52
- back_insert_iterator<Container> operator++(int);
53
  };
54
 
55
  template <class Container>
56
  back_insert_iterator<Container> back_inserter(Container& x);
57
  }
@@ -63,45 +66,43 @@ namespace std {
63
 
64
  ``` cpp
65
  explicit back_insert_iterator(Container& x);
66
  ```
67
 
68
- *Effects:* Initializes `container` with `std::addressof(x)`.
69
 
70
  ##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
71
 
72
  ``` cpp
73
- back_insert_iterator<Container>&
74
- operator=(const typename Container::value_type& value);
75
  ```
76
 
77
- *Effects:* `container->push_back(value);`
78
 
79
  *Returns:* `*this`.
80
 
81
  ``` cpp
82
- back_insert_iterator<Container>&
83
- operator=(typename Container::value_type&& value);
84
  ```
85
 
86
- *Effects:* `container->push_back(std::move(value));`
87
 
88
  *Returns:* `*this`.
89
 
90
  ##### `back_insert_iterator::operator*` <a id="back.insert.iter.op*">[[back.insert.iter.op*]]</a>
91
 
92
  ``` cpp
93
- back_insert_iterator<Container>& operator*();
94
  ```
95
 
96
  *Returns:* `*this`.
97
 
98
  ##### `back_insert_iterator::operator++` <a id="back.insert.iter.op++">[[back.insert.iter.op++]]</a>
99
 
100
  ``` cpp
101
- back_insert_iterator<Container>& operator++();
102
- back_insert_iterator<Container> operator++(int);
103
  ```
104
 
105
  *Returns:* `*this`.
106
 
107
  ##### `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
@@ -116,26 +117,29 @@ template <class Container>
116
  #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
117
 
118
  ``` cpp
119
  namespace std {
120
  template <class Container>
121
- class front_insert_iterator :
122
- public iterator<output_iterator_tag,void,void,void,void> {
123
  protected:
124
  Container* container;
125
 
126
  public:
127
- typedef Container container_type;
 
 
 
 
 
 
128
  explicit front_insert_iterator(Container& x);
129
- front_insert_iterator<Container>&
130
- operator=(const typename Container::value_type& value);
131
- front_insert_iterator<Container>&
132
- operator=(typename Container::value_type&& value);
133
 
134
- front_insert_iterator<Container>& operator*();
135
- front_insert_iterator<Container>& operator++();
136
- front_insert_iterator<Container> operator++(int);
137
  };
138
 
139
  template <class Container>
140
  front_insert_iterator<Container> front_inserter(Container& x);
141
  }
@@ -147,45 +151,43 @@ namespace std {
147
 
148
  ``` cpp
149
  explicit front_insert_iterator(Container& x);
150
  ```
151
 
152
- *Effects:* Initializes `container` with `std::addressof(x)`.
153
 
154
  ##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
155
 
156
  ``` cpp
157
- front_insert_iterator<Container>&
158
- operator=(const typename Container::value_type& value);
159
  ```
160
 
161
- *Effects:* `container->push_front(value);`
162
 
163
  *Returns:* `*this`.
164
 
165
  ``` cpp
166
- front_insert_iterator<Container>&
167
- operator=(typename Container::value_type&& value);
168
  ```
169
 
170
- *Effects:* `container->push_front(std::move(value));`
171
 
172
  *Returns:* `*this`.
173
 
174
  ##### `front_insert_iterator::operator*` <a id="front.insert.iter.op*">[[front.insert.iter.op*]]</a>
175
 
176
  ``` cpp
177
- front_insert_iterator<Container>& operator*();
178
  ```
179
 
180
  *Returns:* `*this`.
181
 
182
  ##### `front_insert_iterator::operator++` <a id="front.insert.iter.op++">[[front.insert.iter.op++]]</a>
183
 
184
  ``` cpp
185
- front_insert_iterator<Container>& operator++();
186
- front_insert_iterator<Container> operator++(int);
187
  ```
188
 
189
  *Returns:* `*this`.
190
 
191
  ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
@@ -200,27 +202,30 @@ template <class Container>
200
  #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
201
 
202
  ``` cpp
203
  namespace std {
204
  template <class Container>
205
- class insert_iterator :
206
- public iterator<output_iterator_tag,void,void,void,void> {
207
  protected:
208
  Container* container;
209
  typename Container::iterator iter;
210
 
211
  public:
212
- typedef Container container_type;
 
 
 
 
 
 
213
  insert_iterator(Container& x, typename Container::iterator i);
214
- insert_iterator<Container>&
215
- operator=(const typename Container::value_type& value);
216
- insert_iterator<Container>&
217
- operator=(typename Container::value_type&& value);
218
 
219
- insert_iterator<Container>& operator*();
220
- insert_iterator<Container>& operator++();
221
- insert_iterator<Container>& operator++(int);
222
  };
223
 
224
  template <class Container>
225
  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
226
  }
@@ -232,35 +237,33 @@ namespace std {
232
 
233
  ``` cpp
234
  insert_iterator(Container& x, typename Container::iterator i);
235
  ```
236
 
237
- *Effects:* Initializes `container` with `std::addressof(x)` and `iter`
238
- with `i`.
239
 
240
  ##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
241
 
242
  ``` cpp
243
- insert_iterator<Container>&
244
- operator=(const typename Container::value_type& value);
245
  ```
246
 
247
- *Effects:*
248
 
249
  ``` cpp
250
  iter = container->insert(iter, value);
251
  ++iter;
252
  ```
253
 
254
  *Returns:* `*this`.
255
 
256
  ``` cpp
257
- insert_iterator<Container>&
258
- operator=(typename Container::value_type&& value);
259
  ```
260
 
261
- *Effects:*
262
 
263
  ``` cpp
264
  iter = container->insert(iter, std::move(value));
265
  ++iter;
266
  ```
@@ -268,20 +271,20 @@ iter = container->insert(iter, std::move(value));
268
  *Returns:* `*this`.
269
 
270
  ##### `insert_iterator::operator*` <a id="insert.iter.op*">[[insert.iter.op*]]</a>
271
 
272
  ``` cpp
273
- insert_iterator<Container>& operator*();
274
  ```
275
 
276
  *Returns:* `*this`.
277
 
278
  ##### `insert_iterator::operator++` <a id="insert.iter.op++">[[insert.iter.op++]]</a>
279
 
280
  ``` cpp
281
- insert_iterator<Container>& operator++();
282
- insert_iterator<Container>& operator++(int);
283
  ```
284
 
285
  *Returns:* `*this`.
286
 
287
  ##### `inserter` <a id="inserter">[[inserter]]</a>
 
32
  #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
33
 
34
  ``` cpp
35
  namespace std {
36
  template <class Container>
37
+ class back_insert_iterator {
 
38
  protected:
39
  Container* container;
40
 
41
  public:
42
+ using iterator_category = output_iterator_tag;
43
+ using value_type = void;
44
+ using difference_type = void;
45
+ using pointer = void;
46
+ using reference = void;
47
+ using container_type = Container;
48
+
49
  explicit back_insert_iterator(Container& x);
50
+ back_insert_iterator& operator=(const typename Container::value_type& value);
51
+ back_insert_iterator& operator=(typename Container::value_type&& value);
 
 
52
 
53
+ back_insert_iterator& operator*();
54
+ back_insert_iterator& operator++();
55
+ back_insert_iterator operator++(int);
56
  };
57
 
58
  template <class Container>
59
  back_insert_iterator<Container> back_inserter(Container& x);
60
  }
 
66
 
67
  ``` cpp
68
  explicit back_insert_iterator(Container& x);
69
  ```
70
 
71
+ *Effects:* Initializes `container` with `addressof(x)`.
72
 
73
  ##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
74
 
75
  ``` cpp
76
+ back_insert_iterator& operator=(const typename Container::value_type& value);
 
77
  ```
78
 
79
+ *Effects:* As if by: `container->push_back(value);`
80
 
81
  *Returns:* `*this`.
82
 
83
  ``` cpp
84
+ back_insert_iterator& operator=(typename Container::value_type&& value);
 
85
  ```
86
 
87
+ *Effects:* As if by: `container->push_back(std::move(value));`
88
 
89
  *Returns:* `*this`.
90
 
91
  ##### `back_insert_iterator::operator*` <a id="back.insert.iter.op*">[[back.insert.iter.op*]]</a>
92
 
93
  ``` cpp
94
+ back_insert_iterator& operator*();
95
  ```
96
 
97
  *Returns:* `*this`.
98
 
99
  ##### `back_insert_iterator::operator++` <a id="back.insert.iter.op++">[[back.insert.iter.op++]]</a>
100
 
101
  ``` cpp
102
+ back_insert_iterator& operator++();
103
+ back_insert_iterator operator++(int);
104
  ```
105
 
106
  *Returns:* `*this`.
107
 
108
  ##### `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
 
117
  #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
118
 
119
  ``` cpp
120
  namespace std {
121
  template <class Container>
122
+ class front_insert_iterator {
 
123
  protected:
124
  Container* container;
125
 
126
  public:
127
+ using iterator_category = output_iterator_tag;
128
+ using value_type = void;
129
+ using difference_type = void;
130
+ using pointer = void;
131
+ using reference = void;
132
+ using container_type = Container;
133
+
134
  explicit front_insert_iterator(Container& x);
135
+ front_insert_iterator& operator=(const typename Container::value_type& value);
136
+ front_insert_iterator& operator=(typename Container::value_type&& value);
 
 
137
 
138
+ front_insert_iterator& operator*();
139
+ front_insert_iterator& operator++();
140
+ front_insert_iterator operator++(int);
141
  };
142
 
143
  template <class Container>
144
  front_insert_iterator<Container> front_inserter(Container& x);
145
  }
 
151
 
152
  ``` cpp
153
  explicit front_insert_iterator(Container& x);
154
  ```
155
 
156
+ *Effects:* Initializes `container` with `addressof(x)`.
157
 
158
  ##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
159
 
160
  ``` cpp
161
+ front_insert_iterator& operator=(const typename Container::value_type& value);
 
162
  ```
163
 
164
+ *Effects:* As if by: `container->push_front(value);`
165
 
166
  *Returns:* `*this`.
167
 
168
  ``` cpp
169
+ front_insert_iterator& operator=(typename Container::value_type&& value);
 
170
  ```
171
 
172
+ *Effects:* As if by: `container->push_front(std::move(value));`
173
 
174
  *Returns:* `*this`.
175
 
176
  ##### `front_insert_iterator::operator*` <a id="front.insert.iter.op*">[[front.insert.iter.op*]]</a>
177
 
178
  ``` cpp
179
+ front_insert_iterator& operator*();
180
  ```
181
 
182
  *Returns:* `*this`.
183
 
184
  ##### `front_insert_iterator::operator++` <a id="front.insert.iter.op++">[[front.insert.iter.op++]]</a>
185
 
186
  ``` cpp
187
+ front_insert_iterator& operator++();
188
+ front_insert_iterator operator++(int);
189
  ```
190
 
191
  *Returns:* `*this`.
192
 
193
  ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
 
202
  #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
203
 
204
  ``` cpp
205
  namespace std {
206
  template <class Container>
207
+ class insert_iterator {
 
208
  protected:
209
  Container* container;
210
  typename Container::iterator iter;
211
 
212
  public:
213
+ using iterator_category = output_iterator_tag;
214
+ using value_type = void;
215
+ using difference_type = void;
216
+ using pointer = void;
217
+ using reference = void;
218
+ using container_type = Container;
219
+
220
  insert_iterator(Container& x, typename Container::iterator i);
221
+ insert_iterator& operator=(const typename Container::value_type& value);
222
+ insert_iterator& operator=(typename Container::value_type&& value);
 
 
223
 
224
+ insert_iterator& operator*();
225
+ insert_iterator& operator++();
226
+ insert_iterator& operator++(int);
227
  };
228
 
229
  template <class Container>
230
  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
231
  }
 
237
 
238
  ``` cpp
239
  insert_iterator(Container& x, typename Container::iterator i);
240
  ```
241
 
242
+ *Effects:* Initializes `container` with `addressof(x)` and `iter` with
243
+ `i`.
244
 
245
  ##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
246
 
247
  ``` cpp
248
+ insert_iterator& operator=(const typename Container::value_type& value);
 
249
  ```
250
 
251
+ *Effects:* As if by:
252
 
253
  ``` cpp
254
  iter = container->insert(iter, value);
255
  ++iter;
256
  ```
257
 
258
  *Returns:* `*this`.
259
 
260
  ``` cpp
261
+ insert_iterator& operator=(typename Container::value_type&& value);
 
262
  ```
263
 
264
+ *Effects:* As if by:
265
 
266
  ``` cpp
267
  iter = container->insert(iter, std::move(value));
268
  ++iter;
269
  ```
 
271
  *Returns:* `*this`.
272
 
273
  ##### `insert_iterator::operator*` <a id="insert.iter.op*">[[insert.iter.op*]]</a>
274
 
275
  ``` cpp
276
+ insert_iterator& operator*();
277
  ```
278
 
279
  *Returns:* `*this`.
280
 
281
  ##### `insert_iterator::operator++` <a id="insert.iter.op++">[[insert.iter.op++]]</a>
282
 
283
  ``` cpp
284
+ insert_iterator& operator++();
285
+ insert_iterator& operator++(int);
286
  ```
287
 
288
  *Returns:* `*this`.
289
 
290
  ##### `inserter` <a id="inserter">[[inserter]]</a>