std:: move

Si d_first se encuentra dentro del rango [ first , last ) , el comportamiento es indefinido. En este caso, puede utilizarse std::move_backward en su lugar.

Parámetros

Valor de retorno

El iterador al elemento después del último elemento movido.

Complejidad

Exactamente std:: distance ( first, last ) asignaciones de movimiento.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy reporta errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

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

Notas

Al mover rangos superpuestos, std::move es apropiado al mover hacia la izquierda (el inicio del rango destino está fuera del rango origen) mientras que std::move_backward es apropiado al mover hacia la derecha (el final del rango destino está fuera del rango origen).

Ejemplo

El siguiente código mueve objetos de hilo (que en sí mismos no son copiables) de un contenedor a otro.

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

thread 1 ended
thread 2 ended
thread 3 ended

Véase también