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

FreeBSD Manual Pages

  
 
  

home | help 
std::compar...e_way_result(3) C++ Standard Libarystd::compar...e_way_result(3)

NAME
       std::compare_three_way_result - std::compare_three_way_result

Synopsis
	  Defined in header <compare>
	  template<class T, class U = T>    (since C++20)
	  struct compare_three_way_result;

	  Let  t  and  u denote	lvalue of const	std::remove_reference_t<T> and
       const
	  std::remove_reference_t<U> respectively, if the expression t	<=>  u
       is well-formed,
	  provides  the	member typedef type equal to decltype(t	<=> u),	other-
       wise there is no
	  member type.

	  The behavior	of  a  program	that  adds  specializations  for  com-
       pare_three_way_result is
	  undefined.

Member types
	  Name Definition
	  type	the  result type of operator<=>	on const-qualified lvalue of T
       and U

Helper types
	  template<class T, class U = T>
	  using		compare_three_way_result_t	   =	      typename
       (since C++20)
	  compare_three_way_result<T, U>::type;

Possible implementation
	  // recommended by Casey Carter
	  //   see   also:   https://github.com/microsoft/STL/pull/385#discus-
       sion_r357894054
	  template<class T, class U = T>
	  using	compare_three_way_result_t = decltype(
	      std::declval<const std::remove_reference_t<T>&>()	<=>
	      std::declval<const std::remove_reference_t<U>&>()
	  );

	  template<class T, class U = T>
	  struct compare_three_way_result {};

	  template<class T, class U>
	      requires requires	{ typename compare_three_way_result_t<T, U>; }
	  struct compare_three_way_result<T, U>	{
	      using type = compare_three_way_result_t<T, U>;
	  };

Example
       // Run this code

	#include <compare>
	#include <type_traits>
	#include <iostream>

	template <class	Ord>
	void print_cmp_type()
	{
	    if constexpr (std::is_same_v<Ord, std::strong_ordering>)
		std::cout << "strong ordering\n";
	    else if constexpr (std::is_same_v<Ord, std::weak_ordering>)
		std::cout << "weak ordering\n";
	    else if constexpr (std::is_same_v<Ord, std::partial_ordering>)
		std::cout << "partial ordering\n";
	    else
		std::cout << "illegal comparison result	type\n";
	}

	int main()
	{
	    print_cmp_type<std::compare_three_way_result_t<int>>();
	    print_cmp_type<std::compare_three_way_result_t<double>>();
	}

Output:
	strong ordering
	partial	ordering

See also
	  partial_ordering the result type of 3-way comparison	that  supports
       all 6 operators,
	  (C++20)	    is not substitutable, and allows incomparable val-
       ues
			   (class)
	  weak_ordering	   the result type of 3-way comparison	that  supports
       all 6 operators
	  (C++20)	   and is not substitutable
			   (class)
	  strong_ordering   the	 result	type of	3-way comparison that supports
       all 6 operators
	  (C++20)	   and is substitutable
			   (class)

http://cppreference.com		  2022.07.31	 std::compar...e_way_result(3)

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

home | help