std::strong_order(3)

NAME
std::strong_order - std::strong_order

Synopsis
   Defined in header <compare>
   inline namespace /* unspecified */ {
       inline constexpr /* unspecified */ strong_order = /* unspecified (since C++20)
   */;
   }
   Call signature
   template< class T, class U >
       requires /* see below */
   constexpr std::strong_ordering strong_order( T&& t, U&& u )
   noexcept(/* see below */);
   Compares two values using 3-way comparison and produces a result of type
   std::strong_ordering.
   Let t and u be expressions and T and U denote decltype((t)) and decltype((u))
   respectively, std::strong_order(t, u) is expression-equivalent to:
     * If std::is_same_v<std::decay_t<T>, std::decay_t<U>> is true:
          * std::strong_ordering(strong_order(t, u)), if it is a well-formed expression
            with overload resolution performed in a context that does not include a
            declaration of std::strong_order,
          * otherwise, if T is a floating-point type:
               * if std::numeric_limits<T>::is_iec559 is true, performs the
                 ISO/IEC/IEEE 60559 totalOrder comparison of floating-point values and
                 returns that result as a value of type std::strong_ordering (note:
                 this comparison can distinguish between the positive and negative zero
                 and between the NaNs with different representations),
               * otherwise, yields a value of type std::strong_ordering that is
                 consistent with the ordering observed by T's comparison operators,
          * otherwise, std::strong_ordering(std::compare_three_way()(t, u)) if it is
            well-formed.
     * In all other cases, the expression is ill-formed, which can result in
       substitution failure when it appears in the immediate context of a template
       instantiation.

Example
    This section is incomplete
    Reason: no example

See also
   strong_ordering the result type of 3-way comparison that supports all
   (C++20) 6 operators and is substitutable
                        (class)
   weak_order performs 3-way comparison and produces a result of
   (C++20) type std::weak_ordering
                        (customization point object)
   partial_order performs 3-way comparison and produces a result of
   (C++20) type std::partial_ordering
                        (customization point object)
                        performs 3-way comparison and produces a result of
   compare_strong_order_fallback type std::strong_ordering, even if operator<=> is
   (C++20) unavailable
                        (customization point object)

Category:
     * Todo no example