std::uninitialized_fill
De cppreference.com
| Definido en el archivo de encabezado <memory>
|
||
| template< class ForwardIt, class T > void uninitialized_fill( ForwardIt first, ForwardIt last, const T& value ); |
(1) | |
| template< class ExecutionPolicy, class ForwardIt, class T > void uninitialized_fill( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value ); |
(2) | (desde C++17) |
1) Copia el valor dado
value a un área de memoria no inicializada, definida por el rango [first, last) como si fuera por
for (; first != last; ++first) ::new (/*VOIDIFICAR*/(*first)) typename std::iterator_traits<ForwardIt>::value_type(value);
donde /*VOIDIFICAR*/(e) es:
|
(hasta C++11) |
|
(desde C++11) (hasta C++20) |
|
(desde C++20) |
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 no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.Contenido |
[editar] Parámetros
| first, last | - | El rango de los elementos a inicializar. |
| value | - | El valor con el que construir los elementos. |
| policy | - | La política de ejecución a usar. Véase política de ejecución para más detalles. |
| Requisitos de tipo | ||
-ForwardIt debe satisfacer los requisitos de ForwardIterator.
| ||
-Ningún incremento, asignación, comparación o direccionamiento indirecto a través de instancias válidas de ForwardIt puede lanzar excepciones. Aplicar &* a un valor ForwardIt debe generar un puntero a su tipo valor. (hasta C++11)
| ||
[editar] Valor de retorno
(Ninguno)
[editar] Complejidad
Lineal en la distancia entre first y last.
[editar] Excepciones
La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:
- Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
- Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.
[editar] Posible implementación
template<class ForwardIt, class T> void uninitialized_fill(ForwardIt first, ForwardIt last, const T& value) { using V = typename std::iterator_traits<ForwardIt>::value_type; ForwardIt current = first; try { for (; current != last; ++current) { ::new (const_cast<void*>(static_cast<const volatile void*>( std::addressof(*current)))) V(value); } } catch (...) { for (; first != current; ++first) { first->~V(); } throw; } } |
[editar] Ejemplo
Ejecuta 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(p, p+sz, "Ejemplo"); for (std::string* i = p; i != p+sz; ++i) { std::cout << *i << '\n'; i->~basic_string<char>(); } std::return_temporary_buffer(p); }
Salida:
Ejemplo Ejemplo Ejemplo Ejemplo
[editar] Véase también
| Copia un objeto a una zona de memoria sin inicializar, definido por un inicio y una cuenta. (plantilla de función) | |
| (C++20) |
Copia un objeto en un área de memoria sin inicializar, definido por un rango. (niebloid) |
