Back to Qt.io
Contact Us Blog Download Qt
En esta página

Qt::strong_ordering Class

class Qt::strong_ordering

Qt::strong_ordering representa una comparación en la que los valores equivalentes son indistinguibles. Más...

Cabecera: #include <QtCompare>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Desde: Qt 6.7

Funciones Públicas

strong_ordering(std::strong_ordering stdorder)
operator Qt::partial_ordering() const
operator Qt::weak_ordering() const
operator std::strong_ordering() const

Miembros públicos estáticos

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)

Descripción detallada

Un valor de tipo Qt::strong_ordering es típicamente devuelto por una función de comparación tripartita. Dicha función compara dos objetos y establece cómo están ordenados. Utiliza este tipo de retorno para indicar que el ordenamiento es estricto; es decir, la función establece un orden total bien definido.

Qt::strong_ordering tiene cuatro valores, representados por las siguientes constantes simbólicas:

  • less representa que el operando izquierdo es menor que el derecho;
  • equal representa que el operando izquierdo es equivalente al derecho;
  • equivalent es un alias de equal;
  • greater representa que el operando izquierdo es mayor que el derecho.

Qt::strong_ordering se utiliza idiomáticamente comparando una instancia contra un cero literal, por ejemplo así:

// 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
}

Véase también Qt::weak_ordering, Qt::partial_ordering, y Visión general de los tipos de comparación.

Documentación de funciones miembro

[constexpr noexcept] strong_ordering::strong_ordering(std::strong_ordering stdorder)

Construye un objeto Qt::strong_ordering a partir de stdorder utilizando las siguientes reglas:

  • std::strong_ordering::less convierte a less.
  • std::strong_ordering::equivalent convierte a equivalent.
  • std::strong_ordering::equal convierte a equal.
  • std::strong_ordering::greater se convierte a greater.

[constexpr noexcept] strong_ordering::operator Qt::partial_ordering() const

Convierte este valor Qt::strong_ordering en un objeto Qt::partial_ordering utilizando las siguientes reglas:

[constexpr noexcept] strong_ordering::operator Qt::weak_ordering() const

Convierte este valor Qt::strong_ordering en un objeto Qt::weak_ordering utilizando las siguientes reglas:

[constexpr noexcept] strong_ordering::operator std::strong_ordering() const

Convierte este valor Qt::strong_ordering en un objeto std::strong_ordering utilizando las siguientes reglas:

  • less convierte a std::strong_ordering::less.
  • equivalent convierte a std::strong_ordering::equivalent.
  • equal convierte a std::strong_ordering::equal.
  • greater se convierte en std::strong_ordering::greater.

Documentación de variables miembro

const Qt::strong_ordering strong_ordering::equal

Representa el resultado de una comparación en la que el operando izquierdo es igual al operando derecho. Igual que Qt::strong_ordering::equivalent.

const Qt::strong_ordering strong_ordering::equivalent

Representa el resultado de una comparación en la que el operando izquierdo es igual al operando derecho. Igual que Qt::strong_ordering::equal.

const Qt::strong_ordering strong_ordering::greater

Representa el resultado de una comparación en la que el operando izquierdo es mayor que el operando derecho.

const Qt::strong_ordering strong_ordering::less

Representa el resultado de una comparación en la que el operando izquierdo es menor que el operando derecho.

No miembros relacionados

[constexpr noexcept] bool is_eq(Qt::strong_ordering o)

[constexpr noexcept] bool is_neq(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_gt(Qt::strong_ordering o)

[constexpr noexcept] bool is_gteq(Qt::strong_ordering o)

Convierte o en el resultado de uno de los seis operadores relacionales:

FunciónOperación
is_eqo == 0
is_neqo != 0
is_lto < 0
is_lteqo <= 0
is_gto > 0
is_gteqo >= 0

Estas funciones se proporcionan por compatibilidad con std::strong_ordering.

[constexpr noexcept] bool operator!=(Qt::strong_ordering lhs, Qt::strong_ordering rhs)

Devuelve true si lhs y rhs representan resultados diferentes; en caso contrario, devuelve true.

[constexpr noexcept] bool operator==(Qt::strong_ordering lhs, Qt::strong_ordering rhs)

Devuelve verdadero si lhs y rhs representan el mismo resultado; en caso contrario, devuelve falso.

© 2026 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.