std::ranges::uninitialized_fill_n

template< /*nothrow-forward-iterator*/ I, class T >
    requires std::constructible_from<std::iter_value_t<I>, const T&>
I uninitialized_fill_n( I first, std::iter_difference_t<I> count,
                        const T& value );

template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I,
          class T = std::iter_value_t<I> >
    requires std::constructible_from<std::iter_value_t<I>, const T&>
I uninitialized_fill_n( Ep&& exec, I first, std::iter_difference_t<I> count,
                        const T& value );

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

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

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a ninguno de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumentos.
• Cuando alguno de ellos se encuentra mediante búsqueda no calificada normal 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 la ranges::uninitialized_fill_n (usando, por ejemplo, ranges::fill_n) si el tipo de valor del rango de salida es TrivialType.

Posible implementación

struct uninitialized_fill_n_fn
{
    template</*nothrow-forward-range*/ I, class T>
        requires std::constructible_from<std::iter_value_t<I>, const T&>
    constexpr I operator()(I first, std::iter_difference_t<I> count,
                           const T& value) const
    {
        I rollback{first};
        try
        {
            for (; count-- > 0; ++first)
                ranges::construct_at(std::addressof(*first), value);
            return first;
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
};

inline constexpr uninitialized_fill_n_fn uninitialized_fill_n{};

Ejemplo

#include <iostream>
#include <memory>
#include <string>
int main()
{
    constexpr int n{3};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last = std::ranges::uninitialized_fill_n(first, n, "cppreference");
        for (auto it{first}; it != last; ++it)
            std::cout << *it << '\n';
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
}

cppreference
cppreference
cppreference

Véase también