Namespaces
Variants

std:: 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>
template < class NoThrowForwardIt, class T >

void uninitialized_fill ( NoThrowForwardIt first,

NoThrowForwardIt last, const T & value ) ;
(1) (constexpr desde C++26)
template < class ExecutionPolicy, class NoThrowForwardIt, class T >

void uninitialized_fill ( ExecutionPolicy && policy,
NoThrowForwardIt first,

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

for ( ; first ! = last ; ++ first )
:: new ( voidify ( * first ) )
typename std:: iterator_traits < NoThrowForwardIt > :: value_type ( value ) ;

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 de acuerdo con la policy .
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(hasta C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(desde C++20)

Contenidos

Parámetros

first, last - el par de iteradores que define el rango de elementos a inicializar
value - el valor con el que construir los elementos
policy - la política de ejecución a utilizar
Requisitos de tipo
-
NoThrowForwardIt debe cumplir con los requisitos de LegacyForwardIterator .
-
Ningún incremento, asignación, comparación o indirección a través de instancias válidas de NoThrowForwardIt puede lanzar excepciones. Aplicar & * a un valor de NoThrowForwardIt debe producir un puntero a su tipo de valor. (hasta C++11)

Complejidad

Lineal en la distancia entre first y last .

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy reporta errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es una de las políticas estándar , std::terminate es llamado. Para cualquier otra ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Notas

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 )

Implementación posible 

template<class NoThrowForwardIt, class T>
constexpr void uninitialized_fill(NoThrowForwardIt first, NoThrowForwardIt last,
                                  const T& value)
{
    using V = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; current != last; ++current)
            ::new (static_cast<void*>(std::addressof(*current))) V(value);
    } 
    catch (...)
    {
        for (; first != current; ++first)
            first->~V();
        throw;
    }
}

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
int main()
{
    const std::size_t sz = 4;
    std::allocator<std::string> alloc;
    std::string* p = alloc.allocate(sz);
    std::uninitialized_fill(p, p + sz, "Example");
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    alloc.deallocate(p, sz);
}

Salida: 

Example
Example
Example
Example

Informes de defectos

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

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 866 C++98 dado T como el tipo de valor de NoThrowForwardIt , si
T :: operator new existe, el programa podría ser incorrecto 		utiliza new de colocación global en su lugar
LWG 2433 C++11 este algoritmo podría ser secuestrado por operator & sobrecargado utiliza std::addressof
LWG 3870 C++20 este algoritmo podría crear objetos en un almacenamiento const se mantiene no permitido

Véase también

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