std::uninitialized_value_construct_n

Défini dans l'en-tête `<memory>`
template< class NoThrowForwardIt, class Size > NoThrowForwardIt uninitialized_value_construct_n ( NoThrowForwardIt first, Size count );	(1)	(depuis C++17) (constexpr depuis C++26)
template< class ExecutionPolicy, class NoThrowForwardIt, class Size > NoThrowForwardIt uninitialized_value_construct_n ( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );	(2)	(depuis C++17)

1) Construit des éléments dans la plage de destination first + [0, count) par initialisation par valeur comme par

for (; count > 0; (void)++first, --count)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type();
return first;

Si une exception est levée durant 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 ne participe à la résolution de surcharge que si la valeur de l'expression suivante est true:

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(jusqu'à C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(depuis C++20)

Paramètres

first	-	le début de la plage d'éléments à initialiser
count	-	le nombre d'éléments à initialiser
policy	-	la politique d'exécution à utiliser
Exigences de type
- `NoThrowForwardIt` doit satisfaire aux exigences de LegacyForwardIterator .
- Aucun incrément, assignation, comparaison ou indirection via des instances valides de `NoThrowForwardIt` ne peut lever d'exceptions.

Valeur de retour

Comme décrit ci-dessus.

Exceptions

2) Pendant le processus d'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 aux 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ée).

Notes

Test de fonctionnalité macro	Valeur	Norme	Fonctionnalité
`__cpp_lib_raw_memory_algorithms`	`202411L`	(C++26)	`constexpr` pour algorithmes `<memory>`spécialisés, (1)

Implémentation possible

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;
    }
}

Exemple

Exécuter ce code

#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";
    }
    // Pour les types scalaires, uninitialized_value_construct_n
    // initialise à zéro la zone mémoire non initialisée donnée.
    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';
}

Sortie :

Default value
Default value
Default value
1 2 3 4
0 0 0 0

Voir aussi

uninitialized_value_construct (C++17)	construit des objets par value-initialization dans une zone mémoire non initialisée, définie par une plage (fonction template)
uninitialized_default_construct_n (C++17)	construit des objets par default-initialization dans une zone mémoire non initialisée, définie par un début et un compte (fonction template)
ranges::uninitialized_value_construct_n (C++20)	construit des objets par value-initialization dans une zone mémoire non initialisée, définie par un début et un compte (objet fonction algorithme)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostic
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support à la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants