Namensräume
Varianten
Aktionen

std::ranges::rotate_copy, std::ranges::rotate_copy_result

Von cppreference.com
< cpp‎ | algorithm‎ | ranges
 
 
Algorithmenbibliothek
Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
Nicht-modifizierende Sequenzoperationen
Stapeloperationen
(C++17)
Suchoperationen
(C++11)                (C++11)(C++11)

Modifizierende Sequenzoperationen
Kopieroperationen
(C++11)
(C++11)
Tauschoperationen
Transformationsoperationen
Generierungsoperationen
Entfernungsoperationen
Ordnungsändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortier- und verwandte Operationen
Partitionierungsoperationen
Sortieroperationen
Binäre Suchoperationen
(auf partitionierten Bereichen)
Mengenoperationen (auf sortierten Bereichen)
Zusammenführungsoperationen (auf sortierten Bereichen)
Heapoperationen
Minimum/Maximum-Operationen
(C++11)
(C++17)
Lexikographische Vergleichsoperationen
Permutationsoperationen
C-Bibliothek
Numerische Operationen
Operationen auf uninitialisiertem Speicher
 
Eingeschränkte Algorithmen
Alle Namen in diesem Menü gehören zum Namespace std::ranges
Nicht-modifizierende Sequenzoperationen
Modifizierende Sequenzoperationen
Partitionierungsoperationen
Sortieroperationen
Binäre Suchoperationen (auf sortierten Bereichen)
       
       
Mengenoperationen (auf sortierten Bereichen)
Heapoperationen
Minimum/Maximum-Operationen
       
       
Permutationsoperationen
Faltoperationen
Operationen auf uninitialisiertem Speicher
Rückgabetypen
 
Definiert in Header <algorithm>
Aufruf-Signatur
template< std::forward_iterator I, std::sentinel_for<I> S,

          std::weakly_incrementable O >
requires std::indirectly_copyable<I, O>
constexpr rotate_copy_result<I, O>

    rotate_copy( I first, I middle, S last, O result );
(1) (seit C++20)
template< ranges::forward_range R, std::weakly_incrementable O >

requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr rotate_copy_result<ranges::borrowed_iterator_t<R>, O>

    rotate_copy( R&& r, ranges::iterator_t<R> middle, O result );
(2) (seit C++20)
Hilfstypen
template< class I, class O >
using rotate_copy_result = in_out_result<I, O>;
(3) (seit C++20)

Kopiert die Linksrotation von [firstlast) nach result.

1) Kopiert die Elemente aus dem Quellbereich [firstlast) so, dass im Zielbereich die Elemente aus [firstmiddle) nach den Elementen aus [middlelast) platziert werden, während die Reihenfolge der Elemente in beiden Bereichen erhalten bleibt.
Das Verhalten ist undefiniert, wenn entweder [firstmiddle) oder [middlelast) kein gültiger Bereich ist oder wenn sich der Quell- und der Zielbereich überschneiden.
2) Dasselbe wie (1), aber verwendet r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.

Inhalt

[edit] Parameter

first, last - das Iterator-Sentinel-Paar, das den Quell-Bereich der zu kopierenden Elemente definiert
r - der Quellbereich der zu kopierenden Elemente
middle - der Iterator auf das Element, das am Anfang des Zielbereichs erscheinen soll
Ergebnis - Anfang des Zielbereichs

[edit] Rückgabewert

{last, result + N}, wobei N = ranges::distance(first, last).

[edit] Komplexität

Linear: exakt N Zuweisungen.

[edit] Hinweise

Wenn der Werttyp TriviallyCopyable ist und die Iteratortypen contiguous_iterator erfüllen, vermeiden Implementierungen von ranges::rotate_copy normalerweise mehrere Zuweisungen, indem sie eine "Bulk-Kopier"-Funktion wie std::memmove verwenden.

[edit] Mögliche Implementierung

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

struct rotate_copy_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::rotate_copy_result<I, O>
        operator()(I first, I middle, S last, O result) const
    {
        auto c1 {ranges::copy(middle, std::move(last), std::move(result))};
        auto c2 {ranges::copy(std::move(first), std::move(middle), std::move(c1.out))};
        return {std::move(c1.in), std::move(c2.out)};
    }
 
    template<ranges::forward_range R, std::weakly_incrementable O>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::rotate_copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, ranges::iterator_t<R> middle, O result) const
    {
        return (*this)(ranges::begin(r), std::move(middle),
                       ranges::end(r), std::move(result));
    }
};
 
inline constexpr rotate_copy_fn rotate_copy {};

[edit] Beispiel

#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::ranges::find(src, 3);
 
    std::ranges::rotate_copy(src, pivot, dest.begin());
    for (int i : dest)
        std::cout << i << ' ';
    std::cout << '\n';
 
    // copy the rotation result directly to the std::cout
    pivot = std::ranges::find(dest, 1);
    std::ranges::rotate_copy(dest, pivot, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

Ausgabe

3 4 5 1 2
1 2 3 4 5

[edit] Siehe auch

Rotiert die Reihenfolge der Elemente in einem Bereich
(Algorithmus-Funktionsobjekt)[edit]
Kopiert einen Elementbereich an einen neuen Speicherort
(Algorithmus-Funktionsobjekt)[edit]
Kopiert und rotiert einen Bereich von Elementen
(Funktionstemplate) [edit]