<QtCompare> - Classes and helpers for defining comparison operators

Funktionsdokumentation

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

Implementiert einen Drei-Wege-Vergleich von Enum-Typen.

Diese Funktion konvertiert „ Enum “ in den zugrunde liegenden Typ und ruft die Überladung für ganzzahlige Typen auf.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Enum ` ein Enum-Typ ist.

Diese Funktion wurde in Qt 6.7 eingeführt.

[constexpr noexcept, since 6.7] template <typename FloatType, typename IntType> requires if_floating_point<FloatType> && if_integral<IntType> auto compareThreeWay(FloatType lhs, IntType rhs)

Führt einen Drei-Wege-Vergleich von Gleitkomma- und Ganzzahltypen durch.

Diese Funktion konvertiert „ rhs “ in „ FloatType “ und ruft die Überladung für Gleitkomma-Typen auf.

Gibt eine Instanz von ` Qt::partial_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt. Ist ` lhs ` keine Zahl (NaN), wird ` Qt::partial_ordering::unordered ` zurückgegeben.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ FloatType “ ein integrierter Gleitkomma-Typ und „ IntType “ ein integrierter ganzzahliger Typ ist.

Diese Funktion wurde in Qt 6.7 eingeführt.

[constexpr noexcept, since 6.7] template <typename IntType, typename FloatType> requires if_integral<IntType> && if_floating_point<FloatType> auto compareThreeWay(IntType lhs, FloatType rhs)

Führt einen Drei-Wege-Vergleich von Integer- und Gleitkommatypen durch.

Diese Funktion konvertiert „ lhs “ in „ FloatType “ und ruft die Überladung für Gleitkomma-Typen auf.

Gibt eine Instanz von ` Qt::partial_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt. Ist ` rhs ` keine Zahl (NaN), wird ` Qt::partial_ordering::unordered ` zurückgegeben.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ IntType “ ein integraler Standardtyp und „ FloatType “ ein Gleitkomma-Standardtyp ist.

Diese Funktion wurde in Qt 6.7 eingeführt.

[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)

Implementiert einen Drei-Wege-Vergleich von Gleitkommatypen.

Gibt ` lhs <=> rhs` zurück, vorausgesetzt, dass ` LeftFloat ` und ` RightFloat ` integrierte Gleitkommatypen sind. Im Gegensatz zu ` operator<=>()` ist diese Funktionsvorlage auch in C++17 verfügbar. Weitere Details finden Sie unter cppreference.

Diese Funktion kann auch in benutzerdefinierten „ compareThreeWay() “-Funktionen verwendet werden, wenn Elemente einer benutzerdefinierten Klasse sortiert werden sollen, die durch integrierte Typen dargestellt wird:

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

Gibt eine Instanz von ` Qt::partial_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt. Wenn ` lhs ` oder ` rhs ` keine Zahl ist (NaN), wird ` Qt::partial_ordering::unordered ` zurückgegeben.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn sowohl LeftFloat als auch RightFloat integrierte Gleitkommatypen sind.

Diese Funktion wurde in Qt 6.7 eingeführt.

[constexpr noexcept, since 6.7] template <typename LeftInt, typename RightInt> requires if_integral<LeftInt> && if_integral<RightInt> auto compareThreeWay(LeftInt lhs, RightInt rhs)

Implementiert einen Drei-Wege-Vergleich von ganzzahligen Typen.

Gibt ` lhs <=> rhs` zurück, vorausgesetzt, ` LeftInt ` und ` RightInt ` sind integrierte ganzzahlige Typen. Im Gegensatz zu ` operator<=>()` ist diese Funktionsvorlage auch in C++17 verfügbar. Weitere Details finden Sie unter cppreference.

Diese Funktion kann auch in benutzerdefinierten „ compareThreeWay() “-Funktionen verwendet werden, wenn Elemente einer benutzerdefinierten Klasse sortiert werden sollen, die durch integrierte Typen dargestellt wird:

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

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Relation zwischen ` lhs ` und ` rhs` darstellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn sowohl ` LeftInt ` als auch ` RightInt ` integrierte ganzzahlige Typen sind.

Diese Funktion wurde in Qt 6.7 eingeführt.

[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)

Implementiert einen Drei-Wege-Vergleich von Zeigern, die in ` Qt::totally_ordered_wrapper` gekapselt sind. Verwendet beim Vergleich eine strenge Gesamtordnung über die Zeiger.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Relation zwischen ` lhs ` und ` rhs` darstellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` T ` und ` U ` denselben Typ haben oder es sich um Basis- und abgeleitete Typen handelt.

Diese Funktion wurde in Qt 6.8 eingeführt.

[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)

Implementiert einen Drei-Wege-Vergleich zwischen einem in ` Qt::totally_ordered_wrapper ` verpackten Zeiger und einem normalen Zeiger. Verwendet beim Vergleich eine strenge Gesamtordnung über die Zeiger.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` T ` und ` U ` denselben Typ haben oder es sich um Basis- und abgeleitete Typen handelt.

Diese Funktion wurde in Qt 6.8 eingeführt.

[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T *> lhs, std::nullptr_t rhs)

Implementiert einen Drei-Wege-Vergleich eines in ` Qt::totally_ordered_wrapper ` verpackten Zeigers mit ` std::nullptr_t`.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

[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)

Implementiert einen Drei-Wege-Vergleich eines normalen Zeigers mit einem in „ Qt::totally_ordered_wrapper “ verpackten Zeiger. Verwendet beim Vergleich eine strenge Gesamtordnung über die Zeiger.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` T ` und ` U ` vom gleichen Typ sind oder es sich um Basis- und abgeleitete Typen handelt.

Diese Funktion wurde in Qt 6.8 eingeführt.

[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)

Diese Überladung verwendet den Rückgabetyp „ auto “, da die Stärke der Sortierreihenfolge von den Template-Argumenten des Paares abhängt. Ist beispielsweise eines der Argumente ein Gleitkomma-Typ, wäre die Sortierreihenfolge „ Qt::partial_ordering “; sind beide ganzzahlig, wäre sie „ Qt::strong_ordering “.

Diese Funktion wurde in Qt 6.12 eingeführt.

[constexpr noexcept, since 6.8] template <typename T> Qt::strong_ordering compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T *> rhs)

Implementiert einen Drei-Wege-Vergleich von ` std::nullptr_t ` mit einem in ` Qt::totally_ordered_wrapper` verpackten Zeiger.

Gibt eine Instanz von ` Qt::strong_ordering ` zurück, die die Beziehung zwischen ` lhs ` und ` rhs` darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

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

Führt den Drei-Wege-Vergleich auf lhs und rhs durch und gibt als Ergebnis einen der Qt-Ordnungs-Typen zurück. Diese Funktion ist sowohl für C++17 als auch für C++20 verfügbar.

Der tatsächlich zurückgegebene Typ hängt von LeftType und RightType ab.

Diese Methode entspricht

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

wobei ` Qt::compareThreeWay ` die Qt-Implementierung des Drei-Wege-Vergleichs für integrierte Typen ist.

Die freien ` compareThreeWay `-Funktionen sollten einen Drei-Wege-Vergleich für benutzerdefinierte Typen bereitstellen. Die Funktionen sollten einen der Qt-Reihenfolge-Typen zurückgeben.

Qt stellt für einige seiner Typen eine ` compareThreeWay `-Implementierung bereit.

Verwenden Sie diese Funktion vor allem in generischem Code, wenn Sie keine Kenntnisse über ` LeftType ` und ` RightType` haben.

Wenn Sie die Typen kennen, verwenden Sie

• Qt::compareThreeWay für integrierte Typen
• compareThreeWay für benutzerdefinierte Typen

Verwenden Sie „ operator<=>() “ direkt in Code, der ausschließlich mit C++20 oder höher kompiliert wird.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch Qt::partial_ordering, Qt::weak_ordering und Qt::strong_ordering.