Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | utility
m (link to ja)
(describe as CPO)
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}}
Line 11: Line 19:
 
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 {{lc|std::partial_ordering}}
  
−
Specifically,
+
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::partial_order(t, u)}} is expression-equivalent to:
−
* If the expression {{c|a <{{=}}> b}} is well-formed and its result is convertible to {{lc|std::partial_ordering}}, returns that result.
+
* If {{c|1=std::is_same_v<std::decay_t<T>, std::decay_t<U>> == true}}:
−
* 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.
+
** {{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, 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}},
+
** otherwise {{c|1=std::partial_ordering(t <=> u)}}, if it is well-formed,
−
:* if {{c|a {{==}} b}} is {{c|true}}, returns {{lc|std::partial_ordering::equivalent}}
+
** otherwise {{c|1=std::partial_ordering(std::weak_order(t, u))}}, if it is well-formed,
−
:* otherwise, if {{c|a < b}} is {{c|true}}, returns {{lc|std::partial_ordering::less}}
+
** other 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.
−
:* otherwise, returns {{lc|std::partial_ordering::greater}}
+
* Otherwise, {{c|std::partial_order(t, u)}} is ill-formed.
−
* Otherwise, the function is defined as deleted.
+
−
 
+
−
===Parameters===
+
−
{{par begin}}
+
−
{{par | a, b | values to compare}}
+
−
{{par end}}
+
  
−
===Return value===
+
{{cpp/expr-eq}}
−
A value of type {{lc|std::partial_ordering}}, as described above.
+
{{cpp/ranges/cpo|std}}
  
 
===Notes===
 
===Notes===
Line 38: Line 40:
 
{{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|ja|zh}}

Revision as of 01:18, 6 September 2019

 
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:

Contents

Expression-equivalent

Expression e is expression-equivalent to expression f, if

  • e and f have the same effects, and
  • either both are constant subexpressions or else neither is a constant subexpression, and
  • either both are potentially-throwing or else neither is potentially-throwing (i.e. noexcept(e) == noexcept(f)).

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.

Notes

Example

This section is incomplete
Reason: no example

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=112716"