From cppreference.com
Defined in header
Call signature
template<std::random_access_iteratorI,std::sentinel_for<I>S,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<I,Comp,Proj>constexprIsort(Ifirst,Slast,Compcomp={},Projproj={}); (1) (since C++20)template<ranges::random_access_rangeR,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<ranges::iterator_t<R>,Comp,Proj>constexprranges::borrowed_iterator_t<R>sort(R&&r,Compcomp={},Projproj={}); (2) (since C++20)template</*execution-policy*/Ep,std::random_access_iteratorI,std::sized_sentinel_for<I>S,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<I,Comp,Proj>Isort(Ep&&policy,Ifirst,Slast,Compcomp={},Projproj={}); (3) (since C++26)template</*execution-policy*/Ep,/*sized-random-access-range*/R,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<ranges::iterator_t<R>,Comp,Proj>ranges::borrowed_iterator_t<R>sort(Ep&&policy,R&&r,Compcomp={},Projproj={}); (4) (since C++26)For the definition of /*execution-policy*/, see
; for the definition of /*sized-random-access-range*/, see
.
1,2)
the elements in the target range [first, last) or r with respect to the comparator comp and projection proj. The order of equivalent elements is not guaranteed to be preserved.
3,4) Same as (1,2), but executed according to policy.
The function-like entities described on this page are
(informally known as niebloids), that is:
Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to
.
When any of them are found by
as the name to the left of the function-call operator,
is inhibited.
Parameters
first, last - the iterator-sentinel pair defining the target
r - the target range comp - the comparator to be applied to the (projected) elements proj - the projection to be applied to the elements policy - the
to use Return value
The past-the-end iterator of the target range.
Complexity
Given N as ranges::distance(first,last) or ranges::distance(r):
1-4)𝓞(N·log(N)) applications of comp and proj.
Exceptions
3,4) 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
uses
to swap elements, whereas ranges::sort instead uses
(which performs ADL for iter_swap, unlike
).
Possible implementation
Note that typical implementations use
. See also the implementation in
and
.
structsort_fn{template<std::random_access_iteratorI,std::sentinel_for<I>S,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<I,Comp,Proj>constexprIoperator()(Ifirst,Slast,Compcomp={},Projproj={})const{if(first==last)returnfirst;Ilast_iter=ranges::next(first,last);ranges::make_heap(first,last_iter,std::ref(comp),std::ref(proj));ranges::sort_heap(first,last_iter,std::ref(comp),std::ref(proj));returnlast_iter;}template<ranges::random_access_rangeR,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<ranges::iterator_t<R>,Comp,Proj>constexprranges::borrowed_iterator_t<R>operator()(R&&r,Compcomp={},Projproj={})const{return(*this)(ranges::begin(r),ranges::next(ranges::begin(r),ranges::end(r)),std::move(comp),std::move(proj));}};inlineconstexprsort_fnsort{};Example
Run this code
#include<algorithm>#include<array>#include<functional>#include<iomanip>#include<iostream>voidprint(autocomment,constauto&seq,charterm=' '){for(std::cout<<comment<<'\n';constauto&elem:seq)std::cout<<elem<<term;std::cout<<'\n';}structParticle{std::stringname;doublemass;// MeVtemplate<classOs>friendOs&operator<<(Os&os,constParticle&p){returnos<<std::left<<std::setw(8)<<p.name<<" : "<<p.mass<<' ';}};intmain(){std::arrays{5,7,4,2,8,6,1,9,0,3};namespaceranges=std::ranges;ranges::sort(s);print("Sort using the default operator<",s);ranges::sort(s,ranges::greater());print("Sort using a standard library compare function object",s);struct{booloperator()(inta,intb)const{returna<b;}}customLess;ranges::sort(s.begin(),s.end(),customLess);print("Sort using a custom function object",s);ranges::sort(s,[](inta,intb){returna>b;});print("Sort using a lambda expression",s);Particleparticles[]{{"Electron",0.511},{"Muon",105.66},{"Tau",1776.86},{"Positron",0.511},{"Proton",938.27},{"Neutron",939.57}};ranges::sort(particles,{},&Particle::name);print("\nSort by name using a projection",particles,'\n');ranges::sort(particles,{},&Particle::mass);print("Sort by mass using a projection",particles,'\n');}Output:
Sort using the default operator< 0 1 2 3 4 5 6 7 8 9 Sort using a standard library compare function object 9 8 7 6 5 4 3 2 1 0 Sort using a custom function object 0 1 2 3 4 5 6 7 8 9 Sort using a lambda expression 9 8 7 6 5 4 3 2 1 0 Sort by name using a projection Electron : 0.511 Muon : 105.66 Neutron : 939.57 Positron : 0.511 Proton : 938.27 Tau : 1776.86 Sort by mass using a projection Electron : 0.511 Positron : 0.511 Muon : 105.66 Proton : 938.27 Neutron : 939.57 Tau : 1776.86 See also
sorts a range of elements
(function template)
(C++20)
sorts the first N elements of a range
(algorithm function object)
(C++20)
sorts a range of elements while preserving relative order between equivalent elements
(algorithm function object)
(C++20)
divides a range of elements into two groups
(algorithm function object)
sorts the elements
(public member function of std::list<T,Allocator>)
sorts the elements
(public member function of std::forward_list<T,Allocator>)
sorts the elements
(public member function of std::hive<T,Allocator>)