std::uninitialized_move
From cppreference.com
                    
                                        
                    
                    
                                                            
                    | Defined in header  <memory> | ||
| template< class InputIt, class ForwardIt > ForwardIt uninitialized_move( InputIt first, InputIt last, ForwardIt d_first ); | (1) | (since C++17) | 
| template< class ExecutionPolicy, class InputIt, class ForwardIt > ForwardIt uninitialized_move( ExecutionPolicy&& policy, InputIt first, InputIt last, ForwardIt d_first ); | (2) | (since C++17) | 
1) Moves elements from the range 
[first, last) to an uninitialized memory area beginning at d_first as if by 
for (; first != last; ++d_first, (void) ++first) ::new (static_cast<void*>(std::addressof(*d_first))) typename std::iterator_traits<ForwardIt>::value_type(std::move(*first));
 If an exception is thrown during the initialization, some objects in 
[first, last) are left in a valid but unspecified state.2) Same as (1), but executed according to 
policy. This overload does not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true| Contents | 
[edit] Parameters
| first, last | - | the range of the elements to move | 
| d_first | - | the beginning of the destination range | 
| policy | - | the execution policy to use. See execution policy for details. | 
| Type requirements | ||
| - InputItmust meet the requirements ofInputIterator. | ||
| - ForwardItmust meet the requirements ofForwardIterator. | ||
| -No increment, assignment, comparison, or indirection through valid instances of ForwardItmay throw exceptions. | ||
[edit] Return value
Iterator to the element past the last element moved.
[edit] Complexity
Linear in the distance between first and last
[edit] Exceptions
The overload with a template parameter named ExecutionPolicy reports errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicyis one of the three standard policies, std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
- If the algorithm fails to allocate memory, std::bad_alloc is thrown.
[edit] Possible implementation
| template<class InputIt, class ForwardIt> ForwardIt uninitialized_move(InputIt first, InputIt last, ForwardIt d_first) { typedef typename std::iterator_traits<ForwardIt>::value_type Value; ForwardIt current = d_first; try { for (; first != last; ++first, (void) ++current) { ::new (static_cast<void*>(std::addressof(*current))) Value(std::move(*first)); } return current; } catch (...) { for (; d_first != current; ++d_first) { d_first->~Value(); } throw; } } | 
[edit] Example
| This section is incomplete Reason: no example | 
[edit] See also
| copies a range of objects to an uninitialized area of memory (function template) | |
| (C++17) | moves a number of objects to an uninitialized area of memory (function template) | 


