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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::partial_ordering - std::partial_ordering

Synopsis
	  Defined in header <compare>
	  class	partial_ordering;      (since C++20)

	  The  class type std::partial_ordering	is the result type of a	three-
       way comparison
	  that

	    * admits all six relational	operators (==, !=, <, <=, >, >=)

	    * does not imply substitutability: if a is equivalent to  b,  f(a)
       may not be
	      equivalent to f(b), where	f denotes a function that reads	only
	      comparison-salient  state	 that is accessible via	the argument's
       public const
	      members. In other	words, equivalent values may  be  distinguish-
       able.
	    *  admits incomparable values: a < b, a == b, and a	> b may	all be
       false

Constants
	  The type std::partial_ordering has four valid	values,	implemented as
       const static
	  data members of its type:

	  Member constant	       Definition
	  less(inline constexpr)       a valid value  of  the  type  std::par-
       tial_ordering
	  [static]			indicating  less-than (ordered before)
       relationship
				       (public static member constant)
				       a valid value  of  the  type  std::par-
       tial_ordering
	  equivalent(inline constexpr) indicating equivalence (neither ordered
       before nor
	  [static]		       ordered after)
				       (public static member constant)
	  greater(inline  constexpr)	 a  valid  value of the	type std::par-
       tial_ordering
	  [static]		       indicating greater-than (ordered	after)
       relationship
				       (public static member constant)
	  unordered(inline constexpr)  a valid value  of  the  type  std::par-
       tial_ordering
	  [static]			indicating relationship	with an	incom-
       parable value
				       (public static member constant)

Conversions
	  std::partial_ordering	cannot be implicitly converted to  other  com-
       parison category
	  types, while both std::strong_ordering and std::weak_ordering	are
	  implicitly-convertible to partial_ordering.

Comparisons
	  Comparison  operators	 are  defined  between values of this type and
       literal 0.
	  This supports	the expressions	a <=> b	== 0 or	a <=> b	< 0  that  can
       be used to
	  convert  the	result of a three-way comparison operator to a boolean
       relationship; see
	  std::is_eq, std::is_lt, etc.

	  These	functions are not visible to ordinary unqualified or qualified
       lookup, and can
	  only be found	by argument-dependent lookup when  std::partial_order-
       ing is an
	  associated class of the arguments.

	  The  behavior	of a program that attempts to compare a	partial_order-
       ing with	anything
	  other	than the integer literal 0 is undefined.

	  operator==
	  operator<
	  operator>   compares with zero or a partial_ordering
	  operator<=  (function)
	  operator>=
	  operator<=>

       operator==

	  friend constexpr bool	 operator==(  partial_ordering	v,  /*unspeci-
       fied*/ u	)	(1)
	  noexcept;
	  friend			 constexpr			  bool
       (2)
	  operator==( partial_ordering v, partial_ordering w ) noexcept	=  de-
       fault;

Parameters
	  v, w - std::partial_ordering values to check
	  u    - an unused parameter of	any type that accepts literal zero ar-
       gument

Return value
	  1)  true  if	v  is  equivalent, false if v is less, greater,	or un-
       ordered
	  2) true if both parameters hold the same value, false	otherwise

       operator<

	  friend constexpr bool	operator<( partial_ordering v, /*unspecified*/
       u )	  (1)
	  noexcept;
	  friend constexpr bool	operator<( /*unspecified*/ u, partial_ordering
       v )	  (2)
	  noexcept;

Parameters
	  v - a	std::partial_ordering value to check
	  u - an unused	parameter of any type that accepts literal zero	 argu-
       ment

Return value
	  1)  true if v	is less, and false if v	is greater, equivalent,	or un-
       ordered
	  2) true if v is greater, and false if	v is less, equivalent, or  un-
       ordered

       operator<=

	  friend  constexpr  bool  operator<=(	partial_ordering v, /*unspeci-
       fied*/ u	)	(1)
	  noexcept;
	  friend constexpr bool	operator<=( /*unspecified*/ u,	partial_order-
       ing v )	     (2)
	  noexcept;

Parameters
	  v - a	std::partial_ordering value to check
	  u  - an unused parameter of any type that accepts literal zero argu-
       ment

Return value
	  1) true if v is less or equivalent, and false	if v is	greater	or un-
       ordered
	  2) true if v is greater or equivalent, and false if v	is less	or un-
       ordered

       operator>

	  friend constexpr bool	operator>( partial_ordering v, /*unspecified*/
       u )	  (1)
	  noexcept;
	  friend constexpr bool	operator>( /*unspecified*/ u, partial_ordering
       v )	  (2)
	  noexcept;

Parameters
	  v - a	std::partial_ordering value to check
	  u - an unused	parameter of any type that accepts literal zero	 argu-
       ment

Return value
	  1)  true if v	is greater, and	false if v is less, equivalent,	or un-
       ordered
	  2) true if v is less,	and false if v is greater, equivalent, or  un-
       ordered

       operator>=

	  friend  constexpr  bool  operator>=(	partial_ordering v, /*unspeci-
       fied*/ u	)	(1)
	  noexcept;
	  friend constexpr bool	operator>=( /*unspecified*/ u,	partial_order-
       ing v )	     (2)
	  noexcept;

Parameters
	  v - a	std::partial_ordering value to check
	  u  - an unused parameter of any type that accepts literal zero argu-
       ment

Return value
	  1) true if v is greater or equivalent, and false if v	is less	or un-
       ordered
	  2) true if v is less or equivalent, and false	if v is	greater	or un-
       ordered

       operator<=>

	  friend constexpr partial_ordering operator<=>(  partial_ordering  v,
       (1)
	  /*unspecified*/ u ) noexcept;
	  friend  constexpr  partial_ordering  operator<=>( /*unspecified*/ u,
       (2)
	  partial_ordering v ) noexcept;

Parameters
	  v - a	std::partial_ordering value to check
	  u - an unused	parameter of any type that accepts literal zero	 argu-
       ment

Return value
	  1) v.
	  2) greater if	v is less, less	if v is	greater, otherwise v.

Notes
	  The built-in operator<=> between floating-point values uses this or-
       dering: the
	  positive  zero  and the negative zero	compare	equivalent, but	can be
       distinguished,
	  and NaN values compare unordered with	any other value.

Example
	   This	section	is incomplete
	   Reason: no example

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

http://cppreference.com		  2022.07.31	      std::partial_ordering(3)

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

home | help