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.
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 <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);
}
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) |