tmp/tmphtwvmc3l/{from.md → to.md}
RENAMED
|
@@ -44,12 +44,10 @@ namespace std {
|
|
| 44 |
reverse_iterator operator- (difference_type n) const;
|
| 45 |
reverse_iterator& operator-=(difference_type n);
|
| 46 |
unspecified operator[](difference_type n) const;
|
| 47 |
protected:
|
| 48 |
Iterator current;
|
| 49 |
-
private:
|
| 50 |
-
Iterator deref_tmp; // exposition only
|
| 51 |
};
|
| 52 |
|
| 53 |
template <class Iterator1, class Iterator2>
|
| 54 |
bool operator==(
|
| 55 |
const reverse_iterator<Iterator1>& x,
|
|
@@ -75,15 +73,18 @@ namespace std {
|
|
| 75 |
const reverse_iterator<Iterator1>& x,
|
| 76 |
const reverse_iterator<Iterator2>& y);
|
| 77 |
template <class Iterator1, class Iterator2>
|
| 78 |
auto operator-(
|
| 79 |
const reverse_iterator<Iterator1>& x,
|
| 80 |
-
const reverse_iterator<Iterator2>& y) -> decltype(y.
|
| 81 |
template <class Iterator>
|
| 82 |
reverse_iterator<Iterator> operator+(
|
| 83 |
typename reverse_iterator<Iterator>::difference_type n,
|
| 84 |
const reverse_iterator<Iterator>& x);
|
|
|
|
|
|
|
|
|
|
| 85 |
}
|
| 86 |
```
|
| 87 |
|
| 88 |
#### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
|
| 89 |
|
|
@@ -154,27 +155,21 @@ reference operator*() const;
|
|
| 154 |
```
|
| 155 |
|
| 156 |
*Effects:*
|
| 157 |
|
| 158 |
``` cpp
|
| 159 |
-
|
| 160 |
-
--
|
| 161 |
-
return *deref_tmp;
|
| 162 |
```
|
| 163 |
|
| 164 |
-
This operation must use an auxiliary member variable rather than a
|
| 165 |
-
temporary variable to avoid returning a reference that persists beyond
|
| 166 |
-
the lifetime of its associated iterator.
|
| 167 |
-
(See [[iterator.requirements]].)
|
| 168 |
-
|
| 169 |
##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
|
| 170 |
|
| 171 |
``` cpp
|
| 172 |
pointer operator->() const;
|
| 173 |
```
|
| 174 |
|
| 175 |
-
*Returns:* `
|
| 176 |
|
| 177 |
##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
|
| 178 |
|
| 179 |
``` cpp
|
| 180 |
reverse_iterator& operator++();
|
|
@@ -337,11 +332,11 @@ template <class Iterator1, class Iterator2>
|
|
| 337 |
|
| 338 |
``` cpp
|
| 339 |
template <class Iterator1, class Iterator2>
|
| 340 |
auto operator-(
|
| 341 |
const reverse_iterator<Iterator1>& x,
|
| 342 |
-
const reverse_iterator<Iterator2>& y) -> decltype(y.
|
| 343 |
```
|
| 344 |
|
| 345 |
*Returns:* `y.current - x.current`.
|
| 346 |
|
| 347 |
##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
|
|
@@ -353,10 +348,19 @@ template <class Iterator>
|
|
| 353 |
const reverse_iterator<Iterator>& x);
|
| 354 |
```
|
| 355 |
|
| 356 |
*Returns:* `reverse_iterator<Iterator> (x.current - n)`.
|
| 357 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 358 |
### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
|
| 359 |
|
| 360 |
To make it possible to deal with insertion in the same way as writing
|
| 361 |
into an array, a special kind of iterator adaptors, called *insert
|
| 362 |
iterators*, are provided in the library. With regular iterator classes,
|
|
@@ -420,11 +424,11 @@ namespace std {
|
|
| 420 |
|
| 421 |
``` cpp
|
| 422 |
explicit back_insert_iterator(Container& x);
|
| 423 |
```
|
| 424 |
|
| 425 |
-
*Effects:* Initializes `container` with `
|
| 426 |
|
| 427 |
##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
|
| 428 |
|
| 429 |
``` cpp
|
| 430 |
back_insert_iterator<Container>&
|
|
@@ -504,11 +508,11 @@ namespace std {
|
|
| 504 |
|
| 505 |
``` cpp
|
| 506 |
explicit front_insert_iterator(Container& x);
|
| 507 |
```
|
| 508 |
|
| 509 |
-
*Effects:* Initializes `container` with `
|
| 510 |
|
| 511 |
##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
|
| 512 |
|
| 513 |
``` cpp
|
| 514 |
front_insert_iterator<Container>&
|
|
@@ -589,11 +593,12 @@ namespace std {
|
|
| 589 |
|
| 590 |
``` cpp
|
| 591 |
insert_iterator(Container& x, typename Container::iterator i);
|
| 592 |
```
|
| 593 |
|
| 594 |
-
*Effects:* Initializes `container` with `
|
|
|
|
| 595 |
|
| 596 |
##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
|
| 597 |
|
| 598 |
``` cpp
|
| 599 |
insert_iterator<Container>&
|
|
@@ -650,13 +655,13 @@ template <class Container>
|
|
| 650 |
*Returns:* `insert_iterator<Container>(x, i)`.
|
| 651 |
|
| 652 |
### Move iterators <a id="move.iterators">[[move.iterators]]</a>
|
| 653 |
|
| 654 |
Class template `move_iterator` is an iterator adaptor with the same
|
| 655 |
-
behavior as the underlying iterator except that its
|
| 656 |
implicitly converts the value returned by the underlying iterator’s
|
| 657 |
-
|
| 658 |
be called with move iterators to replace copying with moving.
|
| 659 |
|
| 660 |
``` cpp
|
| 661 |
list<string> s;
|
| 662 |
// populate the list s
|
|
@@ -728,11 +733,11 @@ namespace std {
|
|
| 728 |
const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
|
| 729 |
template <class Iterator>
|
| 730 |
move_iterator<Iterator> operator+(
|
| 731 |
typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
|
| 732 |
template <class Iterator>
|
| 733 |
-
move_iterator<Iterator> make_move_iterator(
|
| 734 |
}
|
| 735 |
```
|
| 736 |
|
| 737 |
#### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
|
| 738 |
|
|
@@ -957,10 +962,10 @@ template <class Iterator>
|
|
| 957 |
|
| 958 |
*Returns:* `x + n`.
|
| 959 |
|
| 960 |
``` cpp
|
| 961 |
template <class Iterator>
|
| 962 |
-
move_iterator<Iterator> make_move_iterator(
|
| 963 |
```
|
| 964 |
|
| 965 |
*Returns:* `move_iterator<Iterator>(i)`.
|
| 966 |
|
|
|
|
| 44 |
reverse_iterator operator- (difference_type n) const;
|
| 45 |
reverse_iterator& operator-=(difference_type n);
|
| 46 |
unspecified operator[](difference_type n) const;
|
| 47 |
protected:
|
| 48 |
Iterator current;
|
|
|
|
|
|
|
| 49 |
};
|
| 50 |
|
| 51 |
template <class Iterator1, class Iterator2>
|
| 52 |
bool operator==(
|
| 53 |
const reverse_iterator<Iterator1>& x,
|
|
|
|
| 73 |
const reverse_iterator<Iterator1>& x,
|
| 74 |
const reverse_iterator<Iterator2>& y);
|
| 75 |
template <class Iterator1, class Iterator2>
|
| 76 |
auto operator-(
|
| 77 |
const reverse_iterator<Iterator1>& x,
|
| 78 |
+
const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
|
| 79 |
template <class Iterator>
|
| 80 |
reverse_iterator<Iterator> operator+(
|
| 81 |
typename reverse_iterator<Iterator>::difference_type n,
|
| 82 |
const reverse_iterator<Iterator>& x);
|
| 83 |
+
|
| 84 |
+
template <class Iterator>
|
| 85 |
+
reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
|
| 86 |
}
|
| 87 |
```
|
| 88 |
|
| 89 |
#### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
|
| 90 |
|
|
|
|
| 155 |
```
|
| 156 |
|
| 157 |
*Effects:*
|
| 158 |
|
| 159 |
``` cpp
|
| 160 |
+
Iterator tmp = current;
|
| 161 |
+
return *--tmp;
|
|
|
|
| 162 |
```
|
| 163 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 164 |
##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
|
| 165 |
|
| 166 |
``` cpp
|
| 167 |
pointer operator->() const;
|
| 168 |
```
|
| 169 |
|
| 170 |
+
*Returns:* `std::addressof(operator*())`.
|
| 171 |
|
| 172 |
##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
|
| 173 |
|
| 174 |
``` cpp
|
| 175 |
reverse_iterator& operator++();
|
|
|
|
| 332 |
|
| 333 |
``` cpp
|
| 334 |
template <class Iterator1, class Iterator2>
|
| 335 |
auto operator-(
|
| 336 |
const reverse_iterator<Iterator1>& x,
|
| 337 |
+
const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
|
| 338 |
```
|
| 339 |
|
| 340 |
*Returns:* `y.current - x.current`.
|
| 341 |
|
| 342 |
##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
|
|
|
|
| 348 |
const reverse_iterator<Iterator>& x);
|
| 349 |
```
|
| 350 |
|
| 351 |
*Returns:* `reverse_iterator<Iterator> (x.current - n)`.
|
| 352 |
|
| 353 |
+
##### Non-member function `make_reverse_iterator()` <a id="reverse.iter.make">[[reverse.iter.make]]</a>
|
| 354 |
+
|
| 355 |
+
``` cpp
|
| 356 |
+
template <class Iterator>
|
| 357 |
+
reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
|
| 358 |
+
```
|
| 359 |
+
|
| 360 |
+
*Returns:* `reverse_iterator<Iterator>(i)`.
|
| 361 |
+
|
| 362 |
### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
|
| 363 |
|
| 364 |
To make it possible to deal with insertion in the same way as writing
|
| 365 |
into an array, a special kind of iterator adaptors, called *insert
|
| 366 |
iterators*, are provided in the library. With regular iterator classes,
|
|
|
|
| 424 |
|
| 425 |
``` cpp
|
| 426 |
explicit back_insert_iterator(Container& x);
|
| 427 |
```
|
| 428 |
|
| 429 |
+
*Effects:* Initializes `container` with `std::addressof(x)`.
|
| 430 |
|
| 431 |
##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
|
| 432 |
|
| 433 |
``` cpp
|
| 434 |
back_insert_iterator<Container>&
|
|
|
|
| 508 |
|
| 509 |
``` cpp
|
| 510 |
explicit front_insert_iterator(Container& x);
|
| 511 |
```
|
| 512 |
|
| 513 |
+
*Effects:* Initializes `container` with `std::addressof(x)`.
|
| 514 |
|
| 515 |
##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
|
| 516 |
|
| 517 |
``` cpp
|
| 518 |
front_insert_iterator<Container>&
|
|
|
|
| 593 |
|
| 594 |
``` cpp
|
| 595 |
insert_iterator(Container& x, typename Container::iterator i);
|
| 596 |
```
|
| 597 |
|
| 598 |
+
*Effects:* Initializes `container` with `std::addressof(x)` and `iter`
|
| 599 |
+
with `i`.
|
| 600 |
|
| 601 |
##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
|
| 602 |
|
| 603 |
``` cpp
|
| 604 |
insert_iterator<Container>&
|
|
|
|
| 655 |
*Returns:* `insert_iterator<Container>(x, i)`.
|
| 656 |
|
| 657 |
### Move iterators <a id="move.iterators">[[move.iterators]]</a>
|
| 658 |
|
| 659 |
Class template `move_iterator` is an iterator adaptor with the same
|
| 660 |
+
behavior as the underlying iterator except that its indirection operator
|
| 661 |
implicitly converts the value returned by the underlying iterator’s
|
| 662 |
+
indirection operator to an rvalue reference. Some generic algorithms can
|
| 663 |
be called with move iterators to replace copying with moving.
|
| 664 |
|
| 665 |
``` cpp
|
| 666 |
list<string> s;
|
| 667 |
// populate the list s
|
|
|
|
| 733 |
const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
|
| 734 |
template <class Iterator>
|
| 735 |
move_iterator<Iterator> operator+(
|
| 736 |
typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
|
| 737 |
template <class Iterator>
|
| 738 |
+
move_iterator<Iterator> make_move_iterator(Iterator i);
|
| 739 |
}
|
| 740 |
```
|
| 741 |
|
| 742 |
#### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
|
| 743 |
|
|
|
|
| 962 |
|
| 963 |
*Returns:* `x + n`.
|
| 964 |
|
| 965 |
``` cpp
|
| 966 |
template <class Iterator>
|
| 967 |
+
move_iterator<Iterator> make_move_iterator(Iterator i);
|
| 968 |
```
|
| 969 |
|
| 970 |
*Returns:* `move_iterator<Iterator>(i)`.
|
| 971 |
|