std::uninitialized_copy

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

1) Construit des éléments dans la plage de destination commençant à d_first à partir d'éléments de la plage source [first, last) comme par

for (; first != last; ++d_first, (void) ++first)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(*first);
return d_first;

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:

`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, std::distance(first, last)) chevauche [first, last), le comportement est indéfini.

(depuis C++20)

Paramètres

first, last	-	la paire d'itérateurs définissant l'intervalle des éléments à copier
d_first	-	le début de l'intervalle de destination
policy	-	la politique d'exécution à 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, assignation, comparaison ou indirection via des instances valides de `NoThrowForwardIt` ne peut lever d'exceptions. L'application de & * à une valeur `NoThrowForwardIt` doit produire un pointeur vers son type de valeur. (jusqu'en C++11)

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 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 InputIt, class NoThrowForwardIt>
constexpr NoThrowForwardIt uninitialized_copy(InputIt first, InputIt last,
                                              NoThrowForwardIt d_first)
{
    using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; first != last; ++first, (void) ++current)
            ::new (static_cast<void*>(std::addressof(*current))) T(*first);
        return current;
    }
    catch (...)
    {
        for (; d_first != current; ++d_first)
            d_first->~T();
        throw;
    }
}

Exemple

Exécuter ce code

#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    const char* v[] = {"This", "is", "an", "example"};
    
    auto sz = std::size(v);
    
    if (void* pbuf = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
    {
        try
        {
            auto first = static_cast<std::string*>(pbuf);
            auto last = std::uninitialized_copy(std::begin(v), std::end(v), first);
            
            for (auto it = first; it != last; ++it)
                std::cout << *it << '_';
            std::cout << '\n';
            
            std::destroy(first, last);
        }
        catch (...) {}
        std::free(pbuf);
    }
}

Sortie :

This_is_an_example_

Rapports de défauts

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

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 866	C++98	étant donné `T` comme type de valeur de `NoThrowForwardIt`, si `T::operator new` existe, le programme pourrait être mal formé	utilise le remplacement global- new à la place
LWG 2133	C++98	la description de l'effet utilisait une `for` boucle avec l'itération expression `++d_first, ++first`, ce qui résulte en une recherche dépendante des arguments de `operator,`	écarte la valeur d'un opérande pour désactiver cette ADL
LWG 2433	C++11	cet algorithme pourrait être détourné par surchargé `operator&`	utilise std::addressof

Voir aussi

uninitialized_copy_n (C++11)	copie un nombre d'objets vers une zone mémoire non initialisée (fonction template)
ranges::uninitialized_copy (C++20)	copie une plage d'objets vers une zone mémoire non initialisée (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 du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
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 de 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