std::uninitialized_default_construct
Depuis fr.cppreference.net
| Défini dans l'en-tête <memory>
|
||
template< class NoThrowForwardIt >
void uninitialized_default_construct( NoThrowForwardIt first,
NoThrowForwardIt last );
|
(1) | (depuis C++17) (constexpr depuis C++26) |
template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_default_construct( ExecutionPolicy&& policy,
NoThrowForwardIt first,
NoThrowForwardIt last );
|
(2) | (depuis C++17) |
1) Construit les éléments dans la plage de destination
[first, last) par initialisation par défaut, comme par
for (; first != last; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type;
Si une exception est levée pendant l'initialisation, les objets déjà construits sont détruits dans un ordre non spécifié.
2) Identique à (1), mais exécuté selon
policy. Cette surcharge participe à la résolution de surcharge uniquement si la valeur de l'expression suivante est
true :
|
|
(jusqu'à C++20) |
|
|
(depuis C++20) |
Paramètres
| first, last | - | la paire d'itérateurs définissant la plage d'éléments à initialiser |
| policy | - | la politique d'exécution à utiliser |
| Exigences de type | ||
-
NoThrowForwardIt
doit satisfaire aux exigences de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
ne peut lever d'exceptions.
|
||
Exceptions
2) Pendant l'exécution :
- Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
- Si une exception non interceptée est levée lors de l'accès à des objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour les politiques standard, std::terminate est invoqué).
Notes
| Test de fonctionnalité macro | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr pour spécialisés <memory> algorithmes, (1)
|
Implémentation possible
template<class NoThrowForwardIt> constexpr void uninitialized_default_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; } } |
Exemple
Exécuter ce code
#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{first + n}; std::uninitialized_default_construct(first, last); for (auto it{first}; it != last; ++it) std::cout << it->m << '\n'; std::destroy(first, last); } catch (...) { std::cout << "Exception!\n"; } // Pour les types scalaires, uninitialized_default_construct // ne remplit généralement pas de zéros la zone mémoire non initialisée donnée. int v[]{1, 2, 3, 4}; const int original[]{1, 2, 3, 4}; std::uninitialized_default_construct(std::begin(v), std::end(v)); // Comportement potentiellement indéfini, en attente de la résolution de CWG 1997. // for (const int i : v) // std::cout << i << ' '; // Le résultat est non spécifié. std::cout << (std::memcmp(v, original, sizeof(v)) == 0 ? "Unmodified\n" : "Modified\n"); }
Sortie possible :
Default value Default value Default value Unmodified
Voir aussi
|
construit des objets par
default-initialization
dans une zone mémoire non initialisée, définie par un début et un compte
(modèle de fonction) |
|
|
(C++17)
|
construit des objets par
value-initialization
dans une zone mémoire non initialisée, définie par une plage
(modèle de fonction) |
|
construit des objets par
default-initialization
dans une zone mémoire non initialisée, définie par une plage
(objet fonction algorithme) |