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

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...ranges::less(3) C++ Standard Libarystd::experi...ranges::less(3)

NAME
       std::experimental::ranges::less - std::experimental::ranges::less

Synopsis
	  Defined in header <experimental/ranges/functional>
	  template< class T = void >

	  requires StrictTotallyOrdered<T> ||
	  Same<T,			    void>			    ||
       (ranges TS)
	  /* < on two const T lvalues invokes a	built-in operator comparing
	  pointers */

	  struct less;
	  template							    <>
       (ranges TS)
	  struct less<void>;

	  Function object for performing comparisons. The primary template in-
       vokes operator<
	  on  const  lvalues  of type T. The specialization less<void> deduces
       the parameter
	  types	of the function	call operator from the arguments (but not  the
       return type).

	  All specializations of less are Semiregular.

Member types
	  Member type						    Definition
	  is_transparent (member only of less<void> specialization) /* unspec-
       ified */

Member functions
	  operator() checks if the first argument is less than the second
		     (public member function)

       std::experimental::ranges::less::operator()

	  constexpr bool operator()(const T& x,	const T&   (1) (member only of
       primary less<T>
	  y) const;					       template)
	  template< class T, class U >

	  requires StrictTotallyOrderedWith<T, U> ||
	  /* std::declval<T>() < std::declval<U>()	   (2) (member only of
       less<void>
	  resolves to					       specialization)
	  a built-in operator comparing	pointers */

	  constexpr bool operator()(T&&	t, U&& u) const;

	  1) Compares x	and y. Equivalent to return ranges::less<>{}(x,	y);
	  2)  Compares	t  and	u,  equivalent	to return std::forward<T>(t) <
       std::forward<U>(u);,
	  except when that expression resolves to a call to a  builtin	opera-
       tor< comparing
	  pointers.

	  When a call to (1) or	(2) would invoke a built-in operator comparing
       pointers	of
	  type P, the result is	instead	determined as follows:

	    *  Returns true if the (possibly converted)	value of the first ar-
       gument precedes
	      the (possibly converted) value of	the second argument in the
	      implementation-defined strict total ordering  over  all  pointer
       values of type P.
	      This  strict total ordering is consistent	with the partial order
       imposed by the
	      builtin operators	<, >, <=, and >=.
	    * Otherwise, returns false.

	  The behavior is undefined unless the conversion sequences from  both
       T and U to P are
	  equality-preserving (see below).

	 Equality preservation

	  An  expression is equality preserving	if it results in equal outputs
       given equal
	  inputs.

	    * The inputs to an expression consist of its operands.
	    * The outputs of an	expression  consist  of	 its  result  and  all
       operands	modified by
	      the expression (if any).

	  Every	 expression  required to be equality preserving	is further re-
       quired to be
	  stable: two evaluations of such an expression	with  the  same	 input
       objects must have
	  equal	 outputs absent	any explicit intervening modification of those
       input objects.

Notes
	  Unlike std::less, ranges::less requires all six comparison operators
       <, <=, >, >=,
	  == and != to be valid	(via the StrictTotallyOrdered and StrictTotal-
       lyOrderedWith
	  constraints).

Example
	   This	section	is incomplete
	   Reason: no example

See also
	  less function	object implementing x <	y
	       (class template)

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

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

home | help