std::ranges:: uninitialized_fill_n

Copia value a un área de memoria no inicializada first + [ ​ 0 ​ , count ) como si fuera mediante return ranges:: uninitialized_fill ( std:: counted_iterator ( first, count ) ,
std:: default_sentinel , value ) . base ( ) ;

Si se lanza una excepción durante la inicialización, los objetos ya construidos se destruyen en un orden no especificado.

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumento .
• Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada de función, la búsqueda dependiente de argumento queda inhibida.

Parámetros

Valor de retorno

Como se describió anteriormente.

Complejidad

Lineal en count .

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_fill_n , por ejemplo utilizando ranges::fill_n , si el tipo de valor del rango de salida es TrivialType .

Implementación posible

struct uninitialized_fill_n_fn
{
    template<no-throw-forward-range I, class T>
    requires std::constructible_from<std::iter_value_t<I>, const T&>
    I operator()(I first, std::iter_difference_t<I> n, const T& x) const
    {
        I rollback{first};
        try
        {
            for (; n-- > 0; ++first)
                ranges::construct_at(std::addressof(*first), x);
            return first;
        }
        catch (...) // retroceso: destruir elementos construidos
        {
            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

Informes de defectos

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

Véase también