Namespaces
Variants

    std::strong_ordering

    Von de.cppreference.net
     
    C++
     
    Bibliothek der Hilfsmittel
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Hilfsmittel
    Funktionen mit variabler Argumentanzahl
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Gebräuchliche Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Definiert in Header <compare> 
    class strong_ordering;
    		(seit C++20)

    Der Klassentyp std::strong_ordering ist der Ergebnistyp eines dreiseitigen Vergleichs, der:

    • Alle sechs relationalen Operatoren zulässt (==, !=, <, <=, >, >=).
    • Substituierbarkeit impliziert: Wenn a äquivalent zu b ist, ist f(a) auch äquivalent zu f(b), wobei f eine Funktion bezeichnet, die nur den vergleichsrelevanten Zustand liest, der über die öffentlichen const-Member des Arguments zugänglich ist. Mit anderen Worten, äquivalente Werte sind nicht unterscheidbar.
    • Lässt keine nicht vergleichbaren Werte zu: genau einer von a < b, a == b oder a > b muss true sein.

    Konstanten

    Der Typ std::strong_ordering hat vier gültige Werte, implementiert als konstante statische Datenelemente seines Typs:

    Name Definition
    inline constexpr std :: strong_ordering less
    [static]
    		Ein gültiger Wert, der eine Kleiner-als-Beziehung (vorher geordnet) anzeigt
    (Öffentliche statische Member-Konstante)
    inline constexpr std :: strong_ordering equivalent
    [static]
    		Ein gültiger Wert, der Äquivalenz anzeigt (weder vorher noch nachher geordnet), gleichbedeutend mit equal
    (Öffentliche statische Member-Konstante)
    inline constexpr std :: strong_ordering equal
    [static]
    		Ein gültiger Wert, der Äquivalenz anzeigt (weder vorher noch nachher geordnet), gleichbedeutend mit equivalent
    (Öffentliche statische Member-Konstante)
    inline constexpr std :: strong_ordering greater
    [static]
    		Ein gültiger Wert, der eine Größer-als-Beziehung (nachher geordnet) anzeigt
    (Öffentliche statische Member-Konstante)

    Konvertierungen

    std::strong_ordering ist der stärkste der drei Vergleichskategorien: Es ist nicht implizit konvertierbar von einer anderen Kategorie und ist implizit konvertierbar zu den anderen beiden.

    operator partial_ordering
    		implizite Konvertierung zu std::partial_ordering
    (öffentliche Elementfunktion)

    std::strong_ordering:: operator partial_ordering

    constexpr operator partial_ordering ( ) const noexcept ;

    Rückgabewert

    std::partial_ordering::less falls v less ist, std::partial_ordering::greater falls v greater ist, std::partial_ordering::equivalent falls v equal oder equivalent ist.

    operator weak_ordering
    		implizite Konvertierung zu std::weak_ordering
    (öffentliche Elementfunktion)

    std::strong_ordering:: operator weak_ordering

    constexpr operator weak_ordering ( ) const noexcept ;

    Rückgabewert

    std::weak_ordering::less falls v less ist, std::weak_ordering::greater falls v greater ist, std::weak_ordering::equivalent falls v equal oder equivalent ist.

    Vergleiche

    Vergleichsoperatoren sind zwischen Werten dieses Typs und dem Literal ​ 0 ​ definiert. Dies unterstützt die Ausdrücke a <=> b == 0 oder a <=> b < 0 , die verwendet werden können, um das Ergebnis eines Drei-Wege-Vergleichsoperators in eine boolesche Relation umzuwandeln; siehe std::is_eq , std::is_lt , etc.

    Diese Funktionen sind für gewöhnliches unqualified oder qualified lookup nicht sichtbar und können nur durch argument-dependent lookup gefunden werden, wenn std::strong_ordering eine assoziierte Klasse der Argumente ist.

    Das Verhalten eines Programms, das versucht, einen strong_ordering mit etwas anderem als dem ganzzahligen Literal ​ 0 ​ zu vergleichen, ist undefiniert.

    operator== operator< operator> operator<= operator>= operator<=>
    		vergleicht mit Null oder einem strong_ordering
    (Funktion)

    operator==

    friend constexpr bool
    operator == ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr bool
    operator == ( strong_ordering v, strong_ordering w ) noexcept = default ;
    		(2)

    Parameter

    v, w - std::strong_ordering Werte zur Überprüfung
    u - ein ungenutzter Parameter beliebigen Typs, der das Literal Null akzeptiert

    Rückgabewert

    1) true wenn v equivalent oder equal ist, false wenn v less oder greater ist
    2) true wenn beide Parameter denselben Wert enthalten, false andernfalls. Beachten Sie, dass equal dasselbe wie equivalent ist.

    operator<

    friend constexpr bool operator < ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr bool operator < ( /*unspecified*/ u, strong_ordering v ) noexcept ;
    		(2)

    Parameter

    v - ein std::strong_ordering -Wert zur Überprüfung
    u - ein unbenutzter Parameter beliebigen Typs, der das Literal Null akzeptiert

    Rückgabewert

    1) true wenn v less ist, und false wenn v greater , equivalent oder equal ist
    2) true wenn v greater ist, und false wenn v less , equivalent oder equal ist

    operator<=

    friend constexpr bool operator <= ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr bool operator <= ( /*unspecified*/ u, strong_ordering v ) noexcept ;
    		(2)

    Parameter

    v - ein std::strong_ordering -Wert zur Überprüfung
    u - ein unbenutzter Parameter beliebigen Typs, der das Literal Null als Argument akzeptiert

    Rückgabewert

    1) true wenn v less , equivalent oder equal ist, und false wenn v greater ist
    2) true wenn v greater , equivalent oder equal ist, und false wenn v less ist

    operator>

    friend constexpr bool operator > ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr bool operator > ( /*unspecified*/ u, strong_ordering v ) noexcept ;
    		(2)

    Parameter

    v - ein std::strong_ordering -Wert zur Überprüfung
    u - ein unbenutzter Parameter beliebigen Typs, der das Literal Null akzeptiert

    Rückgabewert

    1) true wenn v greater ist, und false wenn v less , equivalent oder equal ist
    2) true wenn v less ist, und false wenn v greater , equivalent oder equal ist

    operator>=

    friend constexpr bool operator >= ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr bool operator >= ( /*unspecified*/ u, strong_ordering v ) noexcept ;
    		(2)

    Parameter

    v - ein std::strong_ordering -Wert zur Überprüfung
    u - ein unbenutzter Parameter beliebigen Typs, der das Literal Null akzeptiert

    Rückgabewert

    1) true wenn v greater , equivalent oder equal ist, und false wenn v less ist
    2) true wenn v less , equivalent oder equal ist, und false wenn v greater ist

    operator<=>

    friend constexpr strong_ordering
    operator <=> ( strong_ordering v, /*unspecified*/ u ) noexcept ;
    		(1)
    friend constexpr strong_ordering
    operator <=> ( /*unspecified*/ u, strong_ordering v ) noexcept ;
    		(2)

    Parameter

    v - ein std::strong_ordering -Wert zur Überprüfung
    u - ein unbenutzter Parameter beliebigen Typs, der das Literal Null als Argument akzeptiert

    Rückgabewert

    1) v .
    2) greater falls v less ist, less falls v greater ist, andernfalls v .

    Beispiel

    Diesen Code ausführen 
    #include <compare>
#include <iostream>
struct Point
{
    int x{}, y{};
    friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs)
    {
        if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y))
            return std::strong_ordering::less;
        if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y))
            return std::strong_ordering::greater;
        return std::strong_ordering::equivalent;
    }
    friend std::ostream& operator<<(std::ostream& os, Point s)
    {
        return os << '(' << s.x << ',' << s.y << ')';
    }
};
void print_three_way_comparison(const auto& p, const auto& q)
{
    const auto cmp{p <=> q};
    std::cout << p
              << (cmp < 0 ? " <  " : cmp > 0 ? " >  " : " == " ) // vergleicht mit 0
              << q << '\n';
}
void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // vergleicht p und q
              << q << '\n';
}
int main()
{
    const Point p1{0, 1}, p2{0, 1}, p3{0, 2};
    print_three_way_comparison(p1, p2);
    print_two_way_comparison(p1, p2);
    print_three_way_comparison(p2, p3);
    print_two_way_comparison(p2, p3);
    print_three_way_comparison(p3, p2);
    print_two_way_comparison(p3, p2);
}

    Ausgabe: 

    (0,1) == (0,1)
(0,1) == (0,1)
(0,1) <  (0,2)
(0,1) <  (0,2)
(0,2) >  (0,1)
(0,2) >  (0,1)

    Siehe auch

    (C++20)
    		Der Ergebnistyp des 3-Wege-Vergleichs, der alle 6 Operatoren unterstützt und nicht substituierbar ist
    (Klasse)
    (C++20)
    		Der Ergebnistyp des 3-Wege-Vergleichs, der alle 6 Operatoren unterstützt, nicht substituierbar ist und unvergleichbare Werte erlaubt
    (Klasse)