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,	/*com-
       pare-pred*/*
	  comp								    );
       (1)
	  void qsort( void *ptr, std::size_t count, std::size_t	size, /*c-com-
       pare-pred*/*
	  comp );
	  extern "C++" using /*compare-pred*/ =	int(const void*, const void*);
       //
	  exposition-only
       (2)
	  extern "C" using /*c-compare-pred*/ =	int(const void*, const void*);
       //
	  exposition-only

	  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 <iostream>
	#include <cstdlib>
	#include <climits>
	#include <compare>
	#include <array>

	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	<< ' ';
	}

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

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)

http://cppreference.com		  2022.07.31			 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.0>

home | help