std::uninitialized_move
De es.cppreference.net
| Definido en el encabezado <memory>
|
||
template< class InputIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,
NoThrowForwardIt d_first );
|
(1) | (desde C++17) (constexpr desde C++26) |
template< class ExecutionPolicy,
class ForwardIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last,
NoThrowForwardIt d_first );
|
(2) | (desde C++17) |
1) Construye elementos en el rango de destino comenzando en
d_first a partir de elementos en el rango de origen [first, last) como si se hiciera mediante
for (; first != last; ++d_first, (void) ++first)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(deref-move(*iter));
return d_first;
Si se lanza una excepción durante la inicialización, algunos objetos en
[first, last) quedan 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 según
policy. Esta sobrecarga participa en la resolución de sobrecarga solo si el valor de la siguiente expresión es
true:
|
|
(hasta C++20) |
|
|
(desde C++20) |
|
Si |
(desde C++20) |
Parámetros
| first, last | - | el par de iteradores que definen el rango de elementos a mover |
| d_first | - | el inicio del rango de destino |
| policy | - | la política de ejecución a utilizar |
| Requisitos de tipo | ||
-
InputIt
debe cumplir con los requisitos de
LegacyInputIterator
.
|
||
-
ForwardIt
debe cumplir con los requisitos de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
debe cumplir con los requisitos de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
puede lanzar excepciones.
|
||
Valor de retorno
Como se describió anteriormente.
Excepciones
2) Durante el proceso de ejecución:
- Si los recursos de memoria temporales necesarios para la paralelización no están disponibles, std::bad_alloc se lanza.
- Si se lanza una excepción no capturada mientras se accede a objetos a través de un argumento de algoritmo, el comportamiento está determinado por la política de ejecución (para políticas estándar, std::terminate se invoca).
Notas
Cuando el iterador de entrada desreferencia a un valor r, el comportamiento de std::uninitialized_move es el mismo que std::uninitialized_copy.
| Prueba de características macro | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr para especializados <memory> algoritmos, (1)
|
Implementación posible
template<class InputIt, class NoThrowForwardIt> constexpr NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first) { using ValueType = typename std::iterator_traits<NoThrowForwardIt>::value_type; auto current = d_first; try { for (; first != last; ++first, (void) ++current) { auto addr = static_cast<void*>(std::addressof(*current)); if constexpr (std::is_lvalue_reference_v<decltype(*first)>) ::new (addr) ValueType(std::move(*first)); else ::new (addr) ValueType(*first); } return current; } catch (...) { std::destroy(d_first, current); throw; } } |
Ejemplo
Ejecutar 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("initially, in: ", std::begin(in), std::end(in));
if (constexpr auto 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("after move, in: ", std::begin(in), std::end(in));
print("after move, out: ", first, last);
std::destroy(first, last);
}
catch (...)
{
std::cout << "Exception!\n";
}
std::free(out);
}
}
Posible salida:
initially, in: "Home" "Work!"
after move, in: "" ""
after move, out: "Home" "Work!"
Informes de defectos
Los siguientes informes de defectos que cambian el comportamiento se aplicaron retroactivamente a estándares C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 3918 | C++17 | la construcción por movimiento siempre se realiza incluso si el iterador de entrada desreferencia a un prvalue |
no se realiza construcción por movimiento en este caso |
Véase también
|
copia un rango de objetos a un área de memoria no inicializada
(plantilla de función) |
|
|
(C++17)
|
mueve una cantidad de objetos a un área de memoria no inicializada
(plantilla de función) |
|
(C++20)
|
mueve un rango de objetos a un área de memoria no inicializada
(objeto función de algoritmo) |