Namespaces
Variants

std:: uninitialized_default_construct_n

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
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 objetos de tipo typename std:: iterator_traits < NoThrowForwardIt > :: value_type en el área de memoria no inicializada first + [ ​ 0 ​ , count ) mediante inicialización por defecto , como si fuera

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 con la policy .
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(hasta C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(desde C++20)

Contenidos

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.

Complejidad

Lineal en n .

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy reporta errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es una de las políticas estándar , std::terminate es llamado. Para cualquier otra ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr para algoritmos de memoria especializados , ( 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

Ejecutar este código 
#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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3870 C++20 este algoritmo podría crear objetos en un almacenamiento const se mantiene no permitido

Véase también

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