std::ranges::move, std::ranges::move_result
Definido en el archivo de encabezado <algorithm> | ||
Signatura de la llamada | ||
template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O > requires std::indirectly_movable<I, O> | (1) | (desde C++20) |
template<ranges::input_range R, std::weakly_incrementable O > requires std::indirectly_movable<ranges::iterator_t<R>, O> | (2) | (desde C++20) |
Tipos auxiliares | ||
template<class I, class O > using move_result =ranges::in_out_result<I, O>; | (3) | (desde C++20) |
[first, last), a otro rango que comienza en result. El comportamiento no está definido si result está dentro del rango [first, last). En tal caso, ranges::move_backward se puede usar en su lugar.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.
Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Contenido |
[editar]Parámetros
| first | - | El comienzo del rango de los elementos a mover. |
| last | - | El final del rango de los elementos a mover. |
| r | - | El rango de los elementos a mover. |
| result | - | El comienzo del rango de destino. |
[editar]Valor de retorno
{last, result + N}, donde
[editar]Complejidad
Exactamente N asignaciones por movimiento.
[editar]Notas
Al mover rangos superpuestos, ranges::move es apropiado cuando se mueve hacia la izquierda (el comienzo del rango de destino está fuera del rango de origen) mientras que ranges::move_backward es apropiado cuando se mueve hacia la derecha (el final del rango de destino está fuera del rango de origen).
[editar]Posible implementación
struct move_fn {template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O> requires std::indirectly_movable<I, O>constexpr ranges::move_result<I, O> operator()(I first, S last, O result)const{for(; first != last;++first, ++result)*result =ranges::iter_move(first);return{std::move(first), std::move(result)};}template<ranges::input_range R, std::weakly_incrementable O> requires std::indirectly_movable<ranges::iterator_t<R>, O>constexpr ranges::move_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result)const{return(*this)(ranges::begin(r), ranges::end(r), std::move(result));}}; inlineconstexpr move_fn move {}; |
[editar]Ejemplo
El siguiente código mueve objetos de tipo hilo (que en sí mismos no se pueden copiar) de un contenedor a otro.
#include <algorithm>#include <chrono>#include <iostream>#include <iterator>#include <list>#include <thread>#include <vector>usingnamespace std::literals::chrono_literals; void f(std::chrono::milliseconds n){std::this_thread::sleep_for(n);std::cout<<"El hilo con n="<< n.count()<<"ms finalizó"<<std::endl;} int main(){std::vector<std::jthread> v; v.emplace_back(f, 400ms); v.emplace_back(f, 600ms); v.emplace_back(f, 800ms); std::list<std::jthread> l; // std::ranges::copy() no compilaría, ya que std::jthread no es copiable std::ranges::move(v, std::back_inserter(l));}
Salida:
El hilo con n=400ms finalizó El hilo con n=600ms finalizó El hilo con n=800ms finalizó
[editar]Véase también
(C++20) | Mueve un rango de elementos a una nueva ubicación en orden inverso. (niebloid) |
(C++20)(C++20) | Copia un rango de elementos a una nueva ubicación. (niebloid) |
(C++20) | Copia un rango de elementos en orden inverso. (niebloid) |
(C++11) | Mueve una serie de elementos a una nueva ubicación. (plantilla de función) |
(C++11) | Obtiene una referencia r-valor (plantilla de función) |
