[specialized.algorithms] - C++20 → C++23

Files changed (1) hide show

tmp/tmpxgxk3phq/{from.md → to.md} +51 -57

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

@@ -1,92 +1,90 @@
 ## Specialized `<memory>` algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-The contents specified in this subclause  [[specialized.algorithms]] are
-declared in the header `<memory>`.
 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
-[*Note 1*: When invoked on ranges of potentially-overlapping subobjects
-[[intro.object]], the algorithms specified in this subclause
-[[specialized.algorithms]] result in undefined behavior. — *end note*]
-Some algorithms specified in this clause make use of the exposition-only
-function `voidify`:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
-    return const_cast<void*>(static_cast<const volatile void*>(addressof(obj)));
   }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
 ``` cpp
 template<class I>
-concept no-throw-input-iterator = // exposition only
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 ```
-A type `I` models *`no-throw-input-iterator`* only if no exceptions are
 thrown from increment, copy construction, move construction, copy
 assignment, move assignment, or indirection through valid iterators.
 [*Note 1*: This concept allows some `input_iterator`
 [[iterator.concept.input]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class S, class I>
-concept no-throw-sentinel = sentinel_for<S, I>; // exposition only
 ```
-Types `S` and `I` model *`no-throw-sentinel`* only if no exceptions are
 thrown from copy construction, move construction, copy assignment, move
 assignment, or comparisons between valid values of type `I` and `S`.
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
-concept no-throw-input-range = // exposition only
   range<R> &&
- no-throw-input-iterator<iterator_t<R>> &&
- no-throw-sentinel<sentinel_t<R>, iterator_t<R>>;
 ```
-A type `R` models *`no-throw-input-range`* only if no exceptions are
-thrown from calls to `ranges::begin` and `ranges::end` on an object of
-type `R`.
 ``` cpp
 template<class I>
-concept no-throw-forward-iterator = // exposition only
- no-throw-input-iterator<I> &&
   forward_iterator<I> &&
- no-throw-sentinel<I, I>;
 ```
 [*Note 3*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
-concept no-throw-forward-range = // exposition only
- no-throw-input-range<R> &&
- no-throw-forward-iterator<iterator_t<R>>;
 ```
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
@@ -102,14 +100,14 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct(I first, S last);
-  template<no-throw-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
@@ -135,11 +133,11 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
@@ -165,14 +163,14 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct(I first, S last);
-  template<no-throw-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
@@ -198,11 +196,11 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
@@ -235,15 +233,15 @@ for (; first != last; ++result, (void) ++first)
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<O> S2>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
     uninitialized_copy_result<I, O>
       uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
-  template<input_range IR, no-throw-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
     uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_copy(IR&& in_range, OR&& out_range);
 }
 ```
@@ -252,13 +250,12 @@ namespace ranges {
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
-for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst) {
   ::new (voidify(*ofirst)) remove_reference_t<iter_reference_t<O>>(*ifirst);
-}
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
@@ -270,21 +267,20 @@ template<class InputIterator, class Size, class NoThrowForwardIterator>
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
-for ( ; n > 0; ++result, (void) ++first, --n) {
   ::new (voidify(*result))
     typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
-}
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
-  template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel<O> S>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
     uninitialized_copy_n_result<I, O>
       uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
@@ -293,11 +289,11 @@ namespace ranges {
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
-auto t = uninitialized_copy(counted_iterator(ifirst, n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
@@ -321,15 +317,15 @@ return result;
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<O> S2>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
     uninitialized_move_result<I, O>
       uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
-  template<input_range IR, no-throw-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
     uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_move(IR&& in_range, OR&& out_range);
 }
 ```
@@ -338,19 +334,18 @@ namespace ranges {
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
-for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst) {
   ::new (voidify(*ofirst))
     remove_reference_t<iter_reference_t<O>>(ranges::iter_move(ifirst));
-}
 return {std::move(ifirst), ofirst};
 ```
 [*Note 1*: If an exception is thrown, some objects in the range
-\[`first`, `last`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
   pair<InputIterator, NoThrowForwardIterator>
@@ -369,11 +364,11 @@ for (; n > 0; ++result, (void) ++first, --n)
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
-  template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel<O> S>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
     uninitialized_move_n_result<I, O>
       uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
@@ -382,17 +377,17 @@ namespace ranges {
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
-auto t = uninitialized_move(counted_iterator(ifirst, n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 [*Note 2*: If an exception is thrown, some objects in the range
-`first`+\[0, `n`) are left in a valid but unspecified
 state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
@@ -408,25 +403,24 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S, class T>
     requires constructible_from<iter_value_t<I>, const T&>
     I uninitialized_fill(I first, S last, const T& x);
-  template<no-throw-forward-range R, class T>
     requires constructible_from<range_value_t<R>, const T&>
     borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 }
 ```
 *Effects:* Equivalent to:
 ``` cpp
-for (; first != last; ++first) {
   ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>(x);
-}
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
@@ -442,11 +436,11 @@ for (; n--; ++first)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, class T>
     requires constructible_from<iter_value_t<I>, const T&>
     I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 ```
@@ -468,11 +462,11 @@ namespace ranges {
 }
 ```
 *Constraints:* The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
-treated as an unevaluated operand.
 *Effects:* Equivalent to:
 ``` cpp
 return ::new (voidify(*location)) T(std::forward<Args>(args)...);
@@ -507,14 +501,14 @@ for (; first != last; ++first)
   destroy_at(addressof(*first));
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-input-iterator I, no-throw-sentinel<I> S>
     requires destructible<iter_value_t<I>>
     constexpr I destroy(I first, S last) noexcept;
-  template<no-throw-input-range R>
     requires destructible<range_value_t<R>>
     constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
 }
 ```
@@ -539,17 +533,17 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-input-iterator I>
     requires destructible<iter_value_t<I>>
     constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
 }
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return destroy(counted_iterator(first, n), default_sentinel).base();
 ```

 ## Specialized `<memory>` algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
+### General <a id="specialized.algorithms.general">[[specialized.algorithms.general]]</a>
+The contents specified in [[specialized.algorithms]] are declared in the
+header `<memory>`.
 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
+Some algorithms specified in [[specialized.algorithms]] make use of the
+exposition-only function `voidify`:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
+    return addressof(obj);
   }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
 ``` cpp
 template<class I>
+concept nothrow-input-iterator = // exposition only
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 ```
+A type `I` models `nothrow-input-iterator` only if no exceptions are
 thrown from increment, copy construction, move construction, copy
 assignment, move assignment, or indirection through valid iterators.
 [*Note 1*: This concept allows some `input_iterator`
 [[iterator.concept.input]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class S, class I>
+concept nothrow-sentinel-for = sentinel_for<S, I>; // exposition only
 ```
+Types `S` and `I` model `nothrow-sentinel-for` only if no exceptions are
 thrown from copy construction, move construction, copy assignment, move
 assignment, or comparisons between valid values of type `I` and `S`.
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
+concept nothrow-input-range = // exposition only
   range<R> &&
+ nothrow-input-iterator<iterator_t<R>> &&
+ nothrow-sentinel-for<sentinel_t<R>, iterator_t<R>>;
 ```
+A type `R` models `nothrow-input-range` only if no exceptions are thrown
+from calls to `ranges::begin` and `ranges::end` on an object of type
+`R`.
 ``` cpp
 template<class I>
+concept nothrow-forward-iterator = // exposition only
+ nothrow-input-iterator<I> &&
   forward_iterator<I> &&
+ nothrow-sentinel-for<I, I>;
 ```
 [*Note 3*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
+concept nothrow-forward-range = // exposition only
+ nothrow-input-range<R> &&
+ nothrow-forward-iterator<iterator_t<R>>;
 ```
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
     typename iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct(I first, S last);
+  template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
 return first;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
     typename iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct(I first, S last);
+  template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
 return first;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
+ nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
     uninitialized_copy_result<I, O>
       uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
+  template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
     uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_copy(IR&& in_range, OR&& out_range);
 }
 ```
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
+for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
   ::new (voidify(*ofirst)) remove_reference_t<iter_reference_t<O>>(*ifirst);
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
+for ( ; n > 0; ++result, (void) ++first, --n)
   ::new (voidify(*result))
     typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
+  template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
     uninitialized_copy_n_result<I, O>
       uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
+auto t = uninitialized_copy(counted_iterator(std::move(ifirst), n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
+ nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
     uninitialized_move_result<I, O>
       uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
+  template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
     uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_move(IR&& in_range, OR&& out_range);
 }
 ```
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
+for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
   ::new (voidify(*ofirst))
     remove_reference_t<iter_reference_t<O>>(ranges::iter_move(ifirst));
 return {std::move(ifirst), ofirst};
 ```
 [*Note 1*: If an exception is thrown, some objects in the range
+\[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
   pair<InputIterator, NoThrowForwardIterator>
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
+  template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
     uninitialized_move_n_result<I, O>
       uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
+auto t = uninitialized_move(counted_iterator(std::move(ifirst), n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 [*Note 2*: If an exception is thrown, some objects in the range
+`ifirst`+\[0, `n`) are left in a valid but unspecified
 state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
     typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S, class T>
     requires constructible_from<iter_value_t<I>, const T&>
     I uninitialized_fill(I first, S last, const T& x);
+  template<nothrow-forward-range R, class T>
     requires constructible_from<range_value_t<R>, const T&>
     borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 }
 ```
 *Effects:* Equivalent to:
 ``` cpp
+for (; first != last; ++first)
   ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>(x);
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
 return first;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-forward-iterator I, class T>
     requires constructible_from<iter_value_t<I>, const T&>
     I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 ```
 }
 ```
 *Constraints:* The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
+treated as an unevaluated operand [[term.unevaluated.operand]].
 *Effects:* Equivalent to:
 ``` cpp
 return ::new (voidify(*location)) T(std::forward<Args>(args)...);
   destroy_at(addressof(*first));
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-input-iterator I, nothrow-sentinel-for<I> S>
     requires destructible<iter_value_t<I>>
     constexpr I destroy(I first, S last) noexcept;
+  template<nothrow-input-range R>
     requires destructible<range_value_t<R>>
     constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
 }
 ```
 return first;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-input-iterator I>
     requires destructible<iter_value_t<I>>
     constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
 }
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return destroy(counted_iterator(std::move(first), n), default_sentinel).base();
 ```

Diff to HTML by rtfpessoa