std::strong_order

 

C++

Sprache

Concepts

Utilities-Bibliothek

Strings Bibliothek

Container-Bibliothek

Algorithmen-Bibliothek

Iteratoren Bibliothek

Numerik-Bibliothek

Input / Output-Bibliothek

Lokalisierungen Bibliothek

Reguläre Ausdrücke Bibliothek(C++11)

Atomare Operationen Bibliothek(C++11)

Thread Support-Bibliothek(C++11)

 

Utilities-Bibliothek

Typen Unterstützung (basic types, RTTI, type traits)

Dynamische Speicherverwaltung

Fehlerbehandlung

Programm Unterstützung

Variadic Funktionen

Datum und Uhrzeit

Funktionsobjekte

initializer_list (C++11)

bitset

hash (C++11)

Relationale Operatoren

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Paare und Tupel

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward und move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

definiert in Header <compare>
inlinenamespace/* unspecified */{     inlineconstexpr/* unspecified */ strong_order =/* unspecified */; }
Aufrufsyntax
template<class T, class U >     requires /* see below */ constexprstd::strong_ordering strong_order(T&& t, U&& u)noexcept(/* see below */);

Das Funktionstemplate vergleicht zwei Werte mit Hilfe des 3-Wegevergleichs und erzeugt ein Ergebnis vom Typ std::strong_ordering.

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

• Falls std::is_same_v<std::decay_t<T>, std::decay_t<U>>wahr ist:
  • std::strong_ordering(strong_order(t, u)), falls es ein wohlgeformter Ausdruck mit Auflösung der Überladungen innerhalb eines Kontextes, welcher keine Deklaration von std::strong_order beinhaltet, ist.
  • ansonsten, falls T ein Gleitkommazahlentype ist:
    • Falls std::numeric_limits<T>::is_iec559wahr ist, wird ein 'totalOrder'-Vergleich gemäß ISO/IEC/IEEE 60559 für Gleitkommazahlen gemacht und das Ergebnis als Type std::strong_ordering zurückgegeben. (Anmerkung: Dieser Vergleich kann zwischen der positiven und der negativen Null unterscheiden und auch zwischen NaN-Werten in verschiedenen Darstellungen),
    • ansonsten wird ein Ergebnis vom Typ std::strong_ordering zurückgegeben, welches konsistent ist mit der Ordnung, die bei den Vergleichsoperatoren von {tt|T}}s beobachtet werden kann
  • ansonsten std::strong_ordering(std::compare_three_way()(t, u)), falls es wohlgeformt ist
• In allen anderen Fällen ist der Ausdruck nicht wohlgeformt, welches zum Fehlschlagen der Substitution substitution failure führen kann, wenn es im unmittelbarem Kontexkt einer Templateinstantisierung auftrittt.

ausdrucksäquivalent

Der Ausdruck e ist ausdrucksäquivalent zum Ausdruck f, falls e und f die gleiche Wirkung haben, entweder beide Ausnahmen werfen können oder beide keine Ausnahmen werfen (d.h. noexcept(e)==noexcept(f)) und entweder beide konstante Unterausdrücke oder beide nicht-konstante Unterausdrücke.

Anpassungspunkte

Der Name std::strong_order bezeichnet einen Anpassungspunkt, der ein konstantes Funktionsobjekt eines literalensemiregulären Klassentyp ist. Zu Darstellungszwecken wird die cv-unqualifizierte Version des Typs mit __strong_order_fn bezeichnet.

Alle Instanzen von __strong_order_fn sind gleich. Die Wirkung des Aufrufens von verschiedenen Instanzen vom Typ __strong_order_fn auf den selben Argumenten ist äquivalent, unabhängig davon ob der Ausdruck, der die Instanz bezeichnet, ein lokalisierbarer oder lesbarer Wert ist und ob er eine const-Qualifikation hat oder nicht. A volatile-qualifizierte Instance muß nicht aufrufbar sein.) . Dadurch kann std::strong_order frei kopiert werden und die Kopien können beliebig ausgetauscht werden.

Bei einer gegebenen Menge von Typen Args... bildet __strong_order_fnstd::invocable<__strong_order_fn, Args...>, std::invocable<const __strong_order_fn, Args...>, std::invocable<__strong_order_fn&, Args...> und std::invocable<const __strong_order_fn&, Args...> ab, falls std::declval<Args>()... die obigen Anforderungen an Argumente von std::strong_order. Anderenfalls kein Funktionsaufrufoperator von __strong_order_fn nimmt an der Auflösung der Überladungen teil.

Anmerkungen

Strenge, totale Ordnung of IEEE-Geleitkommazahlen

Seien x und y Werte des selben IEEE-Gleitkommazahlentyps und total_order_less(x, y) der boolsche Wert, der angibt, daß x vor y kommt in der strengen, totaten Ordnung wie sie durch totalOrder in ISO/IEC/IEEE 60559 definiert ist.

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

• Falls weder x nochy NaN ist:
  • Falls x < y, dann total_order_less(x, y)==true;
  • Falls x > y, dann total_order_less(x, y)==false;
  • Falls x == y,
    • Falls x die negative Null und y die positive Null ist, dann total_order_less(x, y)==true,
    • Falls x nicht null ist und xs Exponent kleiner als ys Exponent, dann total_order_less(x, y)==(x >0) (nur sinnvoll für Gleitkommazahlen im Dezimalsystem);
• Falls entweder x oder {{tt|y} NaN ist:
  • Falls x negativ-NaN und y nicht negativ-NaN ist, dann total_order_less(x, y)==true,
  • Falls x nicht positiv-NaN und y positiv-NaN ist, dann total_order_less(x, y)==true,
• Falls beide x und y are NaNs mit dem gleichen Vorzeichen und xs Mantisse ist kleiner

als ys Mantisse, dann total_order_less(x, y)==!std::signbit(x).

Referenzen

strong_ordering (C++20)	das Ergebnis des 3-Wegevergleichs, der alle 6 Operatoren unterstützt und ersetzbar ist (Klasse)
weak_order (C++20)	führt einen 3-Wegevergleich durch und erzeugt ein Ergebnis vom Typ std::weak_ordering (Anpassungspunkt)
partial_order (C++20)	führt einen 3-Wegevergleich durch und erzeugt ein Ergebnis vom Typ std::partial_ordering (Anpassungspunkt)
compare_strong_order_fallback (C++20)	führt einen 3-Wegevergleich durch und erzeugt ein Ergebnis vom Typ std::strong_ordering auch falls operator<=> nicht verfügbar ist (Anpassungspunkt)