Namespaces
Variants

std:: reverse_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 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 vorliegen.
Verhält sich so, als würde die Zuweisung * ( d_first + N - 1 - i ) = * ( first + i ) [1] einmal für jede ganze Zahl i in [ ​ 0 ​ , N ) ausgeführt.
Wenn sich Quell- und Zielbereiche überlappen, ist das Verhalten undefiniert.
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)

Inhaltsverzeichnis

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
(Funktions-Template)
(C++20)
erstellt eine Kopie eines umgekehrten Bereichs
(Algorithmus-Funktionsobjekt)