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

Files changed (1) hide show

tmp/tmp5wvtq9r4/{from.md → to.md} +165 -25

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

@@ -1,90 +1,230 @@
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-All the iterators that are used as template parameters in the following
-algorithms are required to have their `operator*` return an object for
-which `operator&` is defined and returns a pointer to `T`. In the
-algorithm `uninitialized_copy`, the template parameter `InputIterator`
-is required to satisfy the requirements of an input iterator (
-[[input.iterators]]). In all of the following algorithms, the template
-parameter `ForwardIterator` is required to 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. In the following
-algorithms, if an exception is thrown there are no effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
-template <class T> 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&`.
 #### `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:*
 ``` cpp
-for (; first != last; ++result, ++first)
-  ::new (static_cast<void*>(&*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:*
 ``` cpp
-for ( ; n > 0; ++result, ++first, --n) {
-  ::new (static_cast<void*>(&*result))
     typename iterator_traits<ForwardIterator>::value_type(*first);
 }
 ```
-*Returns:* `result`
 #### `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:*
 ``` cpp
 for (; first != last; ++first)
-  ::new (static_cast<void*>(&*first))
     typename iterator_traits<ForwardIterator>::value_type(x);
 ```
-#### `uninitialized_fill_n` <a id="uninitialized.fill.n">[[uninitialized.fill.n]]</a>
 ``` cpp
 template <class ForwardIterator, class Size, class T>
   ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 ```
-*Effects:*
 ``` cpp
 for (; n--; ++first)
-  ::new (static_cast<void*>(&*first))
     typename iterator_traits<ForwardIterator>::value_type(x);
 return first;
 ```

 ### 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;
+```

Diff to HTML by rtfpessoa