<QtCompare> - Classes and helpers for defining comparison operators

Documentación de funciones

[constexpr noexcept, since 6.7] template <typename Enum, Qt::if_enum<Enum> = true> Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs)

Implementa la comparación tripartita de tipos enum.

Esta función convierte Enum a su tipo subyacente y llama a la sobrecarga para tipos integrales.

Devuelve una instancia de Qt::strong_ordering que representa la relación entre lhs y rhs.

Restricciones

Participa en la resolución de sobrecargas sólo si Enum es un tipo enum.

Esta función se introdujo en Qt 6.7.

[constexpr noexcept, since 6.7] template < typename FloatType, typename IntType, Qt::if_floating_point<FloatType> = true, Qt::if_integral<IntType> = true > auto compareThreeWay(FloatType lhs, IntType rhs)

Implementa la comparación tripartita de tipos de coma flotante e integrales.

Esta función convierte rhs en FloatType y llama a la sobrecarga para tipos de coma 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 sobrecargas sólo si FloatType es un tipo de punto flotante incorporado y IntType es un tipo integral incorporado.

Esta función se introdujo en Qt 6.7.

[constexpr noexcept, since 6.7] template < typename IntType, typename FloatType, Qt::if_integral<IntType> = true, Qt::if_floating_point<FloatType> = true > auto compareThreeWay(IntType lhs, FloatType rhs)

Implementa la comparación tripartita de tipos integrales y de coma flotante.

Esta función convierte lhs en FloatType y llama a la sobrecarga para tipos de coma 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 sobrecargas sólo si IntType es un tipo integral incorporado y FloatType es un tipo de punto flotante incorporado.

Esta función se introdujo en Qt 6.7.

[constexpr noexcept, since 6.7] template < typename LeftFloat, typename RightFloat, Qt::if_floating_point<LeftFloat> = true, Qt::if_floating_point<RightFloat> = true > auto compareThreeWay(LeftFloat lhs, RightFloat rhs)

Implementa la comparación a tres bandas de tipos de coma flotante.

Devuelve lhs <=> rhs, siempre que LeftFloat y RightFloat sean tipos de coma flotante incorporados. A diferencia de operator<=>(), esta plantilla de función también está disponible en C++17. Véase cppreference para más detalles.

Esta función también puede utilizarse en funciones personalizadas de compareThreeWay(), cuando se ordenan miembros de una clase personalizada representados por tipos incorporados:

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 sólo si tanto LeftFloat como RightFloat son tipos de punto flotante incorporados.

Esta función se introdujo en Qt 6.7.

[constexpr noexcept, since 6.7] template < typename LeftInt, typename RightInt, Qt::if_integral<LeftInt> = true, Qt::if_integral<RightInt> = true > auto compareThreeWay(LeftInt lhs, RightInt rhs)

Implementa la comparación tripartita de tipos integrales.

Devuelve lhs <=> rhs, siempre que LeftInt y RightInt sean tipos integrales incorporados. A diferencia de operator<=>(), esta plantilla de función también está disponible en C++17. Véase cppreference para más detalles.

Esta función también puede utilizarse en funciones personalizadas de compareThreeWay(), cuando se ordenan miembros de una clase personalizada representada por tipos incorporados:

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 sobrecargas sólo si tanto LeftInt como RightInt son tipos integrales incorporados.

Esta función se introdujo en Qt 6.7.

[constexpr noexcept, since 6.8] template < typename T, typename U, Qt::if_compatible_pointers<T, U> = true > Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, Qt::totally_ordered_wrapper<U *> rhs)

Implementa la comparación tripartita 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 sólo si T y U son del mismo tipo, o tipos base y derivados.

Esta función se introdujo en Qt 6.8.

[constexpr noexcept, since 6.8] template < typename T, typename U, Qt::if_compatible_pointers<T, U> = true > Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, U *rhs)

Implementa la comparación tripartita de un puntero envuelto en Qt::totally_ordered_wrapper con 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 sólo si T y U son del mismo tipo, o tipos base y derivados.

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 función se introdujo en Qt 6.8.

[constexpr noexcept, since 6.8] template < typename T, typename U, Qt::if_compatible_pointers<T, U> = true > Qt::strong_ordering compareThreeWay(U *lhs, Qt::totally_ordered_wrapper<T *> rhs)

Implementa la comparación a tres bandas de un puntero normal con 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 sólo si T y U son del mismo tipo, o tipos base y derivados.

Esta función se introdujo en Qt 6.8.

[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 tripartita 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 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 a tres bandas 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 devuelto depende de LeftType y RightType.

Este método es equivalente a

using Qt::compareThreeWay;
return compareThreeWay(lhs, rhs);

donde Qt::compareThreeWay es la implementación Qt de la comparación tripartita para tipos incorporados.

Las funciones libres compareThreeWay deberían proporcionar la comparación tripartita para tipos personalizados. Las funciones deberían devolver uno de los tipos de ordenación de Qt.

Qt proporciona la implementación compareThreeWay para algunos de sus tipos.

Use esta función principalmente en código genérico, cuando no sepa nada sobre LeftType y RightType.

Si conoce los tipos, use

• Qt::compareThreeWay para tipos incorporados
• compareThreeWay para tipos personalizados

Use operator<=>() directamente en código que sólo será compilado con C++20 o posterior.

Esta función se introdujo en Qt 6.7.

Ver también Qt::partial_ordering, Qt::weak_ordering, y Qt::strong_ordering.