std::uninitialized_fill
De es.cppreference.net
| 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) Construye elementos en el rango de destino
[first, last) con el valor dado value como si se hiciera 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
policy. Esta sobrecarga participa en la resolución de sobrecarga solo si el valor de la siguiente expresión es
true:
|
|
(hasta C++20) |
|
|
(desde C++20) |
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
.
|
||
-
NoThrowForwardIt
puede lanzar excepciones.
Aplicar
&
*
a un valor de
NoThrowForwardIt
debe producir un puntero a su tipo de valor.
(hasta C++11)
|
||
Excepciones
2) Durante el proceso de ejecución:
- Si los recursos de memoria temporal necesarios para la paralelización no están disponibles, std::bad_alloc se lanza.
- Si se lanza una excepción no capturada al acceder a objetos mediante un argumento de algoritmo, el comportamiento está determinado por la política de ejecución (para políticas estándar, std::terminate se invoca).
Notas
| Prueba de características macro | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr para especializados <memory> algoritmos, (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 cambian el comportamiento se aplicaron retroactivamente a estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento según lo 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
|
usa colocación global new en su lugar
|
| LWG 2433 | C++11 | este algoritmo podría ser secuestrado por una sobrecarga de operator&
|
usa std::addressof |
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) |