Namespaces
Variants

std:: compare_strong_order_fallback

From cppreference.net
C++
Utilities library
Defined in header <compare>
inline namespace /* unspecified */ {

inline constexpr /* unspecified */
compare_strong_order_fallback = /* unspecified */ ;

}
(since C++20)
Call signature
template < class T, class U >

requires /* see below */
constexpr std:: strong_ordering

compare_strong_order_fallback ( T && t, U && u ) noexcept ( /* see below */ ) ;
(since C++20)

Performs three-way comparison on subexpressions t and u and produces a result of type std::strong_ordering , even if the operator <=> is unavailable.

If std:: decay_t < T > and std:: decay_t < U > are the same type, std :: compare_strong_order_fallback ( t, u ) is expression-equivalent to:

  • std:: strong_order ( t, u ) , if it is a well-formed expression;
  • otherwise, t == u ? std :: strong_ordering :: equal :
    t < u ? std :: strong_ordering :: less :
    std :: strong_ordering :: greater
if the expressions t == u and t < u are both well-formed and each of decltype ( t == u ) and decltype ( t < u ) models boolean-testable , except that t and u are evaluated only once.

In all other cases, std :: compare_strong_order_fallback ( t, u ) is ill-formed, which can result in substitution failure when it appears in the immediate context of a template instantiation.

Contents

Customization point objects

The name std::compare_strong_order_fallback denotes a customization point object , which is a const function object of a literal semiregular class type. See CustomizationPointObject for details.

Example

This section is incomplete
Reason: no example

Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 2114
( P2167R3 ) 		C++20 the fallback mechanism only required
return types to be convertible to bool 		constraints strengthened

See also

(C++20)
performs 3-way comparison and produces a result of type std::strong_ordering
(customization point object)