std::weak_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)

 

<tbody> </tbody>

definiert in Header <compare>
inline namespace /* unspecified */ { inline constexpr /* unspecified */ weak_order = /* unspecified */; }
Call signature
template< class T, class U > requires /* see below */ constexpr std::weak_ordering weak_order(T&& t, U&& u) noexcept(/* see below */);

Vergleicht zwei Werte mittel 3-Wegevergleich und erzuegt ein Ergebnis vom Typ std::weak_ordering.

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

• Falls std::is_same_v<std::decay_t<T>, std::decay_t<U>> wahr ist, gilt:
  • std::weak_ordering(weak_order(t, u)), falls es ein wohlgeformter Ausdruck unter Berücksichtigung der Auflösung für Überladung in einem Kontext, der keine Deklaration für std::weak_order beinhaltet,
  • anderenfalls, falls T eine Gleitkommazahl ist, gilt:
    • Falls std::numeric_limits<T>::is_iec559 wahr ist, wird eine Vergleich mit schwacher Ordnung für Geleitkommazahlen, wie unten beschreiben, durchgeführt und das Ergebnis als Wert vom Typ std::weak_ordering durchgeführt.
    • anderenfalls ist das Ergebnis ein Wert vom Typ std::weak_ordering, der konsistent mit der Ordnung ist, die bei Anwendung von Ts Vergleichsoperatoren entsteht.
  • anderenfalls gilt std::weak_ordering(std::compare_three_way()(t, u)), falls es wohlgeformt ist,
  • anderenfalls gilt std::weak_ordering(std::strong_order(t, u)), falls es wohlgeformt ist.
• An allen anderen Fällen ist der Ausdruck nicht wohlgeformt, welches zu einen Substitutionsfehler führen kann, wenn er im unmittelbarem Kontekt einer Templateinstantizierung steht.

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::weak_order bezeichnet einen Anpassungspunkt, der ein konstantes Funktionsobjekt eines literalen semiregulären Klassentyp ist. Zu Darstellungszwecken wird die cv-unqualifizierte Version des Typs mit __weak_order_fn bezeichnet.

Alle Instanzen von __weak_order_fn sind gleich. Die Wirkung des Aufrufens von verschiedenen Instanzen vom Typ __weak_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::weak_order frei kopiert werden und die Kopien können beliebig ausgetauscht werden.

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

Anmerkungen

Streng schwache Ordnung von IEEE-Gleitkommazahlen

Seien x und y Werte des selben IEEE-Gleitkommazahlentyps und weak_order_less(x, y) das boolsche Ergebnis, welches angibt, ob x y vorausgeht in der streng schwachen Ordnung wie definiert durch C++-Standard.

• Falls weder x noch y NaN ist, dann gilt weak_order_less(x, y) == true genau dann, wenn x < y, d.h. alle Darstellungen von gleichen Gleitkommazahlwerten sind äquivalent.
• Falls x negativ NaN ist und y nicht negativ NaN ist, dann gilt weak_order_less(x, y) == true;
• Falls x nicht positiv NaN ist und y positiv NaN ist, dann gilt weak_order_less(x, y) == true;
• Falls sowohl x als auch y NaNs mit dem gleichen Vorzeichen sind, dann gilt (weak_order_less(x, y) || weak_order_less(y, x)) == false, d.h. alle Darstellungen von NaN mit dem gleichen Vorzeichen sind gleich.

Referenzen

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