std::ranges::uninitialized_move_n, std::ranges::uninitialized_move_n_result
Desde es.cppreference.net
| Definido en el encabezado <memory>
|
||
| Firma de llamada |
||
template< std::input_iterator I,
/*nothrow-forward-iterator*/ O, /*nothrow-sentinel-for*/<O> S >
requires std::constructible_from<std::iter_value_t<O>,
std::iter_rvalue_reference_t<I>>
uninitialized_move_n_result<I, O>
uninitialized_move_n( I ifirst, std::iter_difference_t<I> count,
O ofirst, S olast );
|
(1) | (desde C++20) (constexpr desde C++26) |
template< /*execution-policy*/ Ep, std::random_access_iterator I,
/*nothrow-random-access-iterator*/ O,
/*nothrow-sized-sentinel-for*/<O> S >
requires std::constructible_from<std::iter_value_t<O>,
std::iter_rvalue_reference_t<I>>
uninitialized_move_n_result<I, O>
uninitialized_move_n( Ep&& policy, I ifirst,
std::iter_difference_t<I> count,
O ofirst, S olast );
|
(2) | (desde C++26) |
| Tipos auxiliares |
||
template< class I, class O >
using uninitialized_move_n_result = ranges::in_out_result<I, O>;
|
(3) | (desde C++20) |
Para la definición de /*execution-policy*/, consulte esta página; para la definición de otros conceptos solo de exposición, consulte esta página.
1) Construye elementos en el rango destino
[ofirst, olast) a partir de elementos en el rango fuente ifirst + [0, count) como si mediante
auto ret = ranges::uninitialized_move(std::counted_iterator(std::move(ifirst), count),
std::default_sentinel, ofirst, olast);
return {std::move(ret.in).base(), ret.out};
Si se lanza una excepción durante la inicialización, los objetos ya construidos en
[ofirst, olast) se destruyen en un orden no especificado. Además, los objetos en el rango de entrada que comienzan en ifirst, que ya fueron movidos, quedan en un estado válido pero no especificado. Si
[ofirst, olast) se superpone con ifirst + [0, count), el comportamiento no está definido.2) Igual que (1), pero ejecutado de acuerdo con
policy.Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (conocidos informalmente como niebloids), es decir:
- No se pueden especificar listas de argumentos de plantilla explícitas al llamar a ninguna de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante búsqueda no calificada normal como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
Parámetros
| ifirst | - | el comienzo del rango de entrada de elementos desde los cuales mover |
| ofirst, olast | - | el par iterador-centinela que define el rango de salida de elementos a inicializar |
| count | - | el número de elementos a mover |
| policy | - | la política de ejecución a usar |
Valor de retorno
Como se describió anteriormente.
Excepciones
Cualquier excepción lanzada durante la construcción de los elementos en el rango de destino.
2) Durante el proceso de ejecución:
- Si los recursos temporales de memoria requeridos 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
Una implementación puede mejorar la eficiencia de la ranges::uninitialized_move_n (usando, por ejemplo, ranges::copy_n) si el tipo de valor del rango de salida es TrivialType.
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_parallel_algorithm |
202506L |
(C++26) | Algoritmos de rango paralelo |
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr para especializados <memory> algoritmos, (1)
|
Posible implementación
struct uninitialized_move_n_fn
{
template<std::input_iterator I,
/*nothrow-forward-iterator*/ O, /*nothrow-sentinel-for*/<O> S>
requires std::constructible_from<std::iter_value_t<O>,
std::iter_rvalue_reference_t<I>>
constexpr ranges::uninitialized_move_n_result<I, O>
operator()(I ifirst, std::iter_difference_t<I> count, O ofirst, S olast) const
{
auto iter = std::counted_iterator(std::move(ifirst), count);
auto ret = ranges::uninitialized_move(iter, std::default_sentinel, ofirst, olast);
return {std::move(ret.in).base(), ret.out};
}
};
inline constexpr uninitialized_move_n_fn uninitialized_move_n{};
|
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[]{ "No", "Diagnostic", "Required", };
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::ranges::uninitialized_move_n(std::begin(in), sz, first, last);
print("after move, in: ", std::begin(in), std::end(in));
print("after move, out: ", first, last);
std::ranges::destroy(first, last);
}
catch (...)
{
std::cout << "Exception!\n";
}
std::free(out);
}
}
Posible salida:
initially, in: "No" "Diagnostic" "Required"
after move, in: "" "" ""
after move, out: "No" "Diagnostic" "Required"
Véase también
(C++20) |
mueve un rango de objetos a un área de memoria no inicializada (objeto función de algoritmo) |
(C++17) |
mueve un número de objetos a un área de memoria no inicializada (plantilla de función) |