<QtCompare> - Classes and helpers for defining comparison operators

Documentation des fonctions

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

Implémente la comparaison à trois voies des types enum.

Cette fonction convertit Enum en son type sous-jacent et appelle la surcharge pour les types intégraux.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si Enum est un type enum.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies des types à virgule flottante et intégraux.

Cette fonction convertit rhs en FloatType et appelle la surcharge pour les types à virgule flottante.

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si lhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si FloatType est un type flottant intégré et IntType un type intégral intégré.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies des types intégraux et à virgule flottante.

Cette fonction convertit lhs en FloatType et appelle la surcharge pour les types à virgule flottante.

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si rhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si IntType est un type intégral intégré et FloatType un type flottant intégré.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies des types à virgule flottante.

Renvoie lhs <=> rhs, à condition que LeftFloat et RightFloat soient des types à virgule flottante intégrés. Contrairement à operator<=>(), ce modèle de fonction est également disponible en C++17. Voir cppreference pour plus de détails.

Cette fonction peut également être utilisée dans les fonctions personnalisées compareThreeWay(), lors de l'ordonnancement des membres d'une classe personnalisée représentée par des types intégrés :

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)
};

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si lhs ou rhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si LeftFloat et RightFloat sont des types flottants intégrés.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies des types intégraux.

Renvoie lhs <=> rhs, à condition que LeftInt et RightInt soient des types intégraux intégrés. Contrairement à operator<=>(), ce modèle de fonction est également disponible en C++17. Voir cppreference pour plus de détails.

Cette fonction peut également être utilisée dans les fonctions personnalisées compareThreeWay(), lorsqu'il s'agit d'ordonner les membres d'une classe personnalisée représentée par des types intégrés :

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)
};

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si LeftInt et RightInt sont des types intégraux intégrés.

Cette fonction a été introduite dans 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)

Implémente une comparaison à trois voies de pointeurs qui sont enveloppés dans Qt::totally_ordered_wrapper. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Participe à la résolution de surcharge uniquement si T et U sont du même type, ou des types de base et dérivés.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies d'un pointeur enveloppé dans Qt::totally_ordered_wrapper avec un pointeur normal. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si T et U sont du même type, ou des types de base et dérivés.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies d'un pointeur enveloppé dans Qt::totally_ordered_wrapper avec std::nullptr_t.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies d'un pointeur normal avec un pointeur enveloppé dans Qt::totally_ordered_wrapper. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Participe à la résolution de surcharge uniquement si T et U sont du même type, ou des types de base et dérivés.

Cette fonction a été introduite dans 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)

Implémente la comparaison à trois voies de std::nullptr_t avec un pointeur enveloppé dans Qt::totally_ordered_wrapper.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Cette fonction a été introduite dans Qt 6.8.

[since 6.7] template <typename LeftType, typename RightType> auto qCompareThreeWay(const LeftType &lhs, const RightType &rhs)

Effectue la comparaison à trois sur lhs et rhs et renvoie l'un des types de commande Qt XML en tant que résultat. Cette fonction est disponible pour C++17 et C++20.

Le type renvoyé dépend de LeftType et RightType.

Cette méthode est équivalente à

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

où Qt::compareThreeWay est l'implémentation Qt de la comparaison à trois voies pour les types intégrés.

Les fonctions libres compareThreeWay devraient fournir une comparaison à trois voies pour les types personnalisés. Les fonctions doivent renvoyer l'un des types de commande de Qt.

Qt fournit l'implémentation compareThreeWay pour certains de ses types.

Utilisez cette fonction principalement dans le code générique, lorsque vous ne connaissez pas les types LeftType et RightType.

Si vous connaissez les types, utilisez

• Qt::compareThreeWay pour les types intégrés
• compareThreeWay pour les types personnalisés

Utilisez operator<=>() directement dans le code qui ne sera compilé qu'avec C++20 ou une version ultérieure.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi Qt::partial_ordering, Qt::weak_ordering, et Qt::strong_ordering.