Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/utility/compare/compare partial order fallback"

From cppreference.com
< cpp‎ | utility
m (+/es)
m (Uses {{c multi}}.)
 
(6 intermediate revisions by 4 users not shown)
Line 10: Line 10:
 
}}
 
}}
 
{{dcl h|Call signature}}
 
{{dcl h|Call signature}}
−
{{dcl|1=
+
{{dcl|since=c++20|1=
 
template< class T, class U >
 
template< class T, class U >
 
     requires /* see below */
 
     requires /* see below */
 
constexpr std::partial_ordering
 
constexpr std::partial_ordering
−
     compare_partial_order_fallback(T&& t, U&& u) noexcept(/* see below */);
+
     compare_partial_order_fallback( T&& t, U&& u ) noexcept(/* see below */);
 
}}
 
}}
 
{{dcl end}}
 
{{dcl end}}
  
−
Performs three-way comparison on {{tt|t}} and {{tt|u}} and produces a result of type {{lc|std::partial_ordering}}, even if the operator {{tt|1=<=>}} is unavailable.
+
Performs three-way comparison on [[cpp/language/expressions#Full-expressions|subexpressions]] {{c|t}} and {{c|u}} and produces a result of type {{ltt std|cpp/utility/compare/partial_ordering}}, even if the operator {{tt|1=<=>}} is unavailable.
  
−
Let {{tt|t}} and {{tt|u}} be expressions and {{tt|T}} and {{tt|U}} denote {{c|decltype((t))}} and {{c|decltype((u))}} respectively, {{c|std::compare_partial_order_fallback(t, u)}} is expression-equivalent to:
+
If {{c/core|std::decay_t<T>}} and {{c/core|std::decay_t<U>>}} are the same type, {{c|std::compare_partial_order_fallback(t, u)}} is [[cpp/language/expressions#Expression-equivalence|expression-equivalent]] to:
−
* If {{c|1=std::is_same_v<std::decay_t<T>, std::decay_t<U>> == true}}:
+
* {{c|std::partial_order(t, u)}}, if it is a well-formed expression;
−
** the expression is expression-equivalent to {{c|std::partial_order(t, u)}}, if it is a well-formed expression;
+
* otherwise, {{c multi
−
** otherwise, if {{c|1=t == u}} and {{c|t < u}} are both well-formed and convertible to {{c|bool}}, the expression is expression-equivalent to
+
|1=t == u ? std::partial_ordering::equivalent :
−
{{source|1=
+
|2=t < u  ? std::partial_ordering::less :
−
t == u ? std::partial_ordering::equivalent :
+
|3=u < t  ? std::partial_ordering::greater :
−
t < u  ? std::partial_ordering::less :
+
|4=         std::partial_ordering::unordered
−
u < t  ? std::partial_ordering::greater :
+
−
        std::partial_ordering::unordered
+
 
}}
 
}}
−
:: except that {{tt|t}} and {{tt|u}} are evaluated only once.
+
: if the expressions {{c|1=t == u}}, {{c|t < u}} and {{c|u < t}} are all well-formed and each of {{c/core|1=decltype(t == u)}} and {{c/core|decltype(t < u)}} models {{lti|cpp/concepts/boolean-testable}}, except that {{c|t}} and {{c|u}} are evaluated only once.
−
* In all other cases, {{c|std::compare_partial_order_fallback(t, u)}} is ill-formed.
+
 
 +
In all other cases, {{c|std::compare_partial_order_fallback(t, u)}} is ill-formed, which can result in [[cpp/language/sfinae|substitution failure]] when it appears in the immediate context of a template instantiation.
  
−
{{cpp/expr-eq}}
 
 
{{cpp/ranges/cpo|std}}
 
{{cpp/ranges/cpo|std}}
  
 
===Example===
 
===Example===
 
{{example}}
 
{{example}}
 +
 +
===Defect reports===
 +
{{dr list begin}}
 +
{{dr list item|wg=lwg|dr=2114|paper=P2167R3|std=C++20|before=the fallback mechanism only required<br>return types to be convertible to {{c/core|bool}}|after=constraints strengthened}}
 +
{{dr list item|wg=lwg|dr=3465|std=C++20|before=the fallback mechanism did not require {{c|u < t}} to be well-formed|after=required}}
 +
{{dr list end}}
  
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/utility/compare/dsc partial_order}}
+
{{dsc inc|cpp/utility/compare/dsc partial_order}}
 
{{dsc end}}
 
{{dsc end}}
  
−
{{langlinks|es|ja|zh}}
+
{{langlinks|de|es|ja|ru|zh}}

Latest revision as of 22:54, 4 May 2023

 
C++
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
 
Defined in header <compare>
inline namespace /* unspecified */ {

    inline constexpr /* unspecified */
        compare_partial_order_fallback = /* unspecified */;

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

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

    compare_partial_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::partial_ordering, even if the operator <=> is unavailable.

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

  • std::partial_order(t, u), if it is a well-formed expression;
  • otherwise, t == u ? std::partial_ordering::equivalent :
    t < u  ? std::partial_ordering::less :
    u < t  ? std::partial_ordering::greater :
             std::partial_ordering::unordered
if the expressions t == u, t < u and u < t are all 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_partial_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_partial_order_fallback denotes a customization point object, which is a const function object of a literal semiregular class type. For exposition purposes, the cv-unqualified version of its type is denoted as __compare_partial_order_fallback_fn.

All instances of __compare_partial_order_fallback_fn are equal. The effects of invoking different instances of type __compare_partial_order_fallback_fn on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, std::compare_partial_order_fallback can be copied freely and its copies can be used interchangeably.

Given a set of types Args..., if std::declval<Args>()... meet the requirements for arguments to std::compare_partial_order_fallback above, __compare_partial_order_fallback_fn models

Otherwise, no function call operator of __compare_partial_order_fallback_fn participates in overload resolution.

[edit] Example

This section is incomplete
Reason: no example

[edit] 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
LWG 3465 C++20 the fallback mechanism did not require u < t to be well-formed required

[edit] See also

(C++20)
 performs 3-way comparison and produces a result of type std::partial_ordering
(customization point object)[edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/compare/compare_partial_order_fallback&oldid=151375"