std::uninitialized_move

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Gestión de memoria dinámica

Punteros inteligentes unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (hasta C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) Asignadores de memoria allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Recursos de memoria pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) Almacenamiento no inicializado raw_storage_iterator (hasta C++20) get_temporary_buffer (hasta C++20) return_temporary_buffer (hasta C++20)

Algoritmos de memoria no inicializada uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Algoritmos restringidos de memoria no inicializada ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Apoyo para recolección de basura declare_reachable (C++11)(hasta C++23) undeclare_reachable (C++11)(hasta C++23) declare_no_pointers (C++11)(hasta C++23) undeclare_no_pointers (C++11)(hasta C++23) pointer_safety (C++11)(hasta C++23) get_pointer_safety (C++11)(hasta C++23) Misceláneos pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Biblioteca de C malloc aligned_alloc (C++17) calloc realloc free Gestión de memoria de bajo nivel operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

Definido en el archivo de encabezado <memory>
template<class InputIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,                                      NoThrowForwardIt d_first );	(1)	(desde C++17)
template<class ExecutionPolicy, class ForwardIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,                                      ForwardIt first, ForwardIt last,                                      NoThrowForwardIt d_first );	(2)	(desde C++17)

1) Mueve elementos del rango [first, last) a un área de memoria no inicializada que comienza en d_first como si fuera por

for(; first != last;++d_first, (void)++first)::new(/*VOIDIFICAR*/(*d_first))typenamestd::iterator_traits<NoThrowForwardIt>::value_type(std::move(*first));

donde /*VOIDIFICAR*/(e) es:

static_cast<void*>(std::addressof(e))	(hasta C++20)
const_cast<void*>(static_cast<constvolatilevoid*>(std::addressof(e)))	(desde C++20)

Si se lanza una excepción durante la inicialización, algunos objetos en [first, last) se dejan en un estado válido pero no especificado, y los objetos ya construidos se destruyen en un orden no especificado.

2) Igual que (1), pero ejecutado de acuerdo con 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.

Parámetros

first, last	-	El rango de los elementos a mover.
d_first	-	El comienzo del rango de destino.
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.
- ForwardIt debe satisfacer los requisitos de ForwardIterator.
- NoThrowForwardIt debe satisfacer los requisitos de ForwardIterator.
- Ningún incremento, asignación, comparación o direccionamiento indirecto a través de instancias válidas de NoThrowForwardIt puede lanzar excepciones.

Valor de retorno

Iterador al elemento más allá del último elemento movido.

Complejidad

Lineal en la distancia entre first y last.

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.

Posible implementación

template<class InputIt, class NoThrowForwardIt> NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first){using Value =typenamestd::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = d_first;try{for(; first != last;++first, (void)++current){::new(const_cast<void*>(static_cast<constvolatilevoid*>(std::addressof(*current)))) Value(std::move(*first));}return current;}catch(...){std::destroy(d_first, current);throw;}}

Ejemplo

Ejecuta este código

#include <cstdlib>#include <iomanip>#include <iostream>#include <memory>#include <string>   void print(auto rem, auto first, auto last){for(std::cout<< rem; first != last;++first)std::cout<<std::quoted(*first)<<' ';std::cout<<'\n';}   int main(){std::string in[]{"Home", "Work!"}; print("Inicialmente, in es: ", std::begin(in), std::end(in));   if(constexprauto sz =std::size(in);void* out =std::aligned_alloc(alignof(std::string), sizeof(std::string)* sz)){try{auto first {static_cast<std::string*>(out)};auto last {first + sz}; std::uninitialized_move(std::begin(in), std::end(in), first);   print("Después del movimiento, in es: ", std::begin(in), std::end(in)); print("Después del movimiento, out es: ", first, last);   std::destroy(first, last);}catch(...){std::cout<<"¡Excepción!\n";}std::free(out);}}

Posible salida:

Inicialmente, in es: "Home" "Work!" Después del movimiento, in es: "" "" Después del movimiento, out es: "Home" "Work!"

Véase también

uninitialized_copy	Copia un rango de objetos a una zona de memoria sin inicializar. (plantilla de función)
uninitialized_move_n (C++17)	Mueve un número de objetos a un área de memoria sin inicializar. (niebloid)
ranges::uninitialized_move (C++20)	Mueve un rango de objetos a un área de memoria sin inicializar. (niebloid)