Namespaces
Variants

std::ranges:: uninitialized_fill

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definido en el encabezado <memory>
Firma de llamada
template < no-throw-forward-iterator I, no - throw - sentinel - for < I > S,

class T >
requires std:: constructible_from < std:: iter_value_t < I > , const T & >

I uninitialized_fill ( I first, S last, const T & value ) ;
(1) (desde C++20)
(constexpr desde C++26)
template < no-throw-forward-range R, class T >

requires std:: constructible_from < ranges:: range_value_t < R > ,
const T & >
ranges:: borrowed_iterator_t < R > uninitialized_fill ( R && r,

const T & value ) ;
(2) (desde C++20)
(constexpr desde C++26)
1) Copia value a un área de memoria no inicializada [ first , last ) como si fuera mediante

for ( ; first ! = last ; ++ first )
:: new ( voidify ( * first ) ) std:: remove_reference_t < std:: iter_reference_t < I >> ( value ) ;
return first ;

Si se lanza una excepción durante la inicialización, los objetos ya construidos se destruyen en un orden no especificado.
2) Equivalente a return ranges :: uninitialized_fill ( ranges:: begin ( r ) , ranges:: end ( r ) , value ) ; .

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

Contenidos

Parámetros

first, last - el par iterador-centinela que define el rango de elementos a inicializar
r - el range de los elementos a inicializar
value - el valor con el que construir los elementos

Valor de retorno

Como se describió anteriormente.

Complejidad

Lineal en el tamaño del área de memoria no inicializada.

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

Macro de prueba de características Valor Estándar Característica
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr para algoritmos de memoria especializados , ( 1,2 )

Implementación posible 

struct uninitialized_fill_fn
{
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S, class T>
        requires std::constructible_from<std::iter_value_t<I>, const T&>
    constexpr I operator()(I first, S last, const T& value) const
    {
        I rollback{first};
        try
        {
            for (; !(first == last); ++first)
                ranges::construct_at(std::addressof(*first), value);
            return first;
        }
        catch (...)
        {   
            // retroceso: destruir elementos construidos
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
    template<no-throw-forward-range R, class T>
        requires std::constructible_from<ranges::range_value_t<R>, const T&>
    constexpr ranges::borrowed_iterator_t<R> operator()(R&& r, const T& value) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), value);
    }
};
inline constexpr uninitialized_fill_fn uninitialized_fill{};

Ejemplo

Ejecutar este código 
#include <iostream>
#include <memory>
#include <string>
int main()
{
    constexpr int n{4};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last{first + n};
        std::ranges::uninitialized_fill(first, last, "▄▀▄▀▄▀▄▀");
        int count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << *it << '\n';
        std::ranges::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
}

Salida: 

1 ▄▀▄▀▄▀▄▀
2 ▄▀▄▀▄▀▄▀
3 ▄▀▄▀▄▀▄▀
4 ▄▀▄▀▄▀▄▀

Informes de defectos

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

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3870 C++20 este algoritmo podría crear objetos en un almacenamiento const se mantiene no permitido

Véase también

(C++20)
copia un objeto a un área de memoria no inicializada, definida por un inicio y un conteo
(objeto función de algoritmo)
copia un objeto a un área de memoria no inicializada, definida por un rango
(plantilla de función)