std::move
De cppreference.com
| Definido en el archivo de encabezado <algorithm>
|
||
| (1) | ||
| template< class InputIt, class OutputIt > OutputIt move( InputIt first, InputIt last, OutputIt d_first ); |
(desde C++11) (hasta C++20) |
|
| template< class InputIt, class OutputIt > constexpr OutputIt move( InputIt first, InputIt last, OutputIt d_first ); |
(desde C++20) | |
| template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt2 move( ExecutionPolicy&& policy, |
(2) | (desde C++17) |
1) Mueve los elementos en el rango
[first, last) a otro rango que comienza en d_first, comenzando desde el primero y continuando hasta last - 1. Después de esta operación, los elementos en el rango desde el que se movió aún contendrán valores válidos del tipo apropiado, pero no necesariamente los mismos valores que antes del movimiento.2) Igual que (1), pero se ejecuta conforme a la política policy. Esta sobrecarga no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.
Contenido |
[editar] Parámetros
| first, last | - | El rango de los elementos a mover. |
| d_first | - | El comienzo del rango de destino. El comportamiento no está definido si d_first está dentro del rango [first, last). En este caso, se puede usar std::move_backward en lugar de std::move.
|
| policy | - | La política de ejecución a usar. Véase política de ejecución para más detalles. |
| Requisitos de tipo | ||
-InputIt debe satisfacer los requisitos de InputIterator.
| ||
-OutputIt debe satisfacer los requisitos de OutputIterator.
| ||
-ForwardIt1, ForwardIt2 debe satisfacer los requisitos de ForwardIterator.
| ||
[editar] Valor de retorno
Un iterador de salida al elemento más allá del último elemento movido (d_first + (last - first)).
[editar] Complejidad
Exactamente last - first asignaciones por movimiento.
[editar] Excepciones
La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:
- Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
- Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.
[editar] Posible implementación
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; } |
[editar] Notas
Al mover rangos superpuestos, std::move es apropiado cuando se mueve hacia la izquierda (el comienzo del rango de destino está fuera del rango de origen) mientras que std::move_backward es apropiado cuando se mueve hacia la derecha (el final del rango de destino está fuera del rango de origen).
[editar] Ejemplo
El siguiente código mueve objetos de tipo hilo (que en sí mismos no se pueden copiar) de un contenedor a otro.
Ejecuta este código
#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 << "El hilo " << n << " finalizó" << 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() no compilaría, ya que std::jthread no es copiable std::move(v.begin(), v.end(), std::back_inserter(l)); }
Salida:
El hilo 1 finalizó El hilo 2 finalizó El hilo 3 finalizó
[editar] Véase también
| (C++11) |
Mueve una serie de elementos a una nueva ubicación en orden inverso. (plantilla de función) |
| (C++11) |
Obtiene una referencia r-valor (plantilla de función) |
| (C++20) |
Mueve un rango de elementos a una nueva ubicación. (niebloid) |
