std::ranges::uninitialized_value_construct_n

template< /*nothrow-forward-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_value_construct_n( I first,
                                   std::iter_difference_t<I> count );

template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_value_construct_n( Ep&& policy, I first,
                                   std::iter_difference_t<I> count );

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

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

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a ninguna de ellas.
• Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
• Cuando alguna de ellas se encuentra mediante búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumentos se inhibe.

Parámetros

Valor de retorno

Como se describió anteriormente.

Excepciones

Cualquier excepción lanzada durante la construcción de los elementos en el rango de destino.

Notas

Una implementación puede mejorar la eficiencia de ranges::uninitialized_value_construct_n (usando por ejemplo ranges::fill_n) si el tipo de valor del rango es un CopyAssignable TrivialType.

Posible implementación

struct uninitialized_value_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_value_construct(iter, std::default_sentinel).base();
    }
};

inline constexpr uninitialized_value_construct_n_fn uninitialized_value_construct_n{};

Ejemplo

#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_value_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";
    }
    // Para tipos escalares, uninitialized_value_construct_n
    // inicializa a cero el área de memoria no inicializada dada.
    int v[]{1, 2, 3, 4, 5, 6, 7, 8};
    std::cout << ' ';
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << "\n ";
    std::ranges::uninitialized_value_construct_n(std::begin(v), std::size(v));
    for (const int i : v)
        std::cout << i << ' ';
    std::cout << '\n';
}

1 █▓▒░ █▓▒░ █▓▒░ 
2 █▓▒░ █▓▒░ █▓▒░ 
3 █▓▒░ █▓▒░ █▓▒░ 
4 █▓▒░ █▓▒░ █▓▒░
1 2 3 4 5 6 7 8
0 0 0 0 0 0 0 0

Véase también