| Defined in header <algorithm>
|
||
| template< class BidirIt > void reverse( BidirIt first, BidirIt last ); |
(1) | (constexpr since C++20) |
| template< class ExecutionPolicy, class BidirIt > void reverse( ExecutionPolicy&& policy, BidirIt first, BidirIt last ); |
(2) | (since C++17) |
[first, last).first + i and (last - i) - 1 for each integer i in [0, std::distance(first, last) / 2).policy.|
|
(until C++20) |
|
|
(since C++20) |
If *first is not Swappable(until C++20)BidirIt is not ValueSwappable(since C++20), the behavior is undefined.
Parameters
| first, last | - | the range of elements to reverse |
| policy | - | the execution policy to use |
| Type requirements | ||
BidirIt must meet the requirements of LegacyBidirectionalIterator.
| ||
Complexity
Exactly std::distance(first, last) / 2 swaps.
Exceptions
The overload with a template parameter named ExecutionPolicy reports errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicyis one of the standard policies, std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined. - If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Possible implementation
See also the implementations in libstdc++, libc++, and MSVC STL.
|
Notes
Implementations (e.g. MSVC STL) may enable vectorization when the iterator type satisfies LegacyContiguousIterator and swapping its value type calls neither non-trivial special member function nor ADL-found swap.
Example
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
void println(auto rem, auto const& v)
{
for (std::cout << rem; auto e : v)
std::cout << e << ' ';
std::cout << '\n';
}
int main()
{
std::vector<int> v {1, 2, 3};
std::reverse(v.begin(), v.end());
println("after reverse, v = ", v);
int a[] = {4, 5, 6, 7};
std::reverse(std::begin(a), std::end(a));
println("after reverse, a = ", a);
}after reverse, v = 3 2 1
after reverse, a = 7 6 5 4Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 223 | C++98 | std::swap was applied to each pair of iterators | applies std::iter_swap instead |
| LWG 2039 | C++98 | std::iter_swap was also applied when iequals std::distance(first, last) / 2
|
not applied |
See also
| creates a copy of a range that is reversed (function template) | |
| (C++20) |
reverses the order of elements in a range (algorithm function object) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.