std::uninitialized_value_construct
De cppreference.com
| Definido en el archivo de encabezado <memory>
|
||
| template< class ForwardIt > void uninitialized_value_construct( ForwardIt first, ForwardIt last); |
(1) | (desde C++17) |
| template< class ExecutionPolicy, class ForwardIt > void uninitialized_value_construct( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last ); |
(2) | (desde C++17) |
1) Construye objetos de tipo typename iterator_traits<ForwardIt>::value_type en el almacenamiento no inicializado designado por el rango
[first, last) mediante la inicialización por valor, como si fuera por
for (; first != last; ++first) ::new (/*VOIDIFICAR*/(*first)) typename std::iterator_traits<ForwardIt>::value_type();
donde /*VOIDIFICAR*/(e) es:
|
(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. |
| 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.
| ||
[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> void uninitialized_value_construct(ForwardIt first, ForwardIt last) { using Value = 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)))) Value(); } } catch (...) { std::destroy(first, current); throw; } } |
[editar] Ejemplo
Ejecuta este código
#include <iostream> #include <memory> #include <string> int main() { struct S { std::string m{ "Valor por defecto" }; }; 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 << "¡Excepción!\n"; } // Observa que para "tipos triviales" 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:
Valor por defecto Valor por defecto Valor por defecto 1 2 3 4 0 0 0 0
[editar] Véase también
| Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un inicio y una cuenta. (niebloid) | |
| Construye objetos mediante la inicialización por defecto en un área de memoria sin inicializar, definido por un rango. (plantilla de función) | |
| Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un rango. (niebloid) |
