Namespaces
Variants

    std::reverse_copy

    Von de.cppreference.net
     
    C++
     
    Algorithmenbibliothek
    Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
    Eingeschränkte Algorithmen, z. B.ranges::copy,ranges::sort, ...
    Nicht modifizierende Sequenzoperationen    
    Batch-Operationen
    (C++17)
    Suchoperationen
    Modifizierende Sequenzoperationen
    Kopieroperationen
    (C++11)
    (C++11)
    (C++11)
    Swap-Operationen
    Transformationsoperationen
    Erzeugungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

    Sortier- und zugehörige Operationen
    Partitionierungsoperationen
    (C++11)    
    (C++11)

    Sortieroperationen
    Binäre Suchoperationen
    (auf partitionierten Bereichen)
    Mengenoperationen (auf sortierten Bereichen)
    Mischoperationen (auf sortierten Bereichen)
    Heap-Operationen
    Minimum/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Definiert in Header <algorithm> 
    template< class BidirIt, class OutputIt >
OutputIt reverse_copy( BidirIt first, BidirIt last,
                       OutputIt d_first );
    		(1) (constexpr seit C++20) 
    template< class ExecutionPolicy, class BidirIt, class ForwardIt >
ForwardIt reverse_copy( ExecutionPolicy&& policy,
                        BidirIt first, BidirIt last,
                        ForwardIt d_first );
    		(2) (seit C++17)
    1) Gegeben N als std::distance(first, last). Kopiert die Elemente aus dem Bereich [first, last) (Quellbereich) in einen anderen Bereich von N Elementen, beginnend bei d_first (Zielbereich), so dass die Elemente im Zielbereich in umgekehrter Reihenfolge sind.
    Verhält sich, als ob die Zuweisung *(d_first + N - 1 - i) = *(first + i)[1] einmal für jede ganze Zahl i in [0, N) ausgeführt würde.
    Wenn sich Quell- und Zielbereich überschneiden, ist das Verhalten undefiniert.
    2) Gleich wie (1), aber ausgeführt gemäß policy.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true ist:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(bis C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(seit C++20)

    Parameter

    first, last - das Iteratorpaar, das den Quell- Bereich der zu kopierenden Elemente definiert
    d_first - der Anfang des Zielbereichs
    Typanforderungen
    -
    BidirIt muss die Anforderungen von LegacyBidirectionalIterator erfüllen.
    -
    OutputIt muss die Anforderungen von LegacyOutputIterator erfüllen.
    -
    ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.

    Rückgabewert

    Ausgabeiterator auf das Element nach dem letzten kopierten Element.

    Komplexität

    Genau N 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 BidirIt, class OutputIt>
constexpr // seit C++20
OutputIt reverse_copy(BidirIt first, BidirIt last, OutputIt d_first)
{
    for (; first != last; ++d_first)
        *d_first = *(--last);
    return d_first;
}

    Hinweise

    Implementierungen (z.B. MSVC STL ) können Vektorisierung ermöglichen, wenn beide Iteratortypen LegacyContiguousIterator erfüllen und denselben Werttyp besitzen, und der Werttyp TriviallyCopyable ist.

    Beispiel

    Diesen Code ausführen 
    #include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    auto print = [](const std::vector<int>& v)
    {
        for (const auto& value : v)
            std::cout << value << ' ';
        std::cout << '\n';
    };
    std::vector<int> v{1, 2, 3};
    print(v);
    std::vector<int> destination(3);
    std::reverse_copy(std::begin(v), std::end(v), std::begin(destination));
    print(destination);
    std::reverse_copy(std::rbegin(v), std::rend(v), std::begin(destination));
    print(destination);
}

    Ausgabe: 

    1 2 3 
3 2 1 
1 2 3

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 2074 C++98 für jedes i war die Zuweisung
    * ( d_first + N - i ) = * ( first + i ) [1]     		korrigiert zu
    * ( d_first + N - 1 - i ) = * ( first + i ) [1]
    LWG 2150 C++98 nur ein Element musste zugewiesen werden Anforderung korrigiert
    1. ↑ 1.0 1.1 1.2 LegacyOutputIterator muss binäre Operatoren + und - nicht unterstützen. Die Verwendung von + und - ist hier nur erläuternd: Die tatsächliche Berechnung muss sie nicht verwenden.

    Siehe auch

    		 kehrt die Reihenfolge der Elemente in einem Bereich um
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)
    		 erstellt eine umgekehrte Kopie eines Bereichs
    (Algorithmus-Funktionsobjekt)