std::move

template< class InputIt, class OutputIt >
OutputIt move( InputIt first, InputIt last,
               OutputIt d_first );

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt2 move( ExecutionPolicy&& policy,
                 ForwardIt1 first, ForwardIt1 last,
                 ForwardIt2 d_first );

Si d_first se trouve dans la plage [first, last), le comportement est indéfini. Dans ce cas, std::move_backward peut être utilisé à la place.

Paramètres

Valeur de retour

L'itérateur pointant sur l'élément suivant le dernier élément déplacé.

Complexité

Exactement std::distance(first, last) affectations par déplacement.

Exceptions

La surcharge avec un paramètre de modèle nommé ExecutionPolicy signale les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy est l'une des politiques standard, std::terminate est appelé. Pour tout autre ExecutionPolicy, le comportement est défini par l'implémentation.
• Si l'algorithme échoue à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

template<class InputIt, class OutputIt>
OutputIt move(InputIt first, InputIt last, OutputIt d_first)
{
    for (; first != last; ++d_first, ++first)
        *d_first = std::move(*first);
    
    return d_first;
}

Notes

Lors du déplacement de plages qui se chevauchent, std::move est approprié pour déplacer vers la gauche (le début de la plage de destination est en dehors de la plage source) tandis que std::move_backward est approprié pour déplacer vers la droite (la fin de la plage de destination est en dehors de la plage source).

Exemple

Le code suivant déplace des objets thread (qui ne sont pas copiables eux-mêmes) d'un conteneur à un autre.

#include <algorithm>
#include <chrono>
#include <iostream>
#include <iterator>
#include <list>
#include <thread>
#include <vector>

void f(int n)
{
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "thread " << n << " ended" << std::endl;
}

int main()
{
    std::vector<std::jthread> v;
    v.emplace_back(f, 1);
    v.emplace_back(f, 2);
    v.emplace_back(f, 3);
    std::list<std::jthread> l;
    
    // copy() would not compile, because std::jthread is noncopyable
    std::move(v.begin(), v.end(), std::back_inserter(l));
}

thread 1 ended
thread 2 ended
thread 3 ended

Voir aussi