std::move
<algorithm>
OutputIt move( InputIt first, InputIt last,
(constexpr since C++20)
ForwardIt2 move( ExecutionPolicy&& policy,
ForwardIt1 first, ForwardIt1 last,
[first, last), to another range beginning at d_first, starting from first and proceeding to last. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.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 is within the range [first, last), the behavior is undefined. In this case, std::move_backward may be used instead.
Contents
[edit] Parameters
InputIt must meet the requirements of LegacyInputIterator.
OutputIt must meet the requirements of LegacyOutputIterator.
ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.
[edit] Return value
The iterator to the element past the last element moved.
[edit] Complexity
Exactly std::distance (first, last) move assignments.
[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 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 OutputIt> OutputIt move(InputIt first, InputIt last, OutputIt d_first) { for (; first != last; ++d_first, ++first) *d_first = std::move(*first); return d_first; }
[edit] Notes
When moving overlapping ranges, std::move is appropriate when moving to the left (beginning of the destination range is outside the source range) while std::move_backward is appropriate when moving to the right (end of the destination range is outside the source range).
[edit] Example
The following code moves thread objects (which themselves are not copyable) from one container to another.
#include <algorithm> #include <chrono> #include <iostream> #include <iterator> #include <list> #include <thread> #include <vector> void f(int n) { std::this_thread::sleep_for (std::chrono::seconds (n)); std::cout << "thread " << n << " ended" << std::endl ; } int main() { std::vector <std::jthread > v; v.emplace_back(f, 1); v.emplace_back(f, 2); v.emplace_back(f, 3); std::list <std::jthread > l; // copy() would not compile, because std::jthread is noncopyable std::move(v.begin(), v.end(), std::back_inserter (l)); }
Output:
thread 1 ended thread 2 ended thread 3 ended