std::compare_weak_order_fallback
definiert in Header <compare> | ||
inlinenamespace/* unspecified */{ inlineconstexpr/* unspecified */ | ||
Call signature | ||
template<class T, class U > requires /* see below */ | ||
Führt einen 3-Wegevergleich zwischen t und u durch und erzeugt ein Ergebnis vom Typ std::weak_ordering auch wenn der Operator<=> nicht verfügbar ist.
Seien t und u Ausdrücke, T und U definiert durch decltype((t)) bzw. decltype((u)), dann ist std::compare_weak_order_fallback(t, u) ausdrucksäquivalent zu:
- Falls std::is_same_v<std::decay_t<T>, std::decay_t<U>>wahr ist:
- std::weak_order(t, u), falls es wohlgeformt ist;
- anderenfalls
t == u ? std::weak_ordering::equivalent: t < u ? std::weak_ordering::less: std::weak_ordering::greater
- falls t == u und t < u wohlgeformt udn konvertierbar nach bool sind, mit der Ausnahme, daß
tundunur einmal evaluiert werden.
- falls t == u und t < u wohlgeformt udn konvertierbar nach bool sind, mit der Ausnahme, daß
- In allen anderen Fällen ist der Ausdruck std::compare_weak_order_fallback(t, u) nicht wohlgeformt, welches zu einen Substitutionsfehler führen kann, wenn er im unmittelbarem Kontekt einer Templateinstantizierung steht.
Inhaltsverzeichnis |
[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_weak_order_fallback bezeichnet einen Anpassungspunkt, der ein konstantes Funktionsobjekt eines literalensemiregulären Klassentyp ist. Zu Darstellungszwecken wird die cv-unqualifizierte Version des Typs mit __compare_weak_order_fallback_fn bezeichnet.
Alle Instanzen von __compare_weak_order_fallback_fn sind gleich. Die Wirkung des Aufrufens von verschiedenen Instanzen vom Typ __compare_weak_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_weak_order_fallback frei kopiert werden und die Kopien können beliebig ausgetauscht werden.
Bei einer gegebenen Menge von Typen Args... bildet __compare_weak_order_fallback_fnstd::invocable<__compare_weak_order_fallback_fn, Args...>, std::invocable<const __compare_weak_order_fallback_fn, Args...>, std::invocable<__compare_weak_order_fallback_fn&, Args...> und std::invocable<const __compare_weak_order_fallback_fn&, Args...> ab, falls std::declval<Args>()... die obigen Anforderungen an Argumente von std::compare_weak_order_fallback. Anderenfalls kein Funktionsaufrufoperator von __compare_weak_order_fallback_fn nimmt an der Auflösung der Überladungen teil.
[Bearbeiten] Beispiele
#include <iostream>#include <compare> // does not support <=>struct Rational_1 {int num;int den;// > 0}; inlineconstexprbool operator<(Rational_1 lhs, Rational_1 rhs){return lhs.num* rhs.den< rhs.num* lhs.den;} inlineconstexprbool operator==(Rational_1 lhs, Rational_1 rhs){return lhs.num* rhs.den== rhs.num* lhs.den;} // supports <=>struct Rational_2 {int num;int den;// > 0}; inlineconstexprstd::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs){return lhs.num* rhs.den<=> rhs.num* lhs.den;} void print(std::weak_ordering value){if(value ==0)std::cout<<"equal\n";elseif(value <0)std::cout<<"less\n";elsestd::cout<<"greater\n";} int main(){ Rational_1 a{1, 2}; Rational_1 b{3, 4};// print(a <=> b); // doesn't work print(std::compare_weak_order_fallback(a, b));// works, defaults to < and == Rational_2 c{6, 5}; Rational_2 d{8, 7}; print(c <=> d);// works print(std::compare_weak_order_fallback(c, d));// works}
Output:
less greater greater
[Bearbeiten] Referenzen
(C++20) | führt einen 3-Wegevergleich durch und erzeugt ein Ergebnis vom Typ std::weak_ordering(Anpassungspunkt) |
