std::strong_ordering - cppreference.com (original) (raw)

| | | | | ----------------------- | | ------------- | | class strong_ordering; | | (since C++20) |

The class type std::strong_ordering is the result type of a three-way comparison that:

• Admits all six relational operators (==, !=, <, <=, >, >=).
• Implies substitutability: if a is equivalent to b, f(a) is also equivalent to f(b), where f denotes a function that reads only comparison-salient state that is accessible via the argument's public const members. In other words, equivalent values are indistinguishable.
• Does not allow incomparable values: exactly one of a < b, a == b, or a > b must be true.

Contents

• 1 Constants
• 2 Conversions
• 3 std::strong_ordering::operator partial_ordering
  • 3.1 Return value
• 4 std::strong_ordering::operator weak_ordering
  • 4.1 Return value
  • 4.2 Comparisons
• 5 operator==
  • 5.1 Parameters
  • 5.2 Return value
• 6 operator<
  • 6.1 Parameters
  • 6.2 Return value
• 7 operator<=
  • 7.1 Parameters
  • 7.2 Return value
• 8 operator>
  • 8.1 Parameters
  • 8.2 Return value
• 9 operator>=
  • 9.1 Parameters
  • 9.2 Return value
• 10 operator<=>
  • 10.1 Parameters
  • 10.2 Return value
  • 10.3 Example
  • 10.4 See also

[edit] Constants

The type std::strong_ordering has four valid values, implemented as const static data members of its type:

[edit] Conversions

std::strong_ordering is the strongest of the three comparison categories: it is not implicitly-convertible from any other category and is implicitly-convertible to the other two.

std::strong_ordering::operator partial_ordering

| constexpr operator partial_ordering() const noexcept; | | | | ------------------------------------------------------ | | |

Return value

std::partial_ordering::less if v is less,std::partial_ordering::greater if v is greater,std::partial_ordering::equivalent if v is equal or equivalent.

| | implicit conversion to std::weak_ordering (public member function) | | ---------------------------------------------------------------------- |

std::strong_ordering::operator weak_ordering

| constexpr operator weak_ordering() const noexcept; | | | | --------------------------------------------------- | | |

Return value

std::weak_ordering::less if v is less,std::weak_ordering::greater if v is greater,std::weak_ordering::equivalent if v is equal or equivalent.

[edit] Comparisons

Comparison operators are defined between values of this type and literal ​0​. This supports the expressions a <=> b == 0 or a <=> b < 0 that can be used to convert the result of a three-way comparison operator to a boolean relationship; see std::is_eq, std::is_lt, etc.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when std::strong_ordering is an associated class of the arguments.

The behavior of a program that attempts to compare a strong_ordering with anything other than the integer literal ​0​ is undefined.

operator==

| friend constexpr booloperator==( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | ----------------------------------------------------------------------------------------------- | --- | | | friend constexpr booloperator==( strong_ordering v, strong_ordering w ) noexcept = default; | (2) | |

Parameters

Return value

1. true if v is equivalent or equal, false if v is less or greater

2. true if both parameters hold the same value, false otherwise. Note that equal is the same as equivalent.

operator<

| friend constexpr bool operator<( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | ------------------------------------------------------------------------------------ | --- | | | friend constexpr bool operator<( /*unspecified*/ u, strong_ordering v ) noexcept; | (2) | |

Parameters

Return value

1. true if v is less, and false if v is greater, equivalent, or equal

2. true if v is greater, and false if v is less, equivalent, or equal

operator<=

| friend constexpr bool operator<=( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | ------------------------------------------------------------------------------------- | --- | | | friend constexpr bool operator<=( /*unspecified*/ u, strong_ordering v ) noexcept; | (2) | |

Parameters

Return value

1. true if v is less, equivalent, or equal, and false if v is greater

2. true if v is greater, equivalent, or equal, and false if v is less

operator>

| friend constexpr bool operator>( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | ------------------------------------------------------------------------------------- | --- | | | friend constexpr bool operator>( /*unspecified*/ u, strong_ordering v ) noexcept; | (2) | |

Parameters

Return value

1. true if v is greater, and false if v is less, equivalent, or equal

2. true if v is less, and false if v is greater, equivalent, or equal

operator>=

| friend constexpr bool operator>=( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | -------------------------------------------------------------------------------------- | --- | | | friend constexpr bool operator>=( /*unspecified*/ u, strong_ordering v ) noexcept; | (2) | |

Parameters

Return value

1. true if v is greater, equivalent, or equal, and false if v is less

2. true if v is less, equivalent, or equal, and false if v is greater

operator<=>

| friend constexpr strong_orderingoperator<=>( strong_ordering v, /*unspecified*/ u ) noexcept; | (1) | | | ------------------------------------------------------------------------------------------------- | --- | | | friend constexpr strong_orderingoperator<=>( /*unspecified*/ u, strong_ordering v ) noexcept; | (2) | |

Parameters

Return value

1. v.

2. greater if v is less, less if v is greater, otherwise v.

[edit] Example

#include #include   struct Point { int x{}, y{};   friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs) { if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y)) return std::strong_ordering::less; if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y)) return std::strong_ordering::greater; return std::strong_ordering::equivalent; }   friend std::ostream& operator<<(std::ostream& os, Point s) { return os << '(' << s.x << ',' << s.y << ')'; } };   void print_three_way_comparison(const auto& p, const auto& q) { const auto cmp{p <=> q}; std::cout << p << (cmp < 0 ? " < " : cmp > 0 ? " > " : " == " ) // compares with 0 << q << '\n'; }   void print_two_way_comparison(const auto& p, const auto& q) { std::cout << p << (p < q ? " < " : p > q ? " > " : " == ") // compares p and q << q << '\n'; }   int main() { const Point p1{0, 1}, p2{0, 1}, p3{0, 2};   print_three_way_comparison(p1, p2); print_two_way_comparison(p1, p2);   print_three_way_comparison(p2, p3); print_two_way_comparison(p2, p3);   print_three_way_comparison(p3, p2); print_two_way_comparison(p3, p2); }

Output:

(0,1) == (0,1) (0,1) == (0,1) (0,1) < (0,2) (0,1) < (0,2) (0,2) > (0,1) (0,2) > (0,1)

[edit] See also

| | the result type of 3-way comparison that supports all 6 operators and is not substitutable (class) [edit] | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | | the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values (class) [edit] |