En esta página

Qt::weak_ordering Class

class Qt::weak_ordering

Qt::weak_ordering representa una comparación en la que los valores equivalentes siguen siendo distinguibles. Más...

Encabezado: #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

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

Miembros públicos estáticos

const Qt::weak_ordering equivalent
const Qt::weak_ordering greater
const Qt::weak_ordering less
bool is_eq(Qt::weak_ordering o)
bool is_gt(Qt::weak_ordering o)
bool is_gteq(Qt::weak_ordering o)
bool is_lt(Qt::weak_ordering o)
bool is_lteq(Qt::weak_ordering o)
bool is_neq(Qt::weak_ordering o)
bool operator!=(Qt::weak_ordering lhs, Qt::weak_ordering rhs)
bool operator==(Qt::weak_ordering lhs, Qt::weak_ordering rhs)

Descripción detallada

Normalmente, una función de comparación de tres vías devuelve un valor de tipo ` Qt::weak_ordering `. Dicha función compara dos objetos y establece su orden. Utiliza este tipo de retorno para indicar que el orden es débil; es decir, que valores equivalentes pueden ser distinguibles.

Qt::weak_ordering tiene tres valores, representados por las siguientes constantes simbólicas:

  • less indica que el operando de la izquierda es menor que el de la derecha;
  • equivalent indica que el operando de la izquierda es equivalente al de la derecha;
  • greater indica que el operando de la izquierda es mayor que el de la derecha;

Qt::weak_ordering se utiliza de forma habitual al comparar una instancia con 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::weak_ordering compare(T lhs, T rhs); // defined out-of-line
~~~

Qt::weak_ordering result = compare(a, b);
if (result < 0) {
    // a is less than b
}

if (compare(c, d) >= 0) {
    // c is greater than or equivalent to d
}

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

Documentación de funciones miembro

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

Crea un objeto ` Qt::weak_ordering ` a partir de ` stdorder ` siguiendo estas reglas:

  • std::weak_ordering::less se convierte en less.
  • std::weak_ordering::equivalent se convierte en equivalent.
  • std::weak_ordering::greater se convierte en greater.

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

Convierte este valor de tipo « Qt::weak_ordering » en un objeto de tipo « Qt::partial_ordering » siguiendo las siguientes reglas:

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

Convierte este valor de ` Qt::weak_ordering ` en un objeto `std::weak_ordering` siguiendo las siguientes reglas:

  • less se convierte en std::weak_ordering::less.
  • equivalent se convierte en std::weak_ordering::equivalent.
  • greater se convierte a std::weak_ordering::greater.

Documentación de las variables miembro

const Qt::weak_ordering weak_ordering::equivalent

Representa el resultado de una comparación en la que el operando de la izquierda es equivalente al de la derecha.

const Qt::weak_ordering weak_ordering::greater

Representa el resultado de una comparación en la que el operando de la izquierda es mayor que el de la derecha.

const Qt::weak_ordering weak_ordering::less

Representa el resultado de una comparación en la que el operando de la izquierda es menor que el de la derecha.

Elementos no miembros relacionados

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

[constexpr noexcept] bool is_gt(Qt::weak_ordering o)

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

[constexpr noexcept] bool is_lt(Qt::weak_ordering o)

[constexpr noexcept] bool is_lteq(Qt::weak_ordering o)

[constexpr noexcept] bool is_neq(Qt::weak_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 para garantizar la compatibilidad con std::weak_ordering.

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

Devuelve «true» si lhs y rhs muestran resultados diferentes; en caso contrario, devuelve «true».

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

Devuelve «true» si lhs y rhs representan el mismo resultado; en caso contrario, devuelve «false».

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