Namespaces
Variants

std:: uninitialized_fill_n

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 Size, class T >

NoThrowForwardIt uninitialized_fill_n ( NoThrowForwardIt first,

Size count, const T & value ) ;
(1) (constexpr desde C++26)
template < class ExecutionPolicy,

class NoThrowForwardIt, class Size, class T >
NoThrowForwardIt uninitialized_fill_n ( ExecutionPolicy && policy,
NoThrowForwardIt first,

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

for ( ; count -- ; ++ first )
:: new ( voidify ( * first ) )
typename std:: iterator_traits < NoThrowForwardIt > :: value_type ( 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) 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 - inicio del rango de elementos a inicializar
count - número de elementos a construir
value - valor con el que construir los elementos
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. (until C++11)

Valor de retorno

Como se describió anteriormente.

Complejidad

Lineal en count .

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 no puede asignar memoria, std::bad_alloc es lanzada.

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 Size, class T>
constexpr NoThrowForwardIt uninitialized_fill_n(NoThrowForwardIt first,
                                                Size count, const T& value)
{
    using V = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; count > 0; ++current, (void) --count)
            ::new (static_cast<void*>(std::addressof(*current))) V(value);
        return current;
    }
    catch (...)
    {
        for (; first != current; ++first)
            first->~V();
        throw;
    }
    return current;
}

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
int main()
{
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer<std::string>(4);
    std::uninitialized_fill_n(p, sz, "Example");
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    std::return_temporary_buffer(p);
}

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 Aplicado 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 estar mal formado 		utiliza new de colocación global en su lugar
LWG 1339 C++98 no se devolvía la ubicación del primer elemento siguiente
al rango de llenado 		devuelto
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 rango
(plantilla de función)
(C++20)
copia un objeto a un área de memoria no inicializada, definida por un inicio y un contador
(objeto función de algoritmo)