Difference between revisions of "cpp/utility/compare/compare three way"
(P1614R2) |
(→See also: +) |
||
| Line 107: | Line 107: | ||
===See also=== | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc strong_order}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc weak_order}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc partial_order}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc compare_strong_order_fallback}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc compare_weak_order_fallback}} | ||
| + | {{dsc inc | cpp/utility/compare/dsc compare_partial_order_fallback}} | ||
{{dsc end}} | {{dsc end}} | ||
{{langlinks|ja|zh}} | {{langlinks|ja|zh}} | ||
Revision as of 19:45, 2 September 2019
| Defined in header <compare>
|
||
| struct compare_three_way; |
(since C++20) | |
Function object for performing comparisons. Deduces the parameter types of the function call operator from the arguments (but not the return type).
Contents |
Member types
| Member type | Definition |
is_transparent
|
/* unspecified */ |
Member functions
| operator() |
obtains the result of three-way comparison on both arguments (public member function) |
std::compare_three_way::operator()
| template<class T, class U> requires three_way_comparable_with<T, U> || |
||
Compares t and u, equivalent to return std::forward<T>(t) <=> std::forward<U>(u);, except when that expression resolves to a call to a builtin operator<=> comparing pointers.
When a call would invoke a built-in operator comparing pointers of type P, the result is instead determined as follows:
- Returns std::strong_ordering::less if the (possibly converted) value of the first argument precedes the (possibly converted) value of the second argument in the implementation-defined strict total ordering over all pointer values of type
P. This strict total ordering is consistent with the partial order imposed by the builtin operators<,>,<=, and>=. - Otherwise, returns std::strong_ordering::greater if (possibly converted) value of the second argument precedes the (possibly converted) value of the first argument in the same strict total ordering.
- Otherwise, returns std::strong_ordering::equal.
The behavior is undefined unless the the conversion sequences from both T and U to P are equality-preserving (see below).
Equality preservation
Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).
Example
#include <iostream> #include <compare> struct Rational_2 { int num; int den; // > 0 }; inline constexpr std::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs) { return lhs.num * rhs.den <=> rhs.num * lhs.den; } void print(std::weak_ordering value) { if (value == 0) std::cout << "equal\n"; else if (value < 0) std::cout << "less\n"; else std::cout << "greater\n"; } int main() { Rational_2 c{6,5}; Rational_2 d{8,7}; print(c <=> d); print(std::compare_three_way{}(c,d)); }
Output:
less greater greater
See also
| (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) |
| (C++20) |
performs 3-way comparison and produces a result of type std::partial_ordering(customization point object) |
performs 3-way comparison and produces a result of type std::strong_ordering, even if operator<=> is unavailable(customization point object) | |
| (C++20) |
performs 3-way comparison and produces a result of type std::weak_ordering, even if operator<=> is unavailable(customization point object) |
performs 3-way comparison and produces a result of type std::partial_ordering, even if operator<=> is unavailable(customization point object) |
