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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::less - std::less

Synopsis
	  Defined in header <functional>
	  template<>			  (since C++14)
	  class	less<void>;

	  std::less<>  is a specialization of std::less	with parameter and re-
       turn type deduced.

	 Implementation-defined	strict total order over	pointers

	  The function call operator yields the	implementation-defined	strict
       total order over
	  pointers if the < operator between arguments invokes a built-in com-
       parison operator
	  for a	pointer, even if the built-in <	operator does not.

	  The implementation-defined strict total order	is consistent with the
       partial order
	  imposed by built-in comparison operators (
	  <=>,
	  (since C++20)<, >, <=, and >=), and consistent among following stan-
       dard function
	  objects:

	    *	   std::less,	   std::greater,      std::less_equal,	   and
       std::greater_equal, when	the
	      template argument	is a pointer type or void

	    * std::ranges::equal_to, std::ranges::not_equal_to,
	      std::ranges::less,			 std::ranges::greater,
       std::ranges::less_equal,	 (since	C++20)
	      std::ranges::greater_equal, and std::compare_three_way

Member types
	  Member type	 Definition
	  is_transparent /* unspecified	*/

Member functions
	  operator() tests if the lhs compares less than rhs
		     (public member function)

       std::less<>::operator()

	  template< class T, class U>

	  constexpr auto operator()( T&& lhs, U&& rhs )	const

	  -> decltype(std::forward<T>(lhs) < std::forward<U>(rhs));

	  Returns the result of	std::forward<T>(lhs) < std::forward<U>(rhs).

Parameters
	  lhs, rhs - values to compare

Return value
	  The result of	std::forward<T>(lhs) < std::forward<U>(rhs).

	  If the comparison between both arguments resolves to a built-in com-
       parison operator
	  for a	pointer	type, the implementation-defined strict	total order is
       used for
	  comparison after converting both arguments to	pointers.

Exceptions
	  May throw implementation-defined exceptions.

Notes
	  The  member  type  is_transparent  indicates to the caller that this
       function	object is
	  a transparent	function object: it  accepts  arguments	 of  arbitrary
       types and uses
	  perfect  forwarding, which avoids unnecessary	copying	and conversion
       when the
	  function object is used in heterogeneous context, or with rvalue ar-
       guments.	In
	  particular,  template	  functions   such   as	  std::set::find   and
       std::set::lower_bound make
	  use of this member type on their Compare types.

Example
	   This	section	is incomplete
	   Reason: no example

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

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

home | help