Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | utility
m (link to ja)
m (, -> .)
 
(9 intermediate revisions by 5 users not shown)
Line 2: Line 2:
 
{{cpp/utility/navbar}}
 
{{cpp/utility/navbar}}
 
{{dcl begin}}
 
{{dcl begin}}
−
{{dcl header | compare}}
+
{{dcl header|compare}}
−
{{dcl |since=c++20 |
+
{{dcl|since=c++20|1=
−
template< class T >
+
inline namespace /* unspecified */ {
−
constexpr std::partial_ordering partial_order(const T& a, const T& b);
+
    inline constexpr /* unspecified */ partial_order = /* unspecified */;
 +
}
 +
}}
 +
{{dcl h|Call signature}}
 +
{{dcl|1=
 +
template< class T, class U >
 +
    requires /* see below */
 +
constexpr std::partial_ordering
 +
    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 {{lc|std::partial_ordering}}
+
Compares two values using 3-way comparison and produces a result of type {{rlpt|partial_ordering|std::partial_ordering}}.
−
 
+
−
Specifically,
+
−
* If the expression {{c|a <{{=}}> b}} is well-formed and its result is convertible to {{lc|std::partial_ordering}}, returns that result.
+
−
* Otherwise, if the expression {{c|a <{{=}}> b}} is well-formed, but its result is not convertible to {{lc|std::partial_ordering}}, then the function is defined as deleted.
+
−
* Otherwise, if the expression {{c|a <{{=}}> b}} is ill-formed, but the expressions {{c|a {{==}} b}} and {{c|a < b}} are both well-formed and convertible to {{c|bool}},
+
−
:* if {{c|a {{==}} b}} is {{c|true}}, returns {{lc|std::partial_ordering::equivalent}}
+
−
:* otherwise, if {{c|a < b}} is {{c|true}}, returns {{lc|std::partial_ordering::less}}
+
−
:* otherwise, returns {{lc|std::partial_ordering::greater}}
+
−
* Otherwise, the function is defined as deleted.
+
−
 
+
−
===Parameters===
+
−
{{par begin}}
+
−
{{par | a, b | values to compare}}
+
−
{{par end}}
+
  
−
===Return value===
+
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:
−
A value of type {{lc|std::partial_ordering}}, as described above.
+
* 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|std::partial_order}},
 +
** otherwise, {{c|std::partial_ordering(std::compare_three_way()(t, u))}}, if it is well-formed,
 +
** 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.
  
−
===Notes===
+
{{cpp/ranges/cpo|std}}
  
 
===Example===
 
===Example===
Line 35: 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 weak_equal}}
+
{{dsc inc|cpp/utility/compare/dsc compare_partial_order_fallback}}
 
{{dsc end}}
 
{{dsc end}}
  
−
{{langlinks|ja|zh}}
+
{{langlinks|de|es|ja|ru|zh}}

Latest revision as of 09:38, 22 May 2023

 
C++
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
 
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 */
constexpr std::partial_ordering

    partial_order( T&& t, U&& u ) noexcept(/* 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:

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

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) [edit]
(C++20)
 performs 3-way comparison and produces a result of type std::strong_ordering
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::weak_ordering
(customization point object)[edit]
(C++20)
 performs 3-way comparison and produces a result of type std::partial_ordering, even if operator<=> is unavailable
(customization point object)[edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/compare/partial_order&oldid=152000"