<QtCompare> - Classes and helpers for defining comparison operators
El archivo de encabezado <QtCompare> define los tipos « Qt::*_ordering » y macros auxiliares para definir operadores de comparación. Más información...
| Header: | #include <QtCompare> |
Tipos
(since 6.12) | if_has_qt_compare_three_way |
Funciones
(since 6.7) Qt::strong_ordering | compareThreeWay(Enum lhs, Enum rhs) |
(since 6.7) auto | compareThreeWay(FloatType lhs, IntType rhs) |
(since 6.7) auto | compareThreeWay(IntType lhs, FloatType rhs) |
(since 6.7) auto | compareThreeWay(LeftFloat lhs, RightFloat rhs) |
(since 6.7) auto | compareThreeWay(LeftInt lhs, RightInt rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, Qt::totally_ordered_wrapper<U *> rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, U *rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, std::nullptr_t rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(U *lhs, Qt::totally_ordered_wrapper<T *> rhs) |
(since 6.12) auto | compareThreeWay(const std::pair<T1, T2> &lhs, const std::pair<U1, U2> &rhs) |
(since 6.8) Qt::strong_ordering | compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T *> rhs) |
(since 6.7) auto | qCompareThreeWay(const LeftType &lhs, const RightType &rhs) |
Descripción detallada
Este archivo de cabecera introduce los tipos ` Qt::partial_ordering`, ` Qt::weak_ordering` y ` Qt::strong_ordering `, que son las adaptaciones de Qt a C++17 de los tipos ` std::*_ordering `.
Este encabezado también contiene funciones para implementar la comparación de tres elementos en C++17.
Las sobrecargas de la función ` Qt::compareThreeWay() ` proporcionan la comparación de tres elementos para los tipos integrados de C++.
La plantilla ` qCompareThreeWay()` sirve como implementación genérica de la comparación a tres bandas. En su implementación, se basa en las funciones ` Qt::compareThreeWay() ` y ` compareThreeWay() ` libres.
Documentación de tipos
[alias, since 6.12] template <typename T, typename U> if_has_qt_compare_three_way
Un alias de conveniencia para ` std::enable_if_t ` que se puede utilizar para restringir las plantillas de funciones a tipos que admitan la comparación de tres elementos mediante ` compareThreeWay()`.
Esta definición de tipo se introdujo en Qt 6.12.
Véase también Qt::has_qt_compare_three_way.
Documentación de la función
[constexpr noexcept, since 6.7] template <typename Enum> requires if_enum<Enum> Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs)
Implementa la comparación a tres bandas de tipos de enumeración.
Esta función convierte Enum a su tipo subyacente y llama a la sobrecarga para tipos enteros.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas solo si ` Enum ` es un tipo enumerado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename FloatType, typename IntType> requires if_floating_point<FloatType> && if_integral<IntType> auto compareThreeWay(FloatType lhs, IntType rhs)
Implementa la comparación a tres bandas entre tipos de punto flotante y tipos enteros.
Esta función convierte rhs en FloatType y llama a la sobrecarga para los tipos de punto flotante.
Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` lhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si FloatType es un tipo de punto flotante integrado y IntType es un tipo entero integrado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename IntType, typename FloatType> requires if_integral<IntType> && if_floating_point<FloatType> auto compareThreeWay(IntType lhs, FloatType rhs)
Lleva a cabo una comparación a tres bandas entre tipos enteros y de coma flotante.
Esta función convierte lhs en FloatType y llama a la sobrecarga para los tipos de punto flotante.
Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` rhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si IntType es un tipo entero integrado y FloatType es un tipo de punto flotante integrado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename LeftFloat, typename RightFloat> requires if_floating_point<LeftFloat> && if_floating_point<RightFloat> auto compareThreeWay(LeftFloat lhs, RightFloat rhs)
Implementa una comparación a tres bandas de tipos de punto flotante.
Devuelve ` lhs <=> rhs`, siempre que ` LeftFloat ` y ` RightFloat ` sean tipos de punto flotante integrados. A diferencia de ` operator<=>()`, esta plantilla de función también está disponible en C++17. Consulta cppreference para obtener más detalles.
Esta función también se puede utilizar en funciones personalizadas de ` compareThreeWay() `, a la hora de ordenar los miembros de una clase personalizada representada por tipos integrados:
class MyClass {
public:
...
private:
double value;
...
friend Qt::partial_ordering
compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
{ return Qt::compareThreeWay(lhs.value, rhs.value); }
Q_DECLARE_PARTIALLY_ORDERED(MyClass)
};Devuelve una instancia de ` Qt::partial_ordering ` que representa la relación entre ` lhs ` y ` rhs`. Si ` lhs ` o ` rhs ` no es un número (NaN), se devuelve ` Qt::partial_ordering::unordered `.
Restricciones
Participa en la resolución de sobrecarga solo si tanto LeftFloat como RightFloat son tipos de punto flotante integrados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.7] template <typename LeftInt, typename RightInt> requires if_integral<LeftInt> && if_integral<RightInt> auto compareThreeWay(LeftInt lhs, RightInt rhs)
Implementa la comparación a tres bandas de tipos integrales.
Devuelve ` lhs <=> rhs`, siempre que ` LeftInt ` y ` RightInt ` sean tipos enteros predefinidos. A diferencia de ` operator<=>()`, esta plantilla de función también está disponible en C++17. Consulta cppreference para obtener más detalles.
Esta función también se puede utilizar en funciones personalizadas de ` compareThreeWay() `, al ordenar los miembros de una clase personalizada representada por tipos integrados:
class MyClass {
public:
...
private:
int value;
...
friend Qt::strong_ordering
compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
{ return Qt::compareThreeWay(lhs.value, rhs.value); }
Q_DECLARE_STRONGLY_ORDERED(MyClass)
};Devuelve una instancia de Qt::strong_ordering que representa la relación entre lhs y rhs.
Restricciones
Participa en la resolución de sobrecarga solo si tanto ` LeftInt ` como ` RightInt ` son tipos enteros integrados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, Qt::totally_ordered_wrapper<U *> rhs)
Implementa una comparación a tres bandas de punteros envueltos en ` Qt::totally_ordered_wrapper`. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas únicamente si T y U son del mismo tipo, o si son tipos base y derivados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, U *rhs)
Implementa la comparación a tres bandas entre un puntero envuelto en ` Qt::totally_ordered_wrapper ` y un puntero normal. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas solo si T y U son del mismo tipo, o si son tipos base y derivados.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, std::nullptr_t rhs)
Implementa la comparación a tres bandas de un puntero envuelto en « Qt::totally_ordered_wrapper » con « std::nullptr_t ».
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept, since 6.8] template <typename T, typename U> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(U *lhs, Qt::totally_ordered_wrapper<T *> rhs)
Implementa la comparación a tres bandas entre un puntero normal y un puntero envuelto en ` Qt::totally_ordered_wrapper`. Utiliza un orden total estricto sobre los punteros al realizar la comparación.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Restricciones
Participa en la resolución de sobrecargas solo si ` T ` y ` U ` son del mismo tipo, o si se trata de un tipo base y un tipo derivado.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[since 6.12] template <
typename T1,
typename T2,
typename U1,
typename U2
>
auto compareThreeWay(const std::pair<T1, T2> &lhs, const std::pair<U1, U2> &rhs)
Nota: « T1 » debería ser comparable a « U1 », y « T2 » debería ser comparable a « U2 » utilizando « compareThreeWay() » o « operator<() ».
Esta sobrecarga utiliza el tipo de retorno auto, ya que la fuerza del orden depende de los argumentos de plantilla del par. Por ejemplo, si cualquiera de los argumentos es de tipo flotante, el orden sería Qt::partial_ordering; si ambos son enteros, sería Qt::strong_ordering.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T *> rhs)
Implementa la comparación de tres elementos de ` std::nullptr_t ` con un puntero envuelto en ` Qt::totally_ordered_wrapper`.
Devuelve una instancia de ` Qt::strong_ordering ` que representa la relación entre ` lhs ` y ` rhs`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[since 6.7] template <typename LeftType, typename RightType> auto qCompareThreeWay(const LeftType &lhs, const RightType &rhs)
Realiza la comparación de tres elementos en lhs y rhs y devuelve como resultado uno de los tipos de ordenación de Qt. Esta función está disponible tanto para C++17 como para C++20.
El tipo real devuelto depende de LeftType y RightType.
Nota: Esta plantilla de función solo está disponible cuando compareThreeWay() se implementa para el par (LeftType, RightType) o para el par inverso (RightType, LeftType).
Este método es equivalente a
using Qt::compareThreeWay;
return compareThreeWay(lhs, rhs);donde Qt::compareThreeWay es la implementación de Qt de la comparación a tres bandas para tipos integrados.
Las funciones libres de ` compareThreeWay ` deben proporcionar la comparación de tres vías para los tipos personalizados. Las funciones deben devolver uno de los tipos de ordenación de Qt.
Qt proporciona una implementación de ` compareThreeWay ` para algunos de sus tipos.
Nota: No reimplemente ` compareThreeWay() ` para los tipos de Qt, ya que en futuras versiones de Qt se añadirá compatibilidad con esta función para más tipos de Qt.
Utiliza esta función principalmente en código genérico, cuando no sepas nada sobre ` LeftType ` y ` RightType`.
Si conoce los tipos, utilice
Qt::compareThreeWaypara los tipos integradoscompareThreeWaypara los tipos personalizados
Utiliza ` operator<=>() ` directamente en código que solo se vaya a compilar con C++20 o versiones posteriores.
Esta función se introdujo en Qt 6.7.
Véase también Qt::partial_ordering, Qt::weak_ordering y Qt::strong_ordering.
© 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.