Namespaces
Variants

    std::weak_order

    Von de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programm-Hilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-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)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Definiert in Header <compare> 
    inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ weak_order = /* unspecified */;
}
    		(seit C++20)
    Aufrufsignatur
    		 
    template< class T, class U >
    requires /* see below */
constexpr std::weak_ordering weak_order(T&& t, U&& u) noexcept(/* see below */);

    Vergleicht zwei Werte mittels Drei-Wege-Vergleich und erzeugt ein Ergebnis vom Typ std::weak_ordering.

    Seien t und u Ausdrücke und T und U bezeichne decltype((t)) bzw. decltype((u)), so ist std::weak_order(t, u) ausdrucksäquivalent zu:

    • Falls std::is_same_v<std::decay_t<T>, std::decay_t<U>> ist true:
      • std::weak_ordering(weak_order(t, u)), wenn es ein wohlgeformter Ausdruck ist, bei dem die Überladungsauflösung in einem Kontext durchgeführt wird, der keine Deklaration von std::weak_order enthält,
      • andernfalls, falls T ein Gleitkommatyp ist:
        • falls std::numeric_limits<T>::is_iec559 ist true, führt die schwache Ordnungsvergleichsoperation für Gleitkommawerte durch (siehe unten) und gibt dieses Ergebnis als Wert vom Typ std::weak_ordering zurück,
        • andernfalls ergibt es einen Wert vom Typ std::weak_ordering, der mit der durch die Vergleichsoperatoren von T beobachteten Ordnung konsistent ist,
      • andernfalls std::weak_ordering(std::compare_three_way()(t, u)), falls es wohlgeformt ist,
      • andernfalls std::weak_ordering(std::strong_order(t, u)), falls es wohlgeformt ist.
    • In allen anderen Fällen ist der Ausdruck nicht wohlgeformt, was zu Substitutionsfehler führen kann, wenn er im unmittelbaren Kontext einer Template-Instantiierung auftritt.

    Customization Point Objects

    Der Name std::weak_order bezeichnet ein Customization Point Object , welches ein konstantes Funktionsobjekt eines Literal semiregular Klassentyps ist. Weitere Details finden Sie unter CustomizationPointObject .

    Strikte schwache Ordnung von IEEE-Gleitkommatypen

    Seien x und y Werte desselben IEEE-Gleitkommatyps, und weak_order_less ( x, y ) sei das boolesche Ergebnis, das angibt, ob x in der strengen schwachen Ordnung, die durch den C++-Standard definiert ist, vor y kommt.

    • Wenn weder x noch y NaN ist, dann ist weak_order_less ( x, y ) == true genau dann, wenn x < y , d.h. alle Darstellungen gleicher Fließkommawerte sind äquivalent;
    • Wenn x negatives NaN ist und y nicht negatives NaN ist, dann ist weak_order_less ( x, y ) == true ;
    • Wenn x nicht positives NaN ist und y positives NaN ist, dann ist weak_order_less ( x, y ) == true ;
    • Wenn sowohl x als auch y NaNs mit demselben Vorzeichen sind, dann ist ( weak_order_less ( x, y ) || weak_order_less ( y, x ) ) == false , d.h. alle NaNs mit demselben Vorzeichen sind äquivalent.

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    (C++20)
    		der Ergebnistyp des 3-Wege-Vergleichs, der alle 6 Operatoren unterstützt und nicht substituierbar ist
    (Klasse)
    (C++20)
    		führt einen 3-Wege-Vergleich durch und erzeugt ein Ergebnis vom Typ std::strong_ordering
    (Anpassungspunktobjekt)
    (C++20)
    		führt einen 3-Wege-Vergleich durch und erzeugt ein Ergebnis vom Typ std::partial_ordering
    (Anpassungspunktobjekt)
    (C++20)
    		führt einen 3-Wege-Vergleich durch und erzeugt ein Ergebnis vom Typ std::weak_ordering , selbst wenn operator <=> nicht verfügbar ist
    (Anpassungspunktobjekt)