strong_ordering Class

class Qt::strong_ordering

Qt::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(int stdorder)
Qt::partial_ordering operator Qt::partial_ordering() const
Qt::weak_ordering operator Qt::weak_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
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

[default] strong_ordering::strong_ordering(int 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:

[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:

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:

FunctionOperation
is_eqo == 0
is_neqo != 0
is_lto < 0
is_lteqo <= 0
is_gto > 0
is_gteqo >= 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.