std::uninitialized_value_construct_n
De cppreference.com
Definido en el archivo de encabezado <memory> | ||
template<class ForwardIt, class Size > ForwardIt uninitialized_value_construct_n( ForwardIt first, Size n ); | (1) | (desde C++17) |
template<class ExecutionPolicy, class ForwardIt, class Size > ForwardIt uninitialized_value_construct_n( ExecutionPolicy&& policy, ForwardIt first, Size n ); | (2) | (desde C++17) |
1) Construye
n objetos de tipo typename iterator_traits<ForwardIt>::value_type en el almacenamiento no inicializado que comienza en first mediante la inicialización por valor, como si fuera por for(; n >0;(void)++first, --n)::new(/*VOIDIFICAR*/(*first))typenamestd::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 | - | El comienzo del rango de elementos a inicializar. |
| n | - | El número de 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
El fin del rango de objetos (es decir, std::next(first, n)).
[editar]Complejidad
Lineal en n.
[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 Size> ForwardIt uninitialized_value_construct_n( ForwardIt first, Size n ){using T =typenamestd::iterator_traits<ForwardIt>::value_type; ForwardIt current = first;try{for(; n >0;(void)++current, --n){::new(const_cast<void*>(static_cast<constvolatilevoid*>(std::addressof(*current)))) T();}return current;}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"};}; constexprint n {3}; alignas(alignof(S))unsignedchar 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<<"¡Excepción!\n";} // Observa que para "tipos triviales" uninitialized_value_construct_n// llena con ceros el área de memoria no inicializada dada.int v[]{1, 2, 3, 4};for(constint i : v){std::cout<< i <<' ';}std::cout<<'\n'; std::uninitialized_value_construct_n(std::begin(v), std::size(v));for(constint 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 rango. (niebloid) | |
| Construye objetos mediante la inicialización por defecto en un área de memoria sin inicializar, definido por un inicio y una cuenta. (plantilla de funció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) |
