std::uninitialized_copy_n

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

1) Construit des éléments dans la plage de destination commençant à d_first à partir des count premiers éléments de la plage source commençant à first comme si par

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

Si une exception est levée lors de 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:

`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)

Si d_first + [0, count) chevauche first + [0, count), le comportement est indéfini.

(depuis C++20)

Paramètres

first	-	le début de la plage des éléments à copier
count	-	le nombre d'éléments à copier
d_first	-	le début de la plage cible
policy	-	la execution policy à utiliser
Exigences de type
- `InputIt` doit satisfaire aux exigences de LegacyInputIterator.
- `ForwardIt` doit satisfaire aux exigences de LegacyForwardIterator.
- `NoThrowForwardIt` doit satisfaire aux exigences de LegacyForwardIterator.
- Aucun incrément, affectation, comparaison ou déréférencement à travers des instances valides de `NoThrowForwardIt` ne doit 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 attrapé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

Feature-test macro	Valeur	Norme	Fonctionnalité
`__cpp_lib_raw_memory_algorithms`	`202411L`	(C++26)	`constexpr` pour specialized `<memory>` algorithms, (1)

Implémentation possible

template<class InputIt, class Size, class NoThrowForwardIt>
constexpr NoThrowForwardIt uninitialized_copy_n(InputIt first, Size count,
                                                NoThrowForwardIt d_first)
{
    using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; count > 0; ++first, (void) ++current, --count)
            ::new (static_cast<void*>(std::addressof(*current))) T(*first);
    }
    catch (...)
    {
        for (; d_first != current; ++d_first)
            d_first->~T();
        throw;
    }
    return current;
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Exemple

Exécuter ce code

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::string> v = {"This", "is", "an", "example"};
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size());
    sz = std::min(sz, v.size());
    std::uninitialized_copy_n(v.begin(), sz, p);
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << ' ';
        i->~basic_string<char>();
    }
    std::cout << '\n';
    std::return_temporary_buffer(p);
}

Sortie possible :

This is an example

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 2133	C++98	la description de l'effet utilisait une `for` boucle avec l'itération expression `++d_first, ++first, --count`, ce qui entraîne des recherches dépendant des arguments de `operator,`	supprime la valeur d'un opérande pour désactiver ces ADL
LWG 2433	C++11	cet algorithme pourrait être détourné par des surchargées `operator&`	utilisations std::addressof

Voir aussi

uninitialized_copy	copie une plage d'objets vers une zone mémoire non initialisée (fonction template)
ranges::uninitialized_copy_n (C++20)	copie un nombre d'objets vers une zone mémoire non initialisée (objet fonction algorithme)

Support du compilateur
Environnements autonomes et hébergés
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test des fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque des 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 des 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 de 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