Namespaces
Variants

std::ranges::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 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)

Ordenación y operaciones relacionadas
Operaciones de particionamiento
(C++11)    

Operaciones de ordenamiento
Operaciones de búsqueda binaria
(en rangos particionados)
Operaciones de conjuntos (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 el encabezado <memory>
Firma de llamada
template< /*nothrow-forward-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct_n( I first,
                                     std::iter_difference_t<I> count );
(1) (desde C++20)
(constexpr desde C++26)
template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct_n( Ep&& policy, I first,
                                     std::iter_difference_t<I> count );
(2) (desde C++26)

Para la definición de /*execution-policy*/, véase esta página; para la definición de otros conceptos de solo exposición, véase esta página.

1) Construye elementos en el rango de destino first + [0count) mediante inicialización por defecto como si:

return ranges::uninitialized_default_construct(std::counted_iterator(first, count),
                                               std::default_sentinel).base();

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.

Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (informalmente conocidos como niebloids), es decir:

Parámetros

first - el inicio del rango de elementos a inicializar
count - el número de elementos a construir
policy - la execution policy 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 de memoria temporales 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 del 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 omitir la construcción del objeto (sin cambiar el efecto observable) si no se llama a un constructor predeterminado no trivial mientras se inicializa por defecto un objeto std::iter_value_t<I>, lo cual puede detectarse mediante std::is_trivially_default_constructible.

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 algoritmos <memory> especializados, (1)

Posible implementación

struct uninitialized_default_construct_n_fn
{
    template</*nothrow-forward-iterator*/ I>
        requires std::default_initializable<std::iter_value_t<I>>
    constexpr I operator()(I first, std::iter_difference_t<I> count) const
    {
        auto iter = std::counted_iterator(first, count);
        return ranges::uninitialized_default_construct(iter, std::default_sentinel).base();
    }
};

inline constexpr uninitialized_default_construct_n_fn uninitialized_default_construct_n{};

Ejemplo

#include <cstring>
#include <iostream>
#include <memory>
#include <string>

int main()
{
    struct S { std::string m{"█▓▒░ █▓▒░ "}; };
    
    constexpr int n{4};
    alignas(alignof(S)) char out[n * sizeof(S)];
    
    try
    {
        auto first{reinterpret_cast<S*>(out)};
        auto last = std::ranges::uninitialized_default_construct_n(first, n);
        
        auto count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << it->m << '\n';
        
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    
    // For scalar types, uninitialized_default_construct_n
    // generally does not zero-fill the given uninitialized memory area.
    constexpr int sample[]{1, 2, 3, 4, 5, 6};
    int v[]{1, 2, 3, 4, 5, 6};
    std::ranges::uninitialized_default_construct_n(std::begin(v), std::size(v));
    if (std::memcmp(v, sample, sizeof(v)) == 0)
    {
        // Maybe undefined behavior, pending CWG 1997:
        // for (const int i : v) { std::cout << i << ' '; }
        for (const int i : sample)
            std::cout << i << ' ';
    }
    else
        std::cout << "Unspecified!";
    std::cout << '\n';
}

Posible salida:

1 █▓▒░ █▓▒░
2 █▓▒░ █▓▒░
3 █▓▒░ █▓▒░
4 █▓▒░ █▓▒░
1 2 3 4 5 6

Véase también

construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un rango
(objeto función de algoritmo)
construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un rango
(objeto función de algoritmo)
construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un inicio y un recuento
(objeto función de algoritmo)
construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un inicio y un recuento
(plantilla de función)