Qt::strong_ordering Class
class Qt::strong_orderingQt::strong_ordering represents a comparison where equivalent values are indistinguishable. More...
| Header: | #include <QtCompare> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Since: | Qt 6.7 |
Public Functions
| strong_ordering(std::strong_ordering stdorder) | |
| Qt::partial_ordering | operator Qt::partial_ordering() const |
| Qt::weak_ordering | operator Qt::weak_ordering() const |
| std::strong_ordering | operator std::strong_ordering() const |
Static Public Members
| const Qt::strong_ordering | equal |
| const Qt::strong_ordering | equivalent |
| const Qt::strong_ordering | greater |
| const Qt::strong_ordering | less |
Related Non-Members
| bool | is_eq(Qt::strong_ordering o) |
| bool | is_gt(Qt::strong_ordering o) |
| bool | is_gteq(Qt::strong_ordering o) |
| bool | is_lt(Qt::strong_ordering o) |
| bool | is_lteq(Qt::strong_ordering o) |
| bool | is_neq(Qt::strong_ordering o) |
| bool | operator!=(Qt::strong_ordering lhs, Qt::strong_ordering rhs) |
| bool | operator==(Qt::strong_ordering lhs, Qt::strong_ordering rhs) |
Detailed Description
A value of type Qt::strong_ordering is typically returned from a three-way comparison function. Such a function compares two objects and establishes how they are ordered. It uses this return type to indicate that the ordering is strict; that is, the function establishes a well-defined total order.
Qt::strong_ordering has four values, represented by the following symbolic constants:
- less represents that the left operand is less than the right;
- equal represents that the left operand is equivalent to the right;
- equivalent is an alias for
equal; - greater represents that the left operand is greater than the right.
Qt::strong_ordering is idiomatically used by comparing an instance against a literal zero, for instance like this:
// given a, b, c, d as objects of some type that allows for a 3-way compare, // and a compare function declared as follows: Qt::strong_ordering compare(T lhs, T rhs); // defined out-of-line ~~~ Qt::strong_ordering result = compare(a, b); if (result < 0) { // a is less than b } if (compare(c, d) >= 0) { // c is greater than or equal to d }
See also Qt::weak_ordering, Qt::partial_ordering, and Comparison types overview.
Member Function Documentation
[constexpr noexcept] strong_ordering::strong_ordering(std::strong_ordering stdorder)
Constructs a Qt::strong_ordering object from stdorder using the following rules:
- std::strong_ordering::less converts to less.
- std::strong_ordering::equivalent converts to equivalent.
- std::strong_ordering::equal converts to equal.
- std::strong_ordering::greater converts to greater.
[constexpr noexcept] Qt::partial_ordering strong_ordering::operator Qt::partial_ordering() const
Converts this Qt::strong_ordering value to a Qt::partial_ordering object using the following rules:
- less converts to Qt::partial_ordering::less.
- equivalent converts to Qt::partial_ordering::equivalent.
- equal converts to Qt::partial_ordering::equivalent.
- greater converts to Qt::partial_ordering::greater.
[constexpr noexcept] Qt::weak_ordering strong_ordering::operator Qt::weak_ordering() const
Converts this Qt::strong_ordering value to a Qt::weak_ordering object using the following rules:
- less converts to Qt::weak_ordering::less.
- equivalent converts to Qt::weak_ordering::equivalent.
- equal converts to Qt::weak_ordering::equivalent.
- greater converts to Qt::weak_ordering::greater.
[constexpr noexcept] std::strong_ordering strong_ordering::operator std::strong_ordering() const
Converts this Qt::strong_ordering value to a std::strong_ordering object using the following rules:
- less converts to std::strong_ordering::less.
- equivalent converts to std::strong_ordering::equivalent.
- equal converts to std::strong_ordering::equal.
- greater converts to std::strong_ordering::greater.
Member Variable Documentation
const Qt::strong_ordering strong_ordering::equal
Represents the result of a comparison where the left operand is equal to the right operand. Same as Qt::strong_ordering::equivalent.
const Qt::strong_ordering strong_ordering::equivalent
Represents the result of a comparison where the left operand is equal to the right operand. Same as Qt::strong_ordering::equal.
const Qt::strong_ordering strong_ordering::greater
Represents the result of a comparison where the left operand is greater than the right operand.
const Qt::strong_ordering strong_ordering::less
Represents the result of a comparison where the left operand is less than the right operand.
Related Non-Members
[constexpr noexcept] bool is_eq(Qt::strong_ordering o)
[constexpr noexcept] bool is_gt(Qt::strong_ordering o)
[constexpr noexcept] bool is_gteq(Qt::strong_ordering o)
[constexpr noexcept] bool is_lt(Qt::strong_ordering o)
[constexpr noexcept] bool is_lteq(Qt::strong_ordering o)
[constexpr noexcept] bool is_neq(Qt::strong_ordering o)
Converts o into the result of one of the six relational operators:
| Function | Operation |
|---|---|
is_eq | o == 0 |
is_neq | o != 0 |
is_lt | o < 0 |
is_lteq | o <= 0 |
is_gt | o > 0 |
is_gteq | o >= 0 |
These functions are provided for compatibility with std::strong_ordering.
[constexpr noexcept] bool operator!=(Qt::strong_ordering lhs, Qt::strong_ordering rhs)
Returns true if lhs and rhs represent different results; otherwise, returns true.
[constexpr noexcept] bool operator==(Qt::strong_ordering lhs, Qt::strong_ordering rhs)
Returns true if lhs and rhs represent the same result; otherwise, returns false.
© 2024 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
