Namespaces
Variants

std:: move

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
move
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class InputIt, class OutputIt >

OutputIt move ( InputIt first, InputIt last,

OutputIt d_first ) ;
(1) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardIt2 move ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,

ForwardIt2 d_first ) ;
(2) (depuis C++17)
1) Déplace les éléments dans la plage [ first , last ) , vers une autre plage commençant à d_first , en commençant par first et en poursuivant jusqu'à last . Après cette opération, les éléments dans la plage d'origine contiendront toujours des valeurs valides du type approprié, mais pas nécessairement les mêmes valeurs qu'avant le déplacement.
2) Identique à (1) , mais exécuté selon la policy .
Cette surcharge participe à la résolution de surcharge uniquement si toutes les conditions suivantes sont satisfaites :

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> est true .

(jusqu'en C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> est true .

(depuis C++20)

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

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage source des éléments à déplacer
d_first - le début de la plage de destination
policy - la politique d'exécution à utiliser
Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .
-
OutputIt doit satisfaire aux exigences de LegacyOutputIterator .
-
ForwardIt1, ForwardIt2 doit satisfaire aux exigences de LegacyForwardIterator .

Valeur de retour

L'itérateur vers l'élément après 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 fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

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é lors d'un déplacement 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é lors d'un déplacement 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.

Exécuter ce code 
#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() ne compilerait pas, car std::jthread est non-copiable
    std::move(v.begin(), v.end(), std::back_inserter(l));
}

Sortie : 

thread 1 ended
thread 2 ended
thread 3 ended

Voir aussi

(C++11)
déplace une plage d'éléments vers un nouvel emplacement dans l'ordre inverse
(modèle de fonction)
(C++11)
convertit l'argument en xvalue
(modèle de fonction)
(C++20)
déplace une plage d'éléments vers un nouvel emplacement
(objet fonction algorithme)