std::move - cppreference.com
Namespaces
Variants

    std::move

    From cppreference.com
     
    C++
     
    Algorithm library
    Constrained algorithms and algorithms on ranges (C++20)
    Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
    Non-modifying sequence operations    
    Batch operations
    (C++17)
    Search operations
    Modifying sequence operations
    Copy operations
    (C++11)
    (C++11)
    (C++11)
    Swap operations
    Transformation operations
    Generation operations
    Removing operations
    Order-changing operations
    (until C++17)(C++11)
    (C++20)(C++20)
    Sampling operations
    (C++17)

    Sorting and related operations
    Partitioning operations
    (C++11)    
    (C++11)

    Sorting operations
    Binary search operations
    (on partitioned ranges)
    Set operations (on sorted ranges)
    Merge operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    (C++11)
    (C++17)
    Lexicographical comparison operations
    (C++20)
    Permutation operations


     
    Defined in header <algorithm> 
    template< class InputIt, class OutputIt >
OutputIt move( InputIt first, InputIt last, OutputIt d_first );
    		(1) (since C++11)
    (constexpr since C++20)    		 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt2 move( ExecutionPolicy&& policy,
                 ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first );
    		(2) (since C++17)

    Moves all elements in the source range [first, last) to the destination range [d_first, std::next(d_first, std::distance(first, last))).

    1) Move starts from first and proceeding to last.
    If d_first is in the source range, the behavior is undefined.
    2) Same as (1), but the move order is determined by policy.
    This overload participates in overload resolution only if the value of the following expression is true:

    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)
    If the source and destination ranges overlap, the behavior is undefined.

    Parameters

    first, last - the pair of iterators defining the source range
    d_first - the beginning of the destination range
    policy - the execution policy to use
    Type requirements
    -
    InputIt must meet the requirements of LegacyInputIterator.
    -
    OutputIt must meet the requirements of LegacyOutputIterator.
    -
    ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.

    Return value

    The past-the-end iterator of the destination range.

    Complexity

    Exactly std::distance(first, last) assignments.

    Exceptions

    2) During the execution process:
    • If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
    • If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).

    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;
}

    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).

    Example

    The following code moves thread objects (which themselves are not copyable) from one container to another.

    Run this code
    #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

    See also