Namespaces
Variants

std::uninitialized_default_construct

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 secuencia modificadoras
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 partición
(C++11)    

Operaciones de ordenamiento
Operaciones de búsqueda binaria
(sobre rangos particionados)
Operaciones de conjunto (sobre rangos ordenados)
Operaciones de fusión (sobre 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 la cabecera <memory>
template< class NoThrowForwardIt >
void uninitialized_default_construct( NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(1) (desde C++17)
(constexpr desde C++26)
template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_default_construct( ExecutionPolicy&& policy,
                                      NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(2) (desde C++17)
1) Construye elementos en el rango de destino [first, last) mediante inicialización por defecto como si fuera por

for (; first != last; ++first)
    ::new (voidify(*first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type;

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 según 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)

Parámetros

first, last - el par de iteradores que define el rango de elementos a inicializar
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.

Excepciones

2) Durante el proceso de ejecución:
  • Si los recursos de memoria temporales necesarios para la paralelización no están disponibles, se lanza std::bad_alloc.
  • 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, 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>
constexpr void uninitialized_default_construct(NoThrowForwardIt first,
                                               NoThrowForwardIt last)
{
    using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; current != last; ++current)
        {
            ::new (static_cast<void*>(std::addressof(*current))) Value;
        }
    }
    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{first + n};
        std::uninitialized_default_construct(first, last);
        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
    // generalmente no rellena con ceros el área de memoria no inicializada dada.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct(std::begin(v), std::end(v));
    // Comportamiento posiblemente indefinido, pendiente de resolución de CWG 1997.
    // for (const int i : v)
    //     std::cout << i << ' ';
    // El resultado no está especificado.
    std::cout <<
        (std::memcmp(v, original, sizeof(v)) == 0 ? "Unmodified\n" : "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 inicio y un contador
(plantilla de función)
construye objetos mediante value-initialization en un área de memoria no inicializada, definida por un rango
(plantilla de función)
construye objetos mediante default-initialization en un área de memoria no inicializada, definida por un rango
(objeto función algoritmo)