home | help 
std::experi...eater_equal(3)   C++ Standard Libary  std::experi...eater_equal(3)

NAME
     std::experimental::ranges::greater_equal	       -	 std::experimen-
     tal::ranges::greater_equal

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 greater_equal;
	template<>
     (ranges TS)
	struct greater_equal<void>;

	Function object for performing comparisons. The primary template invokes
     operator<
	on const lvalues of type T and negates the result. The specialization
	greater_equal<void> deduces the parameter types of the function call op-
     erator from
	the arguments (but not the return type).

	All specializations of greater_equal are Semiregular.

Member types
	Member type							   Defi-
     nition
	is_transparent	(member  only  of greater_equal<void> specialization) /*
     unspecified */

Member functions
	operator() checks if the first argument is greater than or equal to  the
     second
		   (public member function)

     std::experimental::ranges::greater_equal::operator()

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

	    requires StrictTotallyOrderedWith<T, U> ||
		     /* std::declval<T>() <			 (member only of
	std::declval<U>()	resolves      to			     (2)
     greater_equal<void>
			a built-in operator comparing		 specialization)
	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  !ranges::less<>{}(std::for-
     ward<T>(t),
	std::forward<U>(u));.

Notes
	Unlike	std::greater_equal,  ranges::greater_equal requires all six com-
     parison
	operators <, <=, >, >=, == and != to be valid  (via  the  StrictTotally-
     Ordered and
	StrictTotallyOrderedWith  constraints)	and is entirely defined in terms
     of
	ranges::less. However, the implementation is free to use operator>=  di-
     rectly,
	because  those	concepts require the results of the comparison operators
     to be
	consistent.

Example
	 This section is incomplete
	 Reason: no example

See also
	greater_equal function object implementing x >= y
		      (class template)

Category:
	  * Todo no example

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