std::compare_partial_order_fallback

Führt einen 3-Wegevergleich zwischen t und u aus und erzeugt ein Ergebnis vom Typ std::partial_ordering auch wenn der Operator<=> nicht verfügbar ist.

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

• Falls std::is_same_v<std::decay_t<T>, std::decay_t<U>> wahr ist:
  • std::partial_order(t, u), falls wohlgeformt;
  • anderenfalls

t == u ? std::partial_ordering::equivalent :
t < u  ? std::partial_ordering::less :
u < t  ? std::partial_ordering::greater :
         std::partial_ordering::unordered

falls t == u, t < u, und u < t wohlgeformt und konvertierbar zu bool, mit der Ausnahme, daß t und u nur einmal evaluiert werden.

• In allen anderen Fällen ist der Ausdruck std::compare_partial_order_fallback(t, u) nicht wohlgeformt, welches zu einen Substitutionsfehler führen kann, wenn er im unmittelbarem Kontekt einer Templateinstanzisierung steht.

[Bearbeiten] 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.

[Bearbeiten] Anpassungspunkte

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

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

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

[Bearbeiten] Beispiele

[Bearbeiten] Referenzen