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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::qsort - std::qsort

Synopsis
	  Defined in header <cstdlib>
	  void qsort( void *ptr, std::size_t count,

		      std::size_t size,	/* c-compare-pred */* comp );	(1)
	  void qsort( void *ptr, std::size_t count,

		      std::size_t size,	/* compare-pred	*/* comp );
	  extern "C" using /* c-compare-pred */	= int(const void*,
	  const	  void*);						   (2)
       (exposition only*)
	  extern "C++" using /*	compare-pred */	= int(const void*,
	  const	void*);

	  Sorts	the given array	pointed	to by ptr in ascending order. The  ar-
       ray contains count
	  elements  of size bytes. Function pointed to by comp is used for ob-
       ject comparison.

	  If comp indicates two	elements as equivalent,	their order is unspec-
       ified.

	  If the type of the elements of the array is not a
	  PODType
	  (until C++11)
	  TriviallyCopyable type
	  (since C++11), the behavior is undefined.

Parameters
	  ptr	- pointer to the array to sort
	  count	- number of elements in	the array
	  size	- size of each element in the array in bytes
		  comparison function which returns a negative	integer	 value
       if the first
		  argument  is	less than the second, a	positive integer value
       if the first
		  argument is greater than the second and zero	if  the	 argu-
       ments are
		  equivalent.

		  The  signature  of the comparison function should be equiva-
       lent to the
		  following:
	  comp	-
		   int cmp(const void *a, const	void *b);

		  The function must not	modify the objects passed  to  it  and
       must return
		  consistent results when called for the same objects, regard-
       less of their
		  positions in the array.

Return value
	  (none)

Notes
	  Despite  the	name,  C++, C, and POSIX standards do not require this
       function	to be
	  implemented using Quicksort or  make	any  complexity	 or  stability
       guarantees.

	  The  two overloads provided by the C++ standard library are distinct
       because the
	  types	of the parameter comp are distinct (language linkage  is  part
       of its type).

Example
	  The following	code sorts an array of integers	using qsort():

       // Run this code

	#include <array>
	#include <climits>
	#include <compare>
	#include <cstdlib>
	#include <iostream>

	int main()
	{
	    std::array a{-2, 99, 0, -743, INT_MAX, 2, INT_MIN, 4};

	    std::qsort
	    (
		a.data(),
		a.size(),
		sizeof(decltype(a)::value_type),
		[](const void* x, const	void* y)
		{
		    const int arg1 = *static_cast<const	int*>(x);
		    const int arg2 = *static_cast<const	int*>(y);
		    const auto cmp = arg1 <=> arg2;
		    if (cmp < 0)
			return -1;
		    if (cmp > 0)
			return 1;
		    return 0;
		}
	    );

	    for	(int ai	: a)
		std::cout << ai	<< ' ';
	    std::cout << '\n';
	}

Output:
	-2147483648 -743 -2 0 2	4 99 2147483647

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	    DR	      Applied	 to		   Behavior    as    published
       Correct behavior
	  LWG 405 C++98	     the elements of the array	could  have  any  type
       limited to PODType

See also
	  bsearch    searches an array for an element of unspecified type
		     (function)
	  sort	     sorts a range into	ascending order
		     (function template)
	  is_trivial checks if a type is trivial
	  (C++11)    (class template)
	  C documentation for
	  qsort

http://cppreference.com		  2024.06.10			 std::qsort(3)

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

home | help