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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::compare_three_way -	std::compare_three_way

Synopsis
	  Defined in header <compare>
	  Defined in header <functional>
	  struct compare_three_way;	  (since C++20)

	  Function  object  for	 performing comparisons. Deduces the parameter
       types and the
	  return type of the function call operator.

Member functions
	  operator() obtains the result	of three-way comparison	on both	 argu-
       ments
		     (public member function)

       std::compare_three_way::operator()

	  template< class T, class U >
	  constexpr auto operator()( T&& t, U&&	u ) const;

	  Given	 the  expression  std::forward<T>(t) <=> std::forward<U>(u) as
       expr:

	    * If expr results in a  call  to  built-in	operator<=>  comparing
       pointers, given the
	      composite	pointer	type of	t and u	as P:

	    * Compares the two converted pointers (of type P) in the implemen-
       tation-defined
	      strict total order over pointers:

	    * If t precedes u, returns std::strong_ordering::less.
	    * If u precedes t, returns std::strong_ordering::greater.
	    * Otherwise, returns std::strong_ordering::equal.
	    *  If  the	conversion  sequence from T to P or the	conversion se-
       quence from U to	P is
	      not equality-preserving, the behavior is undefined.
	    * Otherwise:

	    * Returns the result of expr.
	    * If std::three_way_comparable_with<T, U> is not modeled, the  be-
       havior is
	      undefined.

	  This overload	participates in	overload resolution only if
	  std::three_way_comparable_with<T, U> is satisfied.

Example
       // Run this code

	#include <compare>
	#include <iostream>

	struct Rational
	{
	    int	num;
	    int	den; //	> 0

	    // Although	the comparison X <=> Y will work, a direct call
	    // to std::compare_three_way{}(X, Y) requires the operator==
	    // be defined, to satisfy the std::three_way_comparable_with.
	    constexpr bool operator==(Rational const&) const = default;
	};

	constexpr std::weak_ordering operator<=>(Rational lhs, Rational	rhs)
	{
	    return lhs.num * rhs.den <=> rhs.num * lhs.den;
	}

	void print(std::weak_ordering value)
	{
	    value < 0 ?	std::cout << "less\n" :
	    value > 0 ?	std::cout << "greater\n" :
			std::cout << "equal\n";
	}

	int main()
	{
	    Rational a{6, 5};
	    Rational b{8, 7};
	    print(a <=>	b);
	    print(std::compare_three_way{}(a, b));
	}

Output:
	greater
	greater

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	   Applied to	    Behavior as	published	       Correct
       behavior
	  LWG  3530 C++20      syntactic checks	were relaxed	 only semantic
       requirements are
			      while comparing pointers		relaxed

See also
	  ranges::equal_to	constrained function object implementing x  ==
       y
	  (C++20)		(class)
	  ranges::not_equal_to	 constrained function object implementing x !=
       y
	  (C++20)		(class)
	  ranges::less		constrained function object implementing x < y
	  (C++20)		(class)
	  ranges::greater	constrained function object implementing x > y
	  (C++20)		(class)
	  ranges::less_equal	constrained function object implementing x  <=
       y
	  (C++20)		(class)
	  ranges::greater_equal	 constrained function object implementing x >=
       y
	  (C++20)		(class)

http://cppreference.com		  2024.06.10	     std::compare_three_way(3)

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

home | help