Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::is_sorted(3)	      C++ Standard Libary	     std::is_sorted(3)

NAME
       std::is_sorted -	std::is_sorted

Synopsis
	  Defined in header <algorithm>
	  template<   class  ForwardIt	>				(since
       C++11)
	  bool is_sorted(  ForwardIt  first,  ForwardIt	 last		(until
       C++20)
	  );
	  template< class ForwardIt >
	  constexpr  bool  is_sorted(  ForwardIt  first,		(since
       C++20)
	  ForwardIt last );
	  template< class ExecutionPolicy, class ForwardIt
	  >							 (2)	(since
       C++17)
	  bool is_sorted( ExecutionPolicy&& policy,
	  ForwardIt first, ForwardIt last );
	  template<	  class	     ForwardIt,	     class	Compare	     >
       (since C++11)
	  bool	 is_sorted(   ForwardIt	   first,    ForwardIt	  last,	   (1)
       (until C++20)
	  Compare comp );
	  template< class ForwardIt, class Compare >
	  constexpr	   bool	       is_sorted(	ForwardIt	first,
       (since C++20)
	  ForwardIt last, Compare comp );
	  template< class ExecutionPolicy, class	       (3)
	  ForwardIt, class Compare >

	  bool	 is_sorted(   ExecutionPolicy&&	  policy,		   (4)
       (since C++17)
	  ForwardIt first, ForwardIt last,

	  Compare comp );

	  Checks  if the elements in range [first, last) are sorted in non-de-
       scending	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, comp(*(it + n),
       *it) evaluates to
	  false.

	  1) Elements are compared using operator<.
	  3) Elements are compared using the given binary comparison  function
       comp.
	  2,4)	Same  as  (1,3), but executed according	to policy. These over-
       loads 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)	is true.

Parameters
	  first, last -	the range of elements to examine.
	  policy      -	the execution policy to	use. See execution policy  for
       details.
			comparison function object (i.e. an object that	satis-
       fies 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);
	  comp	      -
			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  re-
       gardless	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
			ForwardIt can be dereferenced and then implicitly con-
       verted to both of
			them.

Type requirements
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.

Return value
	  true	if  the	elements in the	range are sorted in non-descending or-
       der.

Complexity
	  Linear in the	distance between first and last.

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::termi-
       nate is called.
	      For  any	other ExecutionPolicy, 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++ and	libc++.

First version
	  template<class ForwardIt>
	  bool is_sorted(ForwardIt first, ForwardIt last)
	  {
	      return std::is_sorted_until(first, last) == last;
	  }

Second version
	  template<class ForwardIt, class Compare>
	  bool is_sorted(ForwardIt first, ForwardIt last, Compare comp)
	  {
	      return std::is_sorted_until(first, last, comp) ==	last;
	  }

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

Example
       // Run this code

	#include <iostream>
	#include <algorithm>
	#include <iterator>
	int main()
	{
	    int	digits[] = {3, 1, 4, 1,	5};

	    for	(auto i	: digits) std::cout << i << ' ';
	    std::cout << ": is_sorted: " << std::boolalpha
		      << std::is_sorted(std::begin(digits),  std::end(digits))
       << '\n';

	    std::sort(std::begin(digits), std::end(digits));

	    for	(auto i	: digits) std::cout << i << ' ';
	    std::cout << ": is_sorted: "
		      <<  std::is_sorted(std::begin(digits), std::end(digits))
       << '\n';
	}

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

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

http://cppreference.com		  2022.07.31		     std::is_sorted(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::is_sorted&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help