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

Files changed (1) hide show

tmp/tmp8p7b84dq/{from.md → to.md} +411 -86

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

@@ -1,230 +1,555 @@
-### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-Throughout this subclause, the names of template parameters are used to
-express type requirements.
-- If an algorithm’s template parameter is named `InputIterator`, the
-  template argument shall satisfy the requirements of an input
-  iterator ([[input.iterators]]).
-- If an algorithm’s template parameter is named `ForwardIterator`, the
-  template argument shall satisfy the requirements of a forward
-  iterator ([[forward.iterators]]), and is required to have the
-  property that no exceptions are thrown from increment, assignment,
-  comparison, or indirection through valid iterators.
 Unless otherwise specified, if an exception is thrown in the following
-algorithms there are no effects.
-#### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
-template <class T> constexpr T* addressof(T& r) noexcept;
 ```
-*Returns:* The actual address of the object or function referenced by
-`r`, even in the presence of an overloaded `operator&`.
-*Remarks:* An expression `addressof(E)` is a constant
-subexpression ([[defns.const.subexpr]]) if `E` is an lvalue constant
-subexpression.
-#### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
-template <class ForwardIterator>
- void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type;
 ```
 ``` cpp
-template <class ForwardIterator, class Size>
- ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type;
 return first;
 ```
-#### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
 ``` cpp
-template <class ForwardIterator>
- void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type();
 ```
 ``` cpp
-template <class ForwardIterator, class Size>
- ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type();
 return first;
 ```
-#### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
 ``` cpp
-template <class InputIterator, class ForwardIterator>
-  ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
-                                     ForwardIterator result);
 ```
-*Effects:* As if by:
 ``` cpp
 for (; first != last; ++result, (void) ++first)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
-template <class InputIterator, class Size, class ForwardIterator>
- ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
-                                       ForwardIterator result);
 ```
-*Effects:* As if by:
 ``` cpp
 for ( ; n > 0; ++result, (void) ++first, --n) {
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(*first);
 }
 ```
 *Returns:* `result`.
-#### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ``` cpp
-template <class InputIterator, class ForwardIterator>
-  ForwardIterator uninitialized_move(InputIterator first, InputIterator last,
-                                     ForwardIterator result);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
 return result;
 ```
-*Remarks:* If an exception is thrown, some objects in the range
-\[`first`, `last`) are left in a valid but unspecified state.
 ``` cpp
-template <class InputIterator, class Size, class ForwardIterator>
- pair<InputIterator, ForwardIterator>
- uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void) ++first, --n)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
 return {first, result};
 ```
-*Remarks:* If an exception is thrown, some objects in the range
-\[`first`, `std::next(first,n)`) are left in a valid but unspecified
-state.
-#### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
-template <class ForwardIterator, class T>
-  void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                          const T& x);
 ```
-*Effects:* As if by:
 ``` cpp
 for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type(x);
 ```
 ``` cpp
-template <class ForwardIterator, class Size, class T>
- ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 ```
-*Effects:* As if by:
 ``` cpp
 for (; n--; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type(x);
 return first;
 ```
-#### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>
 ``` cpp
 template<class T>
-  void destroy_at(T* location);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-location->~T();
 ```
 ``` cpp
-template <class ForwardIterator>
- void destroy(ForwardIterator first, ForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
   destroy_at(addressof(*first));
 ```
 ``` cpp
-template <class ForwardIterator, class Size>
- ForwardIterator destroy_n(ForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
   destroy_at(addressof(*first));
 return first;
 ```

+## 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
+template<class NoThrowForwardIterator>
+  void uninitialized_default_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
+```
+*Effects:* Equivalent to:
+``` cpp
+for (; first != last; ++first)
+  ::new (voidify(*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);
+}
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>;
+return first;
 ```
 ``` cpp
+template<class NoThrowForwardIterator, class Size>
+ NoThrowForwardIterator uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first))
+    typename iterator_traits<NoThrowForwardIterator>::value_type;
 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);
+}
+```
+*Effects:* Equivalent to:
+``` cpp
+return uninitialized_default_construct(counted_iterator(first, n),
+                                       default_sentinel).base();
+```
+### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
+``` cpp
+template<class NoThrowForwardIterator>
+  void uninitialized_value_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
+```
+*Effects:* Equivalent to:
+``` cpp
+for (; first != last; ++first)
+  ::new (voidify(*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);
+}
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>();
+return first;
 ```
 ``` cpp
+template<class NoThrowForwardIterator, class Size>
+ NoThrowForwardIterator uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first))
+    typename iterator_traits<NoThrowForwardIterator>::value_type();
 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);
+}
+```
+*Effects:* Equivalent to:
 ``` cpp
+return uninitialized_value_construct(counted_iterator(first, n),
+                                     default_sentinel).base();
 ```
+### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
+``` cpp
+template<class InputIterator, class NoThrowForwardIterator>
+  NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
+                                            NoThrowForwardIterator result);
+```
+*Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
+\[`first`, `last`).
+*Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++result, (void) ++first)
+  ::new (voidify(*result))
+    typename iterator_traits<NoThrowForwardIterator>::value_type(*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);
+}
 ```
+*Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
+`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>
+  NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
+                                              NoThrowForwardIterator result);
+```
+*Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
+`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);
+}
+```
+*Preconditions:* \[`ofirst`, `olast`) does not overlap with
+`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>
+``` cpp
+template<class InputIterator, class NoThrowForwardIterator>
+  NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
+                                            NoThrowForwardIterator result);
+```
+*Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
+\[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
+  ::new (voidify(*result))
+    typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 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);
+}
+```
+*Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
+`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>
+    uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
+```
+*Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
+`n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void) ++first, --n)
+  ::new (voidify(*result))
+    typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 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);
+}
+```
+*Preconditions:* \[`ofirst`, `olast`) does not overlap with
+`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
+template<class NoThrowForwardIterator, class T>
+  void uninitialized_fill(NoThrowForwardIterator first, NoThrowForwardIterator last, const T& x);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*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>
+  NoThrowForwardIterator uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
+```
+*Effects:* Equivalent to:
 ``` cpp
 for (; n--; ++first)
+  ::new (voidify(*first))
+    typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 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);
+}
+```
+*Effects:* Equivalent to:
+``` cpp
+return uninitialized_fill(counted_iterator(first, n), default_sentinel, x).base();
+```
+### `construct_at` <a id="specialized.construct">[[specialized.construct]]</a>
+``` cpp
+template<class T, class... Args>
+  constexpr T* construct_at(T* location, Args&&... args);
+namespace ranges {
+  template<class T, class... Args>
+    constexpr T* construct_at(T* location, Args&&... args);
+}
+```
+*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)...);
+```
+### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>
 ``` cpp
 template<class T>
+ constexpr void destroy_at(T* location);
+namespace ranges {
+  template<destructible T>
+    constexpr void destroy_at(T* location) noexcept;
+}
+```
+*Effects:*
+- If `T` is an array type, equivalent to
+  `destroy(begin(*location), end(*location))`.
+- Otherwise, equivalent to `location->T̃()`.
+``` cpp
+template<class NoThrowForwardIterator>
+  constexpr void destroy(NoThrowForwardIterator first, NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+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;
+}
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
   destroy_at(addressof(*first));
+return first;
 ```
 ``` cpp
+template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator destroy_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
   destroy_at(addressof(*first));
 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();
+```

Diff to HTML by rtfpessoa