From cppreference.com
Defined in header
template<classBidirIt>voidreverse(BidirItfirst,BidirItlast); (1)(constexpr since C++20)template<classExecutionPolicy,classBidirIt>voidreverse(ExecutionPolicy&&policy,BidirItfirst,BidirItlast); (2) (since C++17)1) Reverses the order of the elements in the target range [first, last) by swapping each pair of corresponding elements using
.
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:
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
(until C++20)std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
(since C++20)If *first is not
(until C++20)BidirIt is not
(since C++20), the behavior is undefined.
Parameters
first, last - the pair of iterators defining the target
policy - the
to use Type requirements -BidirIt must meet the requirements of
. Complexity
Exactly std::distance(first,last)/2 swaps.
Exceptions
2) During the execution process:
If the temporary memory resources required for parallelization are not available,
is thrown.
If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for
,
is invoked).
Notes
Implementations (e.g.
) may enable vectorization when the iterator type satisfies
and swapping its value type calls neither non-trivial special member function nor
-found swap.
Possible implementation
See also the implementations in
,
, and
.
template<classBidirIt>constexpr// since C++20voidreverse(BidirItfirst,BidirItlast){usingiter_cat=typenamestd::iterator_traits<BidirIt>::iterator_category;// Tag dispatch, e.g. calling reverse_impl(first, last, iter_cat()),// can be used in C++14 and earlier modes.ifconstexpr(std::is_base_of_v<std::random_access_iterator_tag,iter_cat>){if(first==last)return;for(--last;first<last;(void)++first,--last)std::iter_swap(first,last);}elsewhile(first!=last&&first!=--last)std::iter_swap(first++,last);}Example
Run this code
#include<algorithm>#include<iterator>#include<print>#include<vector>intmain(){std::vector<int>v{1,2,3};std::println("before reverse, v = {}",v);std::reverse(v.begin(),v.end());std::println("after reverse, v = {}",v);inta[]={4,5,6,7};std::println("before reverse, a = {}",a);std::reverse(std::begin(a),std::end(a));std::println("after reverse, a = {}",a);}Output:
before reverse, v = [1, 2, 3] after reverse, v = [3, 2, 1] before reverse, a = [4, 5, 6, 7] after reverse, a = [7, 6, 5, 4] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR Applied to Behavior as published Correct behavior
C++98
was applied to each pair of iterators applies
instead
C++98
applied
std::distance(first,last)/2+1 times only applied
std::distance(first,last)/2 times See also