Difference between revisions of "cpp/utility/compare/partial order"
m (+/es) |
Andreas Krug (Talk | contribs) m (, -> .) |
||
| (5 intermediate revisions by 4 users not shown) | |||
| Line 13: | Line 13: | ||
requires /* see below */ | requires /* see below */ | ||
constexpr std::partial_ordering | constexpr std::partial_ordering | ||
| − | partial_order(T&& t, U&& u) noexcept(/* see below */); | + | partial_order( T&& t, U&& u ) noexcept(/* see below */); |
}} | }} | ||
{{dcl end}} | {{dcl end}} | ||
| − | Compares two values using 3-way comparison and produces a result of type {{ | + | Compares two values using 3-way comparison and produces a result of type {{rlpt|partial_ordering|std::partial_ordering}}. |
| − | Let {{ | + | Let {{c|t}} and {{c|u}} be expressions and {{tt|T}} and {{tt|U}} denote {{c/core|decltype((t))}} and {{c/core|decltype((u))}} respectively, {{c|std::partial_order(t, u)}} is [[cpp/language/expressions#Expression-equivalence|expression-equivalent]] to: |
| − | * If {{c| | + | * If {{c|std::is_same_v<std::decay_t<T>, std::decay_t<U>>}} is {{c|true}}: |
| − | ** {{c|std::partial_ordering(partial_order(t, u))}}, if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of {{tt| | + | ** {{c|std::partial_ordering(partial_order(t, u))}}, if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of {{tt|std::partial_order}}, |
| − | ** otherwise, {{c| | + | ** otherwise, {{c|std::partial_ordering(std::compare_three_way()(t, u))}}, if it is well-formed, |
| − | ** otherwise, {{c| | + | ** otherwise, {{c|std::partial_ordering(std::weak_order(t, u))}}, if it is well-formed. |
| − | * | + | * In all other cases, the expression is ill-formed, which can result in [[cpp/language/sfinae|substitution failure]] when it appears in the immediate context of a template instantiation. |
| − | + | ||
| − | |||
{{cpp/ranges/cpo|std}} | {{cpp/ranges/cpo|std}} | ||
| − | |||
| − | |||
===Example=== | ===Example=== | ||
| Line 37: | Line 33: | ||
===See also=== | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
| − | {{dsc inc | cpp/utility/compare/dsc partial_ordering}} | + | {{dsc inc|cpp/utility/compare/dsc partial_ordering}} |
| − | {{dsc inc | cpp/utility/compare/dsc strong_order}} | + | {{dsc inc|cpp/utility/compare/dsc strong_order}} |
| − | {{dsc inc | cpp/utility/compare/dsc weak_order}} | + | {{dsc inc|cpp/utility/compare/dsc weak_order}} |
| − | {{dsc inc | cpp/utility/compare/dsc compare_partial_order_fallback}} | + | {{dsc inc|cpp/utility/compare/dsc compare_partial_order_fallback}} |
{{dsc end}} | {{dsc end}} | ||
| − | {{langlinks|es|ja|zh}} | + | {{langlinks|de|es|ja|ru|zh}} |
Latest revision as of 09:38, 22 May 2023
| Defined in header <compare>
|
||
| inline namespace /* unspecified */ { inline constexpr /* unspecified */ partial_order = /* unspecified */; |
(since C++20) | |
| Call signature |
||
| template< class T, class U > requires /* see below */ |
||
Compares two values using 3-way comparison and produces a result of type std::partial_ordering.
Let t and u be expressions and T and U denote decltype((t)) and decltype((u)) respectively, std::partial_order(t, u) is expression-equivalent to:
- If std::is_same_v<std::decay_t<T>, std::decay_t<U>> is true:
- std::partial_ordering(partial_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::partial_order, - otherwise, std::partial_ordering(std::compare_three_way()(t, u)), if it is well-formed,
- otherwise, std::partial_ordering(std::weak_order(t, u)), if it is well-formed.
- std::partial_ordering(partial_order(t, u)), if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of
- 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.
Customization point objects
The name std::partial_order 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 __partial_order_fn.
All instances of __partial_order_fn are equal. The effects of invoking different instances of type __partial_order_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::partial_order 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::partial_order above, __partial_order_fn models
- std::invocable<__partial_order_fn, Args...>,
- std::invocable<const __partial_order_fn, Args...>,
- std::invocable<__partial_order_fn&, Args...>, and
- std::invocable<const __partial_order_fn&, Args...>.
Otherwise, no function call operator of __partial_order_fn participates in overload resolution.
[edit] Example
| This section is incomplete Reason: no example |
[edit] See also
| (C++20) |
the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values (class) |
| (C++20) |
performs 3-way comparison and produces a result of type std::strong_ordering(customization point object) |
| (C++20) |
performs 3-way comparison and produces a result of type std::weak_ordering(customization point object) |
performs 3-way comparison and produces a result of type std::partial_ordering, even if operator<=> is unavailable(customization point object) |
