Namespaces
Variants

std:: strong_order

From cppreference.net
C++
Utilities library
Definiert im Header <compare>
inline namespace /* unspecified */ {

inline constexpr /* unspecified */ strong_order = /* unspecified */ ;

}
(seit C++20)
Aufrufsignatur
template < class T, class U >

requires /* siehe unten */

constexpr std:: strong_ordering strong_order ( T && t, U && u ) noexcept ( /* siehe unten */ ) ;

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

Seien t und u Ausdrücke und bezeichnen T und U jeweils decltype ( ( t ) ) und decltype ( ( u ) ) , dann ist std :: strong_order ( t, u ) ausdrucksäquivalent zu:

  • Wenn std:: is_same_v < std:: decay_t < T > , std:: decay_t < U >> true ist:
    • std:: strong_ordering ( strong_order ( t, u ) ) , falls es ein wohlgeformter Ausdruck ist, wobei die Überladungsauflösung in einem Kontext durchgeführt wird, der keine Deklaration von std::strong_order enthält,
    • andernfalls, wenn T ein Gleitkommatyp ist:
      • wenn std:: numeric_limits < T > :: is_iec559 true ist, führt den ISO/IEC/IEEE 60559 totalOrder -Vergleich von Gleitkommawerten durch und gibt das Ergebnis als Wert vom Typ std::strong_ordering zurück (Hinweis: Dieser Vergleich kann zwischen positiver und negativer Null sowie zwischen NaNs mit unterschiedlichen Darstellungen unterscheiden),
      • andernfalls liefert einen Wert vom Typ std::strong_ordering , der mit der durch die Vergleichsoperatoren von T beobachteten Ordnung konsistent ist,
    • andernfalls, std:: strong_ordering ( std:: compare_three_way ( ) ( t, u ) ) falls wohlgeformt.
  • In allen anderen Fällen ist der Ausdruck fehlerhaft, was zu Substitutionsfehlern führen kann, wenn er im unmittelbaren Kontext einer Template-Instanziierung auftritt.

Inhaltsverzeichnis

Customization Point Objects

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

Strikte Totalordnung von IEEE-Gleitkommatypen

Seien x und y Werte desselben IEEE-Gleitkommatyps, und total_order_less ( x, y ) sei das boolesche Ergebnis, das angibt, ob x in der strengen Totalordnung, die durch totalOrder in ISO/IEC/IEEE 60559 definiert ist, vor y kommt.

( total_order_less ( x, y ) || total_order_less ( y, x ) ) == false genau dann, wenn x und y dasselbe Bitmuster haben.

  • wenn weder x noch y NaN ist:
    • wenn x < y , dann total_order_less ( x, y ) == true ;
    • wenn x > y , dann total_order_less ( x, y ) == false ;
    • wenn x == y ,
      • wenn x negative Null und y positive Null ist, total_order_less ( x, y ) == true ,
      • wenn x nicht Null ist und x 's Exponentenfeld kleiner als y 's ist, dann total_order_less ( x, y ) == ( x > 0 ) (nur bedeutsam für dezimale Gleitkommazahlen);
  • wenn entweder x oder y NaN ist:
    • wenn x negatives NaN und y nicht negatives NaN ist, dann total_order_less ( x, y ) == true ,
    • wenn x nicht positives NaN und y positives NaN ist, dann total_order_less ( x, y ) == true ,
    • wenn sowohl x als auch y NaNs mit gleichem Vorzeichen sind und x 's Mantissenfeld kleiner als y 's ist, dann total_order_less ( x, y ) == ! std:: signbit ( x ) .

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 substituierbar ist
(Klasse)
(C++20)
Führt einen 3-Wege-Vergleich durch und erzeugt ein Ergebnis vom Typ std::weak_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::strong_ordering , selbst wenn operator <=> nicht verfügbar ist
(Anpassungspunktobjekt)