Namespaces
Variants

std::uninitialized_default_construct_n

De es.cppreference.net
 
 
Biblioteca de algoritmos
Algoritmos restringidos y algoritmos sobre rangos (C++20)
Algoritmos restringidos, p.ej. ranges::copy, ranges::sort, ...
Operaciones de secuencia no modificadoras    
Operaciones por lotes
(C++17)
Operaciones de búsqueda
Operaciones de modificación de secuencia
Operaciones de copia
(C++11)
(C++11)
Operaciones de intercambio
Operaciones de transformación
Operaciones de generación
Operaciones de eliminación
Operaciones de cambio de orden
(hasta C++17)(C++11)
(C++20)(C++20)
Operaciones de muestreo
(C++17)

Ordenamiento y operaciones relacionadas
Operaciones de particionamiento
(C++11)    

Operaciones de ordenamiento
Operaciones de búsqueda binaria
(en rangos particionados)
Operaciones de conjunto (en rangos ordenados)
Operaciones de fusión (en rangos ordenados)
Operaciones de montículo
Operaciones de mínimo/máximo
(C++11)
(C++17)
Operaciones de comparación lexicográfica
Operaciones de permutación


 
 
Definido en el encabezado <memory>
template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
    ( NoThrowForwardIt first, Size count );
(1) (desde C++17)
(constexpr desde C++26)
template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
    ( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );
(2) (desde C++17)
1) Construye elementos en el rango de destino first + [0, count) mediante inicialización por defecto como si

for (; count > 0; (void)++first, --count)
    ::new (voidify(*first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type;
return 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 sobrecargas 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)

Parámetros

first - el inicio del rango de elementos a inicializar
count - el número de elementos a construir
policy - la política de ejecución a utilizar
Requisitos de tipo
-
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 describió anteriormente.

Excepciones

2) Durante el proceso de ejecución:
  • Si los recursos de memoria temporal necesarios para la paralelización no están disponibles, se lanza std::bad_alloc.
  • 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, se invoca std::terminate).

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

Ejemplo

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
struct S
{
    std::string m{"default value"};
};
int main()
{
    constexpr int n{3};
    alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(mem)};
        auto last = std::uninitialized_default_construct_n(first, n);
        for (auto it{first}; it != last; ++it)
            std::cout << it->m << '\n';
        std::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
    // Para tipos escalares, uninitialized_default_construct_n
    // generalmente no inicializa a cero el área de memoria no inicializada dada.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct_n(std::begin(v), std::size(v));
    // Un intento de acceder a v podría ser un comportamiento indefinido,
    // pendiente de que se resuelva CWG 1997:
    // for (const int i : v)
    //     std::cout << i << ' ';
    // El resultado no está especificado:
    std::cout << (std::memcmp(v, original, sizeof(v)) == 0 ? "un" : "") << "modified\n";
}

Salida posible:

default value
default value
default value
unmodified

Véase también

construye objetos mediante default-initialization en un área de memoria no inicializada, definida por un rango
(plantilla de función)
construye objetos mediante value-initialization en un área de memoria no inicializada, definida por un inicio y un contador
(plantilla de función)
construye objetos mediante default-initialization en un área de memoria no inicializada, definida por un inicio y contador
(objeto función algoritmo)