std::reverse_copy
From cppreference.com
| Defined in header <algorithm>
|
||
template< class BidirIt, class OutputIt >
OutputIt reverse_copy( BidirIt first, BidirIt last, OutputIt d_first );
|
(1) | (constexpr since C++20) |
template< class ExecutionPolicy, class BidirIt, class ForwardIt >
ForwardIt reverse_copy( ExecutionPolicy&& policy,
BidirIt first, BidirIt last, ForwardIt d_first );
|
(2) | (since C++17) |
1) Copies elements from the source range
[first, last) to the destination range beginning at d_first in reverse order.2) Same as (1), but executed according to
policy. This overload participates in overload resolution only if the value of the following expression is
true:
|
|
(until C++20) |
|
|
(since C++20) |
If the source and destination ranges overlap, the behavior is undefined.
Parameters
| first, last | - | the pair of iterators defining the source range |
| d_first | - | the beginning of the destination range |
| Type requirements | ||
-BidirIt must meet the requirements of LegacyBidirectionalIterator.
| ||
-OutputIt must meet the requirements of LegacyOutputIterator.
| ||
-ForwardIt must meet the requirements of LegacyForwardIterator.
| ||
Return value
The past-the-end iterator of the destination range.
Complexity
Exactly std::distance(first, last) assignments.
Exceptions
2) During the execution process:
- If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
- If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).
Notes
Implementations (e.g. MSVC STL) may enable vectorization when the both iterator types satisfy LegacyContiguousIterator and have the same value type, and the value type is TriviallyCopyable.
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_parallel_algorithm |
201603L |
(C++17) | Parallel algorithms, overload (2) |
Possible implementation
See also the implementations in libstdc++, libc++, and MSVC STL.
template<class BidirIt, class OutputIt>
constexpr // since C++20
OutputIt reverse_copy(BidirIt first, BidirIt last, OutputIt d_first)
{
for (; first != last; ++d_first)
*d_first = *(--last);
return d_first;
}
|
Example
Run this code
#include <algorithm>
#include <print>
#include <vector>
int main()
{
std::vector v{1, 2, 3};
std::print("{}\n", v);
std::vector<int> destination(3);
std::reverse_copy(std::begin(v), std::end(v), std::begin(destination));
std::print("{}\n", destination);
std::reverse_copy(std::rbegin(v), std::rend(v), std::begin(destination));
std::print("{}\n", destination);
}
Output:
[1, 2, 3]
[3, 2, 1]
[1, 2, 3]
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 2074 | C++98 | the actual copy destinations were misaligned with the destination range | corrected |
| LWG 2150 | C++98 | only one element was required to be assigned | corrected the requirement |
See also
(C++20) |
creates a copy of a range that is reversed (algorithm function object) |
| reverses the order of elements in a range (function template & algorithm function object) | |
(C++20) |
|
| a view that iterates over the elements of another bidirectional view in reverse order (class template) (range adaptor object) |