<QtCompare> - Classes and helpers for defining comparison operators

Documentation sur les fonctions

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

Implémente une comparaison à trois voies entre des types énumérés.

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

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

Contraintes

Ne participe à la résolution des surcharges que si ` Enum ` est un type énuméré.

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

Met en œuvre une comparaison à trois voies entre les types à virgule flottante et les types entiers.

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 des surcharges que si FloatType est un type à virgule flottante intégré et si IntType est un type entier intégré.

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

Met en œuvre une comparaison à trois voies entre les types entiers et les types à 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 des surcharges que si IntType est un type entier intégré et si FloatType est un type à virgule flottante intégré.

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

Implémente une comparaison à trois voies entre 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. Consultez cppreference pour plus de détails.

Cette fonction peut également être utilisée dans des fonctions ` compareThreeWay() ` personnalisées, lors du tri 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 des surcharges que si LeftFloat et RightFloat sont tous deux des types à virgule flottante intégrés.

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

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

Renvoie lhs <=> rhs, à condition que LeftInt et RightInt soient des types entiers 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 des fonctions ` compareThreeWay() ` personnalisées, lors du tri des 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 des surcharges que si LeftInt et RightInt sont tous deux des types entiers intégrés.

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

Implémente une comparaison à trois voies entre des pointeurs encapsulés dans ` Qt::totally_ordered_wrapper`. Utilise un ordre total strict sur les pointeurs lors de la comparaison.

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

Contraintes

Ne participe à la résolution des surcharges que si ` T ` et ` U ` sont du même type, ou s’il s’agit d’un type de base et d’un type dérivé.

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

Implémente une comparaison à trois voies entre un pointeur encapsulé dans ` Qt::totally_ordered_wrapper ` et un pointeur standard. Utilise un ordre total strict sur les pointeurs lors de la comparaison.

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

Contraintes

Ne participe à la résolution des surcharges que si ` T ` et ` U ` sont du même type, ou s’il s’agit d’un type de base et d’un type dérivé.

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 encapsulé 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> requires if_compatible_pointers<T, U> Qt::strong_ordering compareThreeWay(U *lhs, Qt::totally_ordered_wrapper<T *> rhs)

Implémente une comparaison à trois voies entre un pointeur standard et un pointeur encapsulé dans ` Qt::totally_ordered_wrapper`. Utilise un ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance d'Qt::strong_ordering représentant la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution des surcharges que si ` T ` et ` U ` sont du même type, ou s'il s'agit d'un type de base et d'un type dérivé.

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

Cette surcharge utilise le type de retour auto, car la force de l’ordre dépend des arguments de modèle de la paire. Par exemple, si l’un des deux arguments est de type à virgule flottante, l’ordre sera Qt::partial_ordering; s’ils sont tous deux entiers, il sera Qt::strong_ordering.

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

Implémente une comparaison à trois voies entre ` std::nullptr_t ` et un pointeur encapsulé 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 voies sur lhs et rhs et renvoie l'un des types d'ordre Qt comme résultat. Cette fonction est disponible à la fois pour C++17 et C++20.

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

Cette méthode équivaut à

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 ` compareThreeWay ` libres doivent fournir une comparaison à trois voies pour les types personnalisés. Ces fonctions doivent renvoyer l’un des types d’ordre Qt.

Qt fournit une implémentation de ` compareThreeWay ` pour certains de ses types.

Utilisez cette fonction principalement dans du code générique, lorsque vous ne disposez d’aucune information concernant ` 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 également Qt::partial_ordering, Qt::weak_ordering et Qt::strong_ordering.