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
Definiert im Header <algorithm>
template < class InputIt, class OutputIt >

OutputIt move ( InputIt first, InputIt last,

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

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

ForwardIt2 d_first ) ;
(2) (seit C++17)
1) Verschiebt die Elemente im Bereich [ first , last ) in einen anderen Bereich beginnend bei d_first , startend von first und fortschreitend bis zu last . Nach diesem Vorgang enthalten die Elemente im verschobenen Bereich weiterhin gültige Werte des entsprechenden Typs, aber nicht notwendigerweise dieselben Werte wie vor der Verschiebung.
2) Gleich wie (1) , aber ausgeführt gemäß policy .
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

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

(bis C++20)

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

(seit C++20)

Wenn d_first innerhalb des Bereichs [ first , last ) liegt, ist das Verhalten undefiniert. In diesem Fall kann stattdessen std::move_backward verwendet werden.

Inhaltsverzeichnis

Parameter

first, last - das Iteratorpaar, das den Quell- Bereich der zu verschiebenden Elemente definiert
d_first - der Anfang des Zielbereichs
policy - die zu verwendende Ausführungsrichtlinie
Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
OutputIt muss die Anforderungen von LegacyOutputIterator erfüllen.
-
ForwardIt1, ForwardIt2 muss die Anforderungen von LegacyForwardIterator erfüllen.

Rückgabewert

Der Iterator auf das Element nach dem letzten verschobenen Element.

Komplexität

Genau std:: distance ( first, last ) Move-Zuweisungen.

Ausnahmen

Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet Fehler wie folgt:

  • Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
  • Wenn der Algorithmus keinen Speicher allokieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung 

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;
}

Hinweise

Beim Verschieben überlappender Bereiche ist std::move geeignet, wenn nach links verschoben wird (der Anfang des Zielbereichs liegt außerhalb des Quellbereichs), während std::move_backward geeignet ist, wenn nach rechts verschoben wird (das Ende des Zielbereichs liegt außerhalb des Quellbereichs).

Beispiel

Der folgende Code verschiebt Thread-Objekte (die selbst nicht kopierbar sind) von einem Container in einen anderen.

Diesen Code ausführen 
#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() würde nicht kompilieren, weil std::jthread nicht kopierbar ist
    std::move(v.begin(), v.end(), std::back_inserter(l));
}

Ausgabe: 

thread 1 ended
thread 2 ended
thread 3 ended

Siehe auch

(C++11)
verschiebt einen Bereich von Elementen in umgekehrter Reihenfolge an einen neuen Speicherort
(Funktions-Template)
(C++11)
konvertiert das Argument in einen xvalue
(Funktions-Template)
(C++20)
verschiebt einen Bereich von Elementen an einen neuen Speicherort
(Algorithmus-Funktionsobjekt)