Namensräume
Varianten
Aktionen

std::ranges::reverse

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::bidirectional_iterator I, std::sentinel_for<I> S >

requires std::permutable<I>
constexpr I

    reverse( I first, S last );
(1) (seit C++20)
template< ranges::bidirectional_range R >

requires std::permutable<ranges::iterator_t<R>>
constexpr ranges::borrowed_iterator_t<R>

    reverse( R&& r );
(2) (seit C++20)
1) Kehrt die Reihenfolge der Elemente im Bereich [firstlast) um.
Verhält sich so, als ob für jedes Paar von Iteratoren first + i, last - i - 1, wobei 0 ≤ i < (last - first) / 2 gilt, ranges::iter_swap angewendet wird.
2) Dasselbe wie (1), verwendet aber r als Bereich, 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 Bereich der umzukehrenden Elemente definiert
r - der Bereich der umzukehrenden Elemente

[edit] Rückgabewert

Ein Iterator, der gleich last ist.

[edit] Komplexität

Genau (last - first) / 2 Swaps.

[edit] Hinweise

Implementierungen (z. B. MSVC STL) können Vektorisierung aktivieren, wenn der Iteratortyp contiguous_iterator modelliert und das Tauschen seines Werttyps weder eine nicht-triviale spezielle Memberfunktion noch eine ADL-gefundene swap aufruft.

[edit] Mögliche Implementierung

Siehe auch Implementierungen in libstdc++ und MSVC STL.

struct reverse_fn
{
    template<std::bidirectional_iterator I, std::sentinel_for<I> S>
    requires std::permutable<I>
    constexpr I operator()(I first, S last) const
    {
        auto last2 {ranges::next(first, last)};
        for (auto tail {last2}; !(first == tail or first == --tail); ++first)
            ranges::iter_swap(first, tail);
        return last2;
    }
 
    template<ranges::bidirectional_range R>
    requires std::permutable<ranges::iterator_t<R>>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r) const
    {
        return (*this)(ranges::begin(r), ranges::end(r));
    }
};
 
inline constexpr reverse_fn reverse {};

[edit] Beispiel

#include <algorithm>
#include <array>
#include <iostream>
#include <string>
 
int main()
{
    std::string s {"ABCDEF"};
    std::cout << s << " → ";
    std::ranges::reverse(s.begin(), s.end());
    std::cout << s << " → ";
    std::ranges::reverse(s);
    std::cout << s << " │ ";
 
    std::array a {1, 2, 3, 4, 5};
    for (auto e : a)
        std::cout << e << ' ';
    std::cout << "→ ";
    std::ranges::reverse(a);
    for (auto e : a)
        std::cout << e << ' ';
    std::cout << '\n';
}

Ausgabe

ABCDEF → FEDCBA → ABCDEF │ 1 2 3 4 5 → 5 4 3 2 1

[edit] Siehe auch

Erstellt eine Kopie eines Bereichs, der umgekehrt ist
(Algorithmus-Funktionsobjekt)[edit]
ein view, der über die Elemente eines anderen bidirektionalen Views in umgekehrter Reihenfolge iteriert
(Klassen-Template) (Range-Adaptor-Objekt)[edit]
Kehrt die Reihenfolge der Elemente in einem Bereich um
(Funktionstemplate) [edit]