home | help 
std::experi...ranges::less(3)  C++ Standard Libary std::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 invokes
     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 re-
     turn type).

	All specializations of less are Semiregular.

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

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& y)     (1)  (member  only
     of primary
	const;							   less<T>  tem-
     plate)
	template< class T, class U >

	    requires StrictTotallyOrderedWith<T, U> ||
		     /* std::declval<T>() < std::declval<U>()	   (member  only
     of less<void>
	resolves  to						(2)  specializa-
     tion)
			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::for-
     ward<U>(u);,
	except when that expression resolves to a call to  a  builtin  operator<
     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 argument
     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  im-
     posed 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	required
     to be
	stable:  two  evaluations  of such an expression with the same input ob-
     jects must have
	equal outputs absent any explicit intervening modification of those  in-
     put objects.

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

Example
	 This section is incomplete
	 Reason: no example

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

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::experi...ranges::less(3)
home | help