std::uninitialized_value_construct_n
De es.cppreference.net
| Definido en el encabezado <memory>
|
||
template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_value_construct_n
( NoThrowForwardIt first, Size count );
|
(1) | (desde C++17) (constexpr desde C++26) |
template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_value_construct_n
( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );
|
(2) | (desde C++17) |
1) Construye elementos en el rango de destino
first + [0, count) mediante inicialización por valor como si por
for (; count > 0; (void)++first, --count)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type();
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 según
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 | - | el inicio del rango de elementos a inicializar |
| count | - | el número 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.
|
||
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 al acceder 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, se invoca std::terminate).
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> constexpr ForwardIt uninitialized_value_construct_n(NoThrowForwardIt first, Size count) { using T = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = first; try { for (; countn > 0; (void) ++current, --count) ::new (static_cast<void*>(std::addressof(*current))) T(); return current; } 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 = std::uninitialized_value_construct_n(first, n); 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_n // inicializa a cero 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_n(std::begin(v), std::size(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 rango
(function template) |
|
construye objetos mediante
default-initialization
en un área de memoria no inicializada, definida por un inicio y un contador
(function template) |
|
|
construye objetos mediante
value-initialization
en un área de memoria no inicializada, definida por un inicio y un contador
(algorithm function object) |