std::uninitialized_fill_n
De es.cppreference.net
| 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) Construye los primeros
count elementos en el rango de destino que comienza en first con el valor dado value como si se hiciera
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 se ejecuta de acuerdo con
policy. Esta sobrecarga participa en la resolución de sobrecargas solo si el valor de la siguiente expresión es
true:
|
|
(hasta C++20) |
|
|
(desde C++20) |
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
.
|
||
-
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.
Excepciones
2) Durante el proceso de ejecución:
- Si los recursos de memoria temporales necesarios para la paralelización no están disponibles, std::bad_alloc se lanza.
- Si se lanza una excepción no capturada mientras se accede a objetos a través de 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 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 cambian el comportamiento se aplicaron retroactivamente a estándares 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 existe T::operator new, el programa podría estar mal formado
|
usa la colocación global new en su lugar
|
| LWG 1339 | C++98 | la ubicación del primer elemento después de el rango de llenado no se devolvía |
se devolvía |
| 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 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) |