std::ranges::uninitialized_move, std::ranges::uninitialized_move_result

Défini dans l'en-tête `<memory>`
Signature d'appel
template< std::input_iterator I, std::sentinel_for<I> S1, /nothrow-forward-iterator/ O, /nothrow-sentinel-for/<O> S2 > requires std::constructible_from<std::iter_value_t<O>, std::iter_rvalue_reference_t<I>> uninitialized_move_result<I, O> uninitialized_move( I ifirst, S1 ilast, O ofirst, S2 olast );	(1)	(depuis C++20) (constexpr depuis C++26)
template< ranges::input_range IR, /nothrow-forward-range/ OR > requires std::constructible_from<ranges::range_value_t<OR>, ranges::range_rvalue_reference_t<IR>> uninitialized_move_result<ranges::borrowed_iterator_t<IR>, ranges::borrowed_iterator_t<OR>> uninitialized_move( IR&& in_range, OR&& out_range );	(2)	(depuis C++20) (constexpr depuis C++26)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S1, /nothrow-random-access-iterator/ O, /nothrow-sized-sentinel-for/<O> S2 > requires std::constructible_from<std::iter_value_t<O>, std::iter_rvalue_reference_t<I>> uninitialized_move_result<I, O> uninitialized_move( Ep&& policy, I ifirst, S1 ilast, O ofirst, S2 olast );	(3)	(depuis C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ IR, /nothrow-sized-random-access-range/ OR > requires std::constructible_from<ranges::range_value_t<OR>, ranges::range_rvalue_reference_t<IR>> uninitialized_move_result<ranges::borrowed_iterator_t<IR>, ranges::borrowed_iterator_t<OR>> uninitialized_move( Ep&& policy, IR&& in_range, OR&& out_range );	(4)	(depuis C++26)
Types auxiliaires
template< class I, class O > using uninitialized_move_result = ranges::in_out_result<I, O>;	(5)	(depuis C++20)

Pour la définition de /*execution-policy*/, voir cette page ; pour la définition de /*sized-random-access-range*/, voir cette page ; pour la définition des autres concepts d'exposition uniquement, voir cette page.

1) Construit des éléments dans la plage de destination [ofirst, olast) à partir d'éléments dans la plage source [ifirst, ilast) comme par

for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
::new (voidify(*ofirst))
std::remove_reference_t<std::iter_reference_t<O>>(ranges::iter_move(ifirst));
return {std::move(ifirst), ofirst};

Si une exception est levée lors de l'initialisation, alors les objets déjà construits dans [ofirst, olast) sont détruits dans un ordre non spécifié. De plus, les objets dans [ifirst, ilast) qui ont déjà été déplacés, sont laissés dans un état valide mais non spécifié.

2) Identique à (1), mais utilise in_range comme plage source et out_range comme plage de destination.

3,4) Identique à (1,2), mais exécuté selon policy.

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement connus sous le nom de niebloïdes), c'est-à-dire :

Les listes explicites d'arguments template ne peuvent pas être spécifiées lors de l'appel à l'un d'entre eux.
Aucun d'entre eux n'est visible par recherche dépendante des arguments.
Lorsque l'un d'entre eux est trouvé par recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

ifirst, ilast	-	la paire itérateur-sentinelle définissant la plage d'éléments à déplacer
in_range	-	la `plage` d'entrée d'éléments à déplacer
ofirst, olast	-	la paire itérateur-sentinelle définissant la plage de sortie d'éléments à initialiser
out_range	-	la `plage` de sortie à initialiser
policy	-	la politique d'exécution à utiliser

Valeur de retour

Comme décrit ci-dessus.

Exceptions

Toute exception levée lors de la construction des éléments dans la plage de destination.

3,4) 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 capturé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é).

Notes

Une implémentation peut améliorer l'efficacité de la ranges::uninitialized_move (en utilisant par ex. ranges::copy) si le type de valeur de la plage de sortie est TrivialType.

Test de fonctionnalité macro	Valeur	Norme	Fonctionnalité
`__cpp_lib_parallel_algorithm`	`202506L`	(C++26)	Algorithmes de plage parallèles
`__cpp_lib_raw_memory_algorithms`	`202411L`	(C++26)	`constexpr` pour spécialisés `<memory>` algorithmes, (1,2)

Implémentation possible

struct uninitialized_move_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S1,
             /*nothrow-forward-iterator*/ O, /*nothrow-sentinel-for*/<O> S2>
        requires std::constructible_from<std::iter_value_t<O>,
                                         std::iter_rvalue_reference_t<I>>
    constexpr ranges::uninitialized_move_result<I, O>
        operator()(I ifirst, S1 ilast, O ofirst, S2 olast) const
    {
        using ValueType = std::remove_reference_t<std::iter_reference_t<O>>;
        O current{ofirst};
        try
        {
            for (; !(ifirst == ilast or current == olast); ++ifirst, ++current)
                ::new (static_cast<void*>(std::addressof(*current))))
                    ValueType(ranges::iter_move(ifirst));
            return {std::move(ifirst), std::move(current)};
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; ofirst != current; ++ofirst)
                ranges::destroy_at(std::addressof(*ofirst));
            throw;
        }
    }
    
    template<ranges::input_range IR, /*nothrow-forward-range*/ OR>
        requires std::constructible_from<ranges::range_value_t<OR>,
                                         ranges::range_rvalue_reference_t<IR>>
    constexpr ranges::uninitialized_move_result<ranges::borrowed_iterator_t<IR>,
                                                ranges::borrowed_iterator_t<OR>>
        operator()(IR&& in_range, OR&& out_range) const
    {
        return (*this)(ranges::begin(in_range), ranges::end(in_range),
                       ranges::begin(out_range),
                       ranges::next(ranges::begin(out_range), ranges::end(out_range)));
    }
    
    template<ranges::forward_range IR, /*nothrow-forward-range*/ OR>
        requires std::constructible_from<ranges::range_value_t<OR>,
                                         ranges::range_rvalue_reference_t<IR>>
    constexpr ranges::uninitialized_move_result<ranges::borrowed_iterator_t<IR>,
                                                ranges::borrowed_iterator_t<OR>>
        operator()(IR&& in_range, OR&& out_range) const
    {
        return (*this)(ranges::begin(in_range),
                       ranges::next(ranges::begin(in_range), ranges::end(in_range))
                       ranges::begin(out_range),
                       ranges::next(ranges::begin(out_range), ranges::end(out_range)));
    }
};

inline constexpr uninitialized_move_fn uninitialized_move{};

Exemple

Exécuter ce code

#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[]{"Home", "World"};
    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::ranges::uninitialized_move(std::begin(in), std::end(in), first, last);
            print("after move, in: ", std::begin(in), std::end(in));
            print("after move, out: ", first, last);
            std::ranges::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "Exception!\n";
        }
        std::free(out);
    }
}

Sortie possible :

initially, in: "Home" "World"
after move, in: "" ""
after move, out: "Home" "World"

Voir aussi

ranges::uninitialized_move_n (C++20)	déplace un nombre d'objets vers une zone mémoire non initialisée (objet fonction d'algorithme)
uninitialized_move (C++17)	déplace une plage d'objets vers une zone mémoire non initialisée (modèle de fonction)

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