[list.ops] - C++20 → C++23

Files changed (1) hide show

tmp/tmp4yyezslk/{from.md → to.md} +40 -40

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

@@ -1,13 +1,16 @@
 #### Operations <a id="list.ops">[[list.ops]]</a>
 Since lists allow fast insertion and erasing from the middle of a list,
-certain operations are provided specifically for them.[^3] In this
-subclause, arguments for a template parameter named `Predicate` or
-`BinaryPredicate` shall meet the corresponding requirements in
-[[algorithms.requirements]]. For `merge` and `sort`, the definitions and
-requirements in [[alg.sorting]] apply.
 `list` provides three splice operations that destructively move elements
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
@@ -82,67 +85,64 @@ the erased elements.
 *Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
-*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
 size_type unique();
 template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
 *Effects:* Erases all but the first element from every consecutive group
-of equal elements referred to by the iterator `i` in the range
-\[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
-`unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
-`unique` with a predicate argument) holds. Invalidates only the
-iterators and references to the erased elements.
 *Returns:* The number of elements erased.
-*Throws:* Nothing unless an exception is thrown by `*i == *(i-1)` or
-`pred(*i, *(i - 1))`
-*Complexity:* If the range `[first, last)` is not empty, exactly
-`(last - first) - 1` applications of the corresponding predicate,
-otherwise no applications of the predicate.
 ``` cpp
 void merge(list& x);
 void merge(list&& x);
 template<class Compare> void merge(list& x, Compare comp);
 template<class Compare> void merge(list&& x, Compare comp);
 ```
-*Preconditions:* Both the list and the argument list shall be sorted
-with respect to the comparator `operator<` (for the first two overloads)
-or `comp` (for the last two overloads), and
-`get_allocator() == x.get_allocator()` is `true`.
-*Effects:* If `addressof(x) == this`, does nothing; otherwise, merges
-the two sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The
-result is a range in which the elements will be sorted in non-decreasing
-order according to the ordering defined by `comp`; that is, for every
-iterator `i`, in the range other than the first, the condition
-`comp(*i, *(i - 1))` will be `false`. Pointers and references to the
-moved elements of `x` now refer to those same elements but as members of
-`*this`. Iterators referring to the moved elements will continue to
-refer to their elements, but they now behave as iterators into `*this`,
-not into `x`.
-*Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, the
-range `[x.begin(), x.end())` is empty after the merge. No elements are
-copied by this operation.
-*Complexity:* At most `size() + x.size() - 1` applications of `comp` if
-`addressof(x) != this`; otherwise, no applications of `comp` are
-performed. If an exception is thrown other than by a comparison there
-are no effects.
 ``` cpp
 void reverse() noexcept;
 ```
@@ -159,9 +159,9 @@ template<class Compare> void sort(Compare comp);
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
-*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Approximately N log N comparisons, where `N == size()`.

 #### Operations <a id="list.ops">[[list.ops]]</a>
 Since lists allow fast insertion and erasing from the middle of a list,
+certain operations are provided specifically for them.[^3]
+In this subclause, arguments for a template parameter named `Predicate`
+or `BinaryPredicate` shall meet the corresponding requirements in
+[[algorithms.requirements]]. The semantics of `i + n` and `i - n`, where
+`i` is an iterator into the list and `n` is an integer, are the same as
+those of `next(i, n)` and `prev(i, n)`, respectively. For `merge` and
+`sort`, the definitions and requirements in [[alg.sorting]] apply.
 `list` provides three splice operations that destructively move elements
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
 *Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
+*Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 size_type unique();
 template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
+Let `binary_pred` be `equal_to<>{}` for the first overload.
+*Preconditions:* `binary_pred` is an equivalence relation.
 *Effects:* Erases all but the first element from every consecutive group
+of equivalent elements. That is, for a nonempty list, erases all
+elements referred to by the iterator `i` in the range \[`begin() + 1`,
+`end()`) for which `binary_pred(*i, *(i - 1))` is `true`. Invalidates
+only the iterators and references to the erased elements.
 *Returns:* The number of elements erased.
+*Throws:* Nothing unless an exception is thrown by the predicate.
+*Complexity:* If `empty()` is `false`, exactly `size() - 1` applications
+of the corresponding predicate, otherwise no applications of the
+predicate.
 ``` cpp
 void merge(list& x);
 void merge(list&& x);
 template<class Compare> void merge(list& x, Compare comp);
 template<class Compare> void merge(list&& x, Compare comp);
 ```
+Let `comp` be `less<>` for the first two overloads.
+*Preconditions:* `*this` and `x` are both sorted with respect to the
+comparator `comp`, and `get_allocator() == x.get_allocator()` is `true`.
+*Effects:* If `addressof(x) == this`, there are no effects. Otherwise,
+merges the two sorted ranges \[`begin()`, `end()`) and \[`x.begin()`,
+`x.end()`). The result is a range that is sorted with respect to the
+comparator `comp`. Pointers and references to the moved elements of `x`
+now refer to those same elements but as members of `*this`. Iterators
+referring to the moved elements will continue to refer to their
+elements, but they now behave as iterators into `*this`, not into `x`.
+*Complexity:* At most `size() + x.size() - 1` comparisons if
+`addressof(x) != this`; otherwise, no comparisons are performed.
+*Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
+is empty after the merge. No elements are copied by this operation. If
+an exception is thrown other than by a comparison there are no effects.
 ``` cpp
 void reverse() noexcept;
 ```
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
 *Complexity:* Approximately N log N comparisons, where `N == size()`.
+*Remarks:* Stable [[algorithm.stable]].

Diff to HTML by rtfpessoa