std::uninitialized_move
<memory>
NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,
(constexpr since C++26)
class ForwardIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last,
[
first,
last)
(using move semantics if supported) 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(/* value */);
return d_first;
[
first,
last)
are left in a valid but unspecified state, and the objects already constructed are destroyed in an unspecified order.std::is_execution_policy_v <std::decay_t <ExecutionPolicy>> is true.
(until C++20)std::is_execution_policy_v <std::remove_cvref_t <ExecutionPolicy>> is true.
(since C++20)
If d_first +
[
0,
std::distance (first, last))
overlaps with [
first,
last)
, the behavior is undefined.
Contents
[edit] Parameters
InputIt
must meet the requirements of LegacyInputIterator.
ForwardIt
must meet the requirements of LegacyForwardIterator.
NoThrowForwardIt
must meet the requirements of LegacyForwardIterator.
NoThrowForwardIt
may throw exceptions.
[edit] Return value
As described above.
[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
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.
[edit] Notes
When the input iterator deferences to an rvalue, the behavior of std::uninitialized_move
is same as std::uninitialized_copy .
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr for specialized memory algorithms, (1) |
[edit] Possible implementation
template<class InputIt, class NoThrowForwardIt> constexpr NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first) { using ValueType = typename std::iterator_traits <NoThrowForwardIt>::value_type; auto current = d_first; try { for (; first != last; ++first, (void) ++current) { auto addr = static_cast<void*>(std::addressof (*current)); if constexpr (std::is_lvalue_reference_v <decltype(*first)>) ::new (addr) ValueType(std::move(*first)); else ::new (addr) ValueType(*first); } return current; } catch (...) { std::destroy (d_first, current); throw; } }
[edit] 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!"
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 3870 | C++20 | this algorithm might create objects on a const storage | kept disallowed |
LWG 3918 | C++17 | additional temporary materialization was required when the input iterator deferences to a prvalue |
copies the element in this case |
[edit] See also
(algorithm function object)[edit]