std::uninitialized_value_construct
De es.cppreference.net
| Definido en el encabezado <memory>
|
||
template< class NoThrowForwardIt >
void uninitialized_value_construct( NoThrowForwardIt first,
NoThrowForwardIt last );
|
(1) | (desde C++17) (constexpr desde C++26) |
template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_value_construct( ExecutionPolicy&& policy,
NoThrowForwardIt first,
NoThrowForwardIt last );
|
(2) | (desde C++17) |
1) Construye elementos en el rango de destino
[first, last) mediante inicialización por valor como si por
for (; first != last; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type();
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 según
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, last | - | el par de iteradores que define el rango de elementos a inicializar |
| policy | - | la política de ejecución a utilizar |
| Requisitos de tipo | ||
-
NoThrowForwardIt
debe cumplir con los requisitos de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
puede lanzar excepciones.
|
||
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> constexpr void uninitialized_value_construct(NoThrowForwardIt first, NoThrowForwardIt last) { using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = first; try { for (; current != last; ++current) { ::new (static_cast<void*>(std::addressof(*current))) Value(); } } catch (...) { std::destroy(first, current); throw; } } |
Ejemplo
Ejecutar este código
#include <iostream> #include <memory> #include <string> int main() { struct S { std::string m{"Default value"}; }; constexpr int n{3}; alignas(alignof(S)) unsigned char mem[n * sizeof(S)]; try { auto first{reinterpret_cast<S*>(mem)}; auto last{first + n}; std::uninitialized_value_construct(first, last); for (auto it{first}; it != last; ++it) std::cout << it->m << '\n'; std::destroy(first, last); } catch (...) { std::cout << "Exception!\n"; } // Para tipos escalares, uninitialized_value_construct // llena con ceros el área de memoria no inicializada dada. int v[]{1, 2, 3, 4}; for (const int i : v) std::cout << i << ' '; std::cout << '\n'; std::uninitialized_value_construct(std::begin(v), std::end(v)); for (const int i : v) std::cout << i << ' '; std::cout << '\n'; }
Salida:
Default value Default value Default value 1 2 3 4 0 0 0 0
Véase también
|
(C++17)
|
construye objetos mediante
value-initialization
en un área de memoria no inicializada, definida por un inicio y un contador
(plantilla de función) |
|
(C++17)
|
construye objetos mediante
default-initialization
en un área de memoria no inicializada, definida por un rango
(plantilla de función) |
|
construye objetos mediante
value-initialization
en un área de memoria no inicializada, definida por un rango
(objeto función de algoritmo) |