std::uninitialized_default_construct_n
De es.cppreference.net
| Definido en el encabezado <memory>
|
||
template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
( NoThrowForwardIt first, Size count );
|
(1) | (desde C++17) (constexpr desde C++26) |
template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_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 defecto como si
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 de acuerdo a
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 | - | el inicio del rango de elementos a inicializar |
| count | - | el número de elementos a construir |
| 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 temporal necesarios para la paralelización no están disponibles, se lanza std::bad_alloc.
- 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_default_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 <cstring> #include <iostream> #include <memory> #include <string> struct S { std::string m{"default value"}; }; int main() { constexpr int n{3}; alignas(alignof(S)) unsigned char mem[n * sizeof(S)]; try { auto first{reinterpret_cast<S*>(mem)}; auto last = std::uninitialized_default_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_default_construct_n // generalmente no inicializa a cero el área de memoria no inicializada dada. int v[]{1, 2, 3, 4}; const int original[]{1, 2, 3, 4}; std::uninitialized_default_construct_n(std::begin(v), std::size(v)); // Un intento de acceder a v podría ser un comportamiento indefinido, // pendiente de que se resuelva CWG 1997: // for (const int i : v) // std::cout << i << ' '; // El resultado no está especificado: std::cout << (std::memcmp(v, original, sizeof(v)) == 0 ? "un" : "") << "modified\n"; }
Salida posible:
default value default value default value unmodified
Véase también
|
(C++17)
|
construye objetos mediante
default-initialization
en un área de memoria no inicializada, definida por un rango
(plantilla de funció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) |
|
construye objetos mediante
default-initialization
en un área de memoria no inicializada, definida por un inicio y contador
(objeto función algoritmo) |