std::ranges::is_sorted

Defined in header `<algorithm>`
Call signature
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less > constexpr bool is_sorted( I first, S last, Comp comp = {}, Proj proj = {} );	(1)	(since C++20)
template< ranges::forward_range R, class Proj = std::identity, std::indirect_strict_weak_order< std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less > constexpr bool is_sorted( R&& r, Comp comp = {}, Proj proj = {} );	(2)	(since C++20)

Checks if the elements in range [first, last) are sorted in non-descending order.

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, std::invoke(comp, std::invoke(proj, *(it + n)), std::invoke(proj, *it)) evaluates to false.

1) Elements are compared using the given binary comparison function comp.

2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

The function-like entities described on this page are niebloids, that is:

Explicit template argument lists may not be specified when calling any of them.
None of them is visible to argument-dependent lookup.
When one of them is found by normal unqualified lookup for the name to the left of the function-call operator, it inhibits argument-dependent lookup.

In practice, they may be implemented as function objects, or with special compiler extensions.

Parameters

first, last	-	iterator-sentinel defining the range to check if it is sorted
r	-	the range to check if it is sorted
comp	-	comparison function to apply to the projected elements
proj	-	projection to apply to the elements

Return value

true if the elements in the range are sorted according to comp.

Complexity

Linear in the distance between first and last.

Possible implementation

struct is_sorted_fn {
  template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
           std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less>
  constexpr bool operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
  {
      return ranges::is_sorted_until(first, last, comp, proj) == last;
  }
 
  template<ranges::forward_range R, class Proj = std::identity,
           std::indirect_strict_weak_order<
               std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
  constexpr bool operator()(R&& r, Comp comp = {}, Proj proj = {}) const
  {
      return (*this)(ranges::begin(r), ranges::end(r),
                     std::ref(comp), std::ref(proj));
  }
};
 
inline constexpr is_sorted_fn is_sorted;

Notes

ranges::is_sorted returns true for empty ranges and ranges of length one.

Example

Run this code

#include <algorithm>
#include <iostream>
#include <iterator>
 
int main()
{
    namespace ranges = std::ranges;
 
    std::array digits {3, 1, 4, 1, 5};
 
    ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
    std::cout << ": is_sorted: " << std::boolalpha
              << ranges::is_sorted(digits) << '\n';
 
    ranges::sort(digits);
 
    ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
    std::cout << ": is_sorted: "
              << ranges::is_sorted(ranges::begin(digits), 
                                   ranges::end(digits)) << '\n';
}

Output:

3 1 4 1 5 : is_sorted: false
1 1 3 4 5 : is_sorted: true

Compiler support
Freestanding and hosted
Language
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

ranges::is_sorted_until (C++20)	finds the largest sorted subrange (niebloid)
is_sorted (C++11)	checks whether a range is sorted into ascending order (function template)