std::uninitialized_move
Defined in header <memory> |
||
---|---|---|
template< class InputIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( InputIt first, InputIt last, NoThrowForwardIt d_first ); |
(1) | (since C++17) |
template< class ExecutionPolicy, class ForwardIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, NoThrowForwardIt 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 (/*VOIDIFY*/(*d_first)) typename std::iterator_traits<NoThrowForwardIt>::value_type(std::move(*first));
where /*VOIDIFY*/(e)
is:
static_cast<void*>(std::addressof(e)) |
(until C++20) |
const_cast<void*>(static_cast<const volatile void*>(std::addressof(e))) |
(since C++20) |
If an exception is thrown during the initialization, some objects in
[first, last)
are left in a valid but unspecified state, and the objects already constructed are destroyed in an unspecified order.
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>>
(until C++20)
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
(since C++20) is true.
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 | ||
-InputIt must meet the requirements of LegacyInputIterator. |
||
-ForwardIt must meet the requirements of LegacyForwardIterator. |
||
-NoThrowForwardIt must meet the requirements of LegacyForwardIterator. |
||
-No increment, assignment, comparison, or indirection through valid instances of NoThrowForwardIt may throw exceptions. |
Return value
Iterator to the element past the last element moved.
Complexity
Linear in the distance between first
and last
.
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
ExecutionPolicy
is one of the 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.
Possible implementation
template<class InputIt, class NoThrowForwardIt> NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first) { using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = d_first; try { for (; first != last; ++first, (void) ++current) { ::new (const_cast<void*>(static_cast<const volatile void*>( std::addressof(*current)))) Value(std::move(*first)); } return current; } catch (...) { std::destroy(d_first, current); throw; } } |
Example
#include <cstdlib> #include <iomanip> #include <iostream> #include <memory> #include <string> void print(auto rem, auto first, auto last) { for (std::cout << rem; first != last; ++first) std::cout << std::quoted(*first) << ' '; std::cout << '\n'; } int main() { std::string in[] { "Home", "Work!" }; print("initially, in: ", std::begin(in), std::end(in)); if ( constexpr auto sz = std::size(in); void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz) ) { try { auto first {static_cast<std::string*>(out)}; auto last {first + sz}; std::uninitialized_move(std::begin(in), std::end(in), first); print("after move, in: ", std::begin(in), std::end(in)); print("after move, out: ", first, last); std::destroy(first, last); } catch (...) { std::cout << "Exception!\n"; } std::free(out); } }
Possible output:
initially, in: "Home" "Work!" after move, in: "" "" after move, out: "Home" "Work!"
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) |
(C++20)
|
moves a range of objects to an uninitialized area of memory (niebloid) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory/uninitialized_move