std::uninitialized_copy_n

Definido en el encabezado `<memory>`
template< class InputIt, class Size, class NoThrowForwardIt > NoThrowForwardIt uninitialized_copy_n( InputIt first, Size count, NoThrowForwardIt d_first );	(1)	(desde C++11) (constexpr desde C++26)
template< class ExecutionPolicy, class ForwardIt, class Size, class NoThrowForwardIt > NoThrowForwardIt uninitialized_copy_n( ExecutionPolicy&& policy, ForwardIt first, Size count, NoThrowForwardIt d_first );	(2)	(desde C++17)

1) Construye elementos en el rango de destino comenzando en d_first a partir de los primeros count elementos en el rango de origen comenzando en first como si fuera mediante

for (; count > 0; ++d_first, (void) ++first, --count)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(*first);
return d_first;

Si se lanza una excepción durante la inicialización, los objetos ya construidos se destruyen en un orden no especificado.

2) Igual que (1), pero ejecutado de acuerdo a policy.

Esta sobrecarga participa en la resolución de sobrecarga solo si el valor de la siguiente expresión es true:

`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)

Si d_first + [0, count) se superpone con first + [0, count), el comportamiento no está definido.

(desde C++20)

Parámetros

first	-	el inicio del rango de los elementos a copiar
count	-	el número de elementos a copiar
d_first	-	el inicio del rango destino
policy	-	la política de ejecución a usar
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.
- Ningún incremento, asignación, comparación o indirección a través de instancias válidas de `NoThrowForwardIt` puede lanzar excepciones.

Valor de retorno

Como se describe arriba.

Excepciones

2) Durante el proceso de ejecución:

Si los recursos de memoria temporal necesarios para la paralelización no están disponibles, std::bad_alloc se lanza.
Si se lanza una excepción no capturada al acceder 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

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 Size, class NoThrowForwardIt>
constexpr NoThrowForwardIt uninitialized_copy_n(InputIt first, Size count,
                                                NoThrowForwardIt d_first)
{
    using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; count > 0; ++first, (void) ++current, --count)
            ::new (static_cast<void*>(std::addressof(*current))) T(*first);
    }
    catch (...)
    {
        for (; d_first != current; ++d_first)
            d_first->~T();
        throw;
    }
    return current;
}

Ejemplo

Ejecutar este código

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::string> v = {"This", "is", "an", "example"};
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size());
    sz = std::min(sz, v.size());
    std::uninitialized_copy_n(v.begin(), sz, p);
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << ' ';
        i->~basic_string<char>();
    }
    std::cout << '\n';
    std::return_temporary_buffer(p);
}

Salida posible:

This is an example

Reportes de defectos

Los siguientes reportes de defectos que cambian el comportamiento se aplicaron retroactivamente a estándares C++ previamente publicados.

DR	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2133	C++98	la descripción del efecto usaba un `for` bucle con la iteración expresión `++d_first, ++first, --count`, lo cual resulta en búsquedas dependientes de argumentos de `operator,`	descarta el valor de un operando para deshabilitar esas ADLs
LWG 2433	C++11	este algoritmo podría ser secuestrado por sobrecargado `operator&`	utiliza std::addressof

Véase también

uninitialized_copy	copia un rango de objetos a un área de memoria no inicializada (plantilla de función)
ranges::uninitialized_copy_n (C++20)	copia un número de objetos a un área de memoria no inicializada (objeto función de algoritmo)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca de numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca de sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

es.cppreference.net

Namespaces

Variants