Namespaces
Variants

std:: rotate_copy

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)
(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 ForwardIt, class OutputIt >

OutputIt rotate_copy ( ForwardIt first, ForwardIt middle,

ForwardIt last, OutputIt d_first ) ;
(1) (constexpr seit C++20)
template < class ExecutionPolicy,

class ForwardIt1, class ForwardIt2 >
ForwardIt2 rotate_copy ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 middle,

ForwardIt1 last, ForwardIt2 d_first ) ;
(2) (seit C++17)

Kopiert die Linksrotation von [ first , last ) nach d_first .

1) Kopiert die Elemente aus dem Bereich [ first , last ) , sodass im Zielbereich beginnend bei d_first die Elemente aus [ middle , last ) vor den Elementen aus [ first , middle ) platziert werden, während die Reihenfolgen der Elemente in beiden Bereichen erhalten bleiben.
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 eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

  • [ first , middle ) oder [ middle , last ) ist kein gültiger Bereich .
  • Die Quell- und Zielbereiche überlappen sich.

Inhaltsverzeichnis

Parameter

first, last - das Paar von Iteratoren, das den Quell- Bereich der zu kopierenden Elemente definiert
middle - ein Iterator zu einem Element in [ first , last ) , das am Anfang des neuen Bereichs erscheinen soll
d_first - Anfang des Zielbereichs
policy - die zu verwendende Ausführungsrichtlinie
Typanforderungen
-
ForwardIt, ForwardIt1, ForwardIt2 müssen die Anforderungen von LegacyForwardIterator erfüllen.
-
OutputIt muss die Anforderungen von LegacyOutputIterator erfüllen.

Rückgabewert

Ausgabeiterator auf das Element nach dem letzten kopierten Element.

Komplexität

Genau std:: distance ( first, last ) 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 allozieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

Siehe auch die Implementierungen in libstdc++ , libc++ , und MSVC STL . 

template<class ForwardIt, class OutputIt>
constexpr // seit C++20
OutputIt rotate_copy(ForwardIt first, ForwardIt middle,
                     ForwardIt last, OutputIt d_first)
{
    d_first = std::copy(middle, last, d_first);
    return std::copy(first, middle, d_first);
}

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
int main()
{
    std::vector<int> src{1, 2, 3, 4, 5};
    std::vector<int> dest(src.size());
    auto pivot = std::find(src.begin(), src.end(), 3);
    std::rotate_copy(src.begin(), pivot, src.end(), dest.begin());
    for (int i : dest)
        std::cout << i << ' ';
    std::cout << '\n';
    // copy the rotation result directly to the std::cout
    pivot = std::find(dest.begin(), dest.end(), 1);
    std::rotate_copy(dest.begin(), pivot, dest.end(),
                     std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

Ausgabe: 

3 4 5 1 2
1 2 3 4 5

Siehe auch

dreht die Reihenfolge der Elemente in einem Bereich
(Funktions-Template)
(C++20)
kopiert und dreht einen Bereich von Elementen
(Algorithmus-Funktionsobjekt)