Namespaces
Variants

std::uninitialized_move_n

Depuis fr.cppreference.net
 
 
Bibliothèque d'algorithmes
Algorithmes contraints et algorithmes sur les plages (C++20)
Algorithmes contraints, p.ex. ranges::copy, ranges::sort, ...
Opérations de séquence non modifiantes    
Opérations par lots
(C++17)
Opérations de recherche
Opérations de séquence modificatrices
Opérations de copie
(C++11)
(C++11)
Opérations d'échange
Opérations de transformation
Opérations de génération
Opérations de suppression
Opérations de changement d'ordre
(jusqu'à C++17)(C++11)
(C++20)(C++20)
Opérations d'échantillonnage
(C++17)

Opérations de tri et connexes
Opérations de partitionnement
(C++11)    

Opérations de tri
Opérations de recherche binaire
(sur plages partitionnées)
Opérations d'ensemble (sur plages triées)
Opérations de fusion (sur plages triées)
Opérations de tas
Opérations de minimum/maximum
(C++11)
(C++17)
Opérations de comparaison lexicographique
Opérations de permutation


 
 
Défini dans l'en-tête <memory>
template< class InputIt, class Size, class NoThrowForwardIt >
std::pair<InputIt, NoThrowForwardIt>
    uninitialized_move_n( InputIt first, Size count,
                          NoThrowForwardIt d_first );
(1) (depuis C++17)
(constexpr depuis C++26)
template< class ExecutionPolicy,
          class ForwardIt, class Size, class NoThrowForwardIt >
std::pair<ForwardIt, NoThrowForwardIt>
    uninitialized_move_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(deref-move(*iter));
return {first, d_first};

Si une exception est levée lors de l'initialisation, certains objets dans first + [0count) sont laissés dans un état valide mais non spécifié, et 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)


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

(depuis C++20)

Paramètres

first - le début de la plage des éléments à déplacer
d_first - le début de la plage de destination
count - le nombre d'éléments à déplacer
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.

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 à des objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour standard policies, std::terminate est invoqué).

Notes

Lorsque l'itérateur d'entrée déréférence une rvalue, le comportement de std::uninitialized_move_n est le même que celui de std::uninitialized_copy_n.

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 Size, class NoThrowForwardIt>
constexpr std::pair<InputIt, NoThrowForwardIt>
    uninitialized_move_n(InputIt first, Size count, NoThrowForwardIt d_first)
{
    using ValueType = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; count > 0; ++first, (void) ++current, --count) {
            auto addr = static_cast<void*>(std::addressof(*current));
            if constexpr (std::is_lvalue_reference_v<decltype(*first)>)
                ::new (addr) ValueType(std::move(*first));
            else
                ::new (addr) ValueType(*first);
        }
    }
    catch (...)
    {
        std::destroy(d_first, current);
        throw;
    }
    return {first, current};
}
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `
` et ``, et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.

Exemple

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
void print(auto rem, auto first, auto last)
{
    for (std::cout << rem; first != last; ++first)
        std::cout << std::quoted(*first) << ' ';
    std::cout << '\n';
}
int main()
{
    std::string in[]{"One", "Definition", "Rule"};
    print("initially, in: ", std::begin(in), std::end(in));
    if (constexpr auto sz = std::size(in);
        void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
    {
        try
        {
            auto first{static_cast<std::string*>(out)};
            auto last{first + sz};
            std::uninitialized_move_n(std::begin(in), sz, first);
            print("after move, in: ", std::begin(in), std::end(in));
            print("after move, out: ", first, last);
            std::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "Exception!\n";
        }
        std::free(out);
    }
}

Sortie possible :

initially, in: "One" "Definition" "Rule" 
after move, in: "" "" "" 
after move, out: "One" "Definition" "Rule"

Rapports de défauts

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

DR Appliqué à Comportement tel que publié Comportement correct
LWG 3918 C++17 la construction par déplacement est toujours effectuée même
si l'itérateur d'entrée déréférence une prvalue
aucune construction par déplacement
dans ce cas

Voir aussi

déplace une plage d'objets vers une zone mémoire non initialisée
(modèle de fonction)
copie un nombre d'objets vers une zone mémoire non initialisée
(modèle de fonction)
déplace un nombre d'objets vers une zone mémoire non initialisée
(objet fonction algorithme)