std::sort - cppreference.com

From cppreference.com

<algorithm>

Defined in header

(1)

template

class

RandomIt

void

sort

(

RandomIt first, RandomIt last

)

;

(until C++20)

template

class

RandomIt

constexpr

void

sort

(

RandomIt first, RandomIt last

)

;

(since C++20)

template

class

ExecutionPolicy,

class

RandomIt

ExecutionPolicy,RandomIt

void sort( ExecutionPolicy&& policy,

RandomIt first, RandomIt last

)

;

RandomIt first, RandomIt last

(2)

(since C++17)

(3)

template

class

RandomIt,

class

Compare

void

sort

(

RandomIt first, RandomIt last, Compare comp

)

;

(until C++20)

template

class

RandomIt,

class

Compare

constexpr

void

sort

(

RandomIt first, RandomIt last, Compare comp

)

;

(since C++20)

template

class

ExecutionPolicy,

class

RandomIt,

class

Compare

ExecutionPolicy,RandomIt,Compare

void sort( ExecutionPolicy&& policy,

RandomIt first, RandomIt last, Compare comp

)

;

RandomIt first, RandomIt last, Compare comp

(4)

(since C++17)

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is not guaranteed to be preserved.

A sequence is sorted with respect to a comparator comp if for any iterator it pointing to the sequence and any non-negative integer n such that it + n is a valid iterator pointing to an element of the sequence, comp(*(it + n), *it) (or *(it + n) < *it) evaluates to false.

Elements are compared using operator<.

Elements are compared using the given binary comparison function comp.

2,4)

Same as

(1,3)

, but executed according to policy. These overloads do not participate in overload resolution unless

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)

Same as, but executed according to. These overloads do not participate in overload resolution unlessis true.

Tóm Tắt

edit]

Parameters

first, last

–

the range of elements to sort

policy

–

the execution policy to use. See execution policy for details.

comp

–

comparison function object (i.e. an object that satisfies the requirements of

Compare

) which returns

true

if the first argument is less than (i.e. is ordered before) the second.

The signature of the comparison function should be equivalent to the following:

bool cmp(const Type1 &a, const Type2 &b);

While the signature does not need to have const &, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) Type1 and Type2 regardless of value category (thus, Type1 & is not allowed, nor is Type1 unless for Type1 a move is equivalent to a copy (since C++11)).
The types Type1 and Type2 must be such that an object of type RandomIt can be dereferenced and then implicitly converted to both of them.

Type requirements

–

RandomIt must meet the requirements of

ValueSwappable

and

LegacyRandomAccessIterator

–

The type of dereferenced RandomIt must meet the requirements of

MoveAssignable

and

MoveConstructible

–

Compare must meet the requirements of

Compare

edit]

Return value

(none)

edit]

Complexity

O(N·log(N)), where N = std::distance(first, last) comparisons on average.

(until C++11)

O(N·log(N)), where N = std::distance(first, last) comparisons.

(since C++11)

edit]

Exceptions

The overloads with a template parameter named ExecutionPolicy report errors as follows:

If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicy is one of the standard policies, std::terminateExecutionPolicy, the behavior is implementation-defined.
If the algorithm fails to allocate memory, std::bad_alloc

edit]

Possible implementation

See also the implementations in libstdc++ and libc++.

edit]

Example

Run this code

#include <algorithm>
#include <functional>
#include <array>
#include <iostream>
#include <string_view>
 
int
 main(
)
{
    std::
array
<
int
, 10
>
 s =
 {
5
, 7
, 4
, 2
, 8
, 6
, 1
, 9
, 0
, 3
}
;
 
    auto
 print =
 [
&
s]
(
std::
string_view
 const
 rem)
 {
        for
 (
auto
 a :
 s)
 {
            std::
cout
 <<
 a <<
 ' '
;
        }
        std::
cout
 <<
 ": "
 <<
 rem <<
 '
\n
';
    }
;
 
    std::
sort
(
s.begin
(
)
, s.end
(
)
)
;
    print(
"sorted with the default operator<"
)
;
 
    std::
sort
(
s.begin
(
)
, s.end
(
)
, std::
greater
<
int
>
(
)
)
;
    print(
"sorted with the standard library compare function object"
)
;
 
    struct
 {
        bool
 operator(
)
(
int
 a, int
 b)
 const
 {
 return
 a <
 b;
 }
    }
 customLess;
    std::
sort
(
s.begin
(
)
, s.end
(
)
, customLess)
;
    print(
"sorted with a custom function object"
)
;
 
    std::
sort
(
s.begin
(
)
, s.end
(
)
, [
]
(
int
 a, int
 b)
 {
        return
 a >
 b;
    }
)
;
    print(
"sorted with a lambda expression"
)
;
}

Output:

0 1 2 3 4 5 6 7 8 9 : sorted with the default operator<
9 8 7 6 5 4 3 2 1 0 : sorted with the standard library compare function object
0 1 2 3 4 5 6 7 8 9 : sorted with a custom function object
9 8 7 6 5 4 3 2 1 0 : sorted with a lambda expression

std::sort – cppreference.com

edit]

edit]

edit]

edit]

edit]

edit]

edit]

mtoplist