std::compare_weak_order_fallback

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definiert in der Header-Datei <compare>
inline namespace /* nicht spezifiziert */ {     inline constexpr /* nicht spezifiziert */         compare_weak_order_fallback = /* nicht spezifiziert */; }		(seit C++20)
Aufruf-Signatur
template< class T, class U >     requires /* siehe unten */ constexpr std::weak_ordering     compare_weak_order_fallback( T&& t, U&& u ) noexcept(/* siehe unten */);		(seit C++20)

Führt einen Drei-Wege-Vergleich für die Teilausdrücke t und u durch und erzeugt ein Ergebnis vom Typ std::weak_ordering, auch wenn der Operator <=> nicht verfügbar ist.

Wenn std::decay_t<T> und std::decay_t<U> denselben Typ haben, ist std::compare_weak_order_fallback(t, u) ausdrucksäquivalent zu

• std::weak_order(t, u), wenn dies ein wohlgeformter Ausdruck ist; andernfalls
• t == u ? std::weak_ordering::equivalent :
  t <  u ? std::weak_ordering::less :
           std::weak_ordering::greater, wenn die Ausdrücke t == u und t < u beide wohlgeformt sind und jeweils decltype(t == u) und decltype(t < u) boolean-testable modellieren, außer dass t und u nur einmal ausgewertet werden.

In allen anderen Fällen ist std::compare_weak_order_fallback(t, u) schlecht geformt, was zu einem Substitutionsfehler führen kann, wenn er im unmittelbaren Kontext einer Templatinstanziierung auftritt.

Customization Point Objects

Der Name std::compare_weak_order_fallback bezeichnet ein Customization Point Object, ein konstantes Funktionsobjekt eines literalen semiregular Klassentyps. Zu Auslegungszwecken wird die cv-unqualifizierte Version seines Typs als __compare_weak_order_fallback_fn bezeichnet.

Alle Instanzen von __compare_weak_order_fallback_fn sind gleich. Die Auswirkungen des Aufrufs verschiedener Instanzen des Typs __compare_weak_order_fallback_fn mit denselben Argumenten sind äquivalent, unabhängig davon, ob der den Instanz bezeichnende Ausdruck ein lvalue oder ein rvalue ist und ob er mit const qualifiziert ist oder nicht (eine mit volatile qualifizierte Instanz muss jedoch nicht aufrufbar sein). Daher kann std::compare_weak_order_fallback frei kopiert werden und seine Kopien können austauschbar verwendet werden.

Gegeben sei eine Menge von Typen Args.... Wenn std::declval<Args>()... die Anforderungen für Argumente an std::compare_weak_order_fallback oben erfüllt, modelliert __compare_weak_order_fallback_fn

• std::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...>.
  

Andernfalls nimmt kein Funktionsoperator von __compare_weak_order_fallback_fn an der Überladungsauflösung teil.

Beispiel

Führen Sie diesen Code aus

#include <compare>
#include <iostream>
 
// does not support <=>
struct Rational_1
{
    int num;
    int den; // > 0
};
 
inline constexpr bool operator<(Rational_1 lhs, Rational_1 rhs)
{
    return lhs.num * rhs.den < rhs.num * lhs.den;
}
 
inline constexpr bool 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
};
 
inline constexpr std::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs)
{
    return lhs.num * rhs.den <=> rhs.num * lhs.den;
}
 
inline constexpr bool operator==(Rational_2 lhs, Rational_2 rhs)
{
    return lhs <=> rhs == 0;
}
 
void print(int id, std::weak_ordering value)
{
    std::cout << id << ") ";
    if (value == 0)
        std::cout << "equal\n";
    else if (value < 0)
        std::cout << "less\n";
    else
        std::cout << "greater\n";
}
 
int main()
{
    Rational_1 a{1, 2}, b{3, 4};
//  print(0, a <=> b); // does not work
    print(1, std::compare_weak_order_fallback(a, b)); // works, defaults to < and ==
 
    Rational_2 c{6, 5}, d{8, 7};
    print(2, c <=> d); // works
    print(3, std::compare_weak_order_fallback(c, d)); // works
 
    Rational_2 e{2, 3}, f{4, 6};
    print(4, e <=> f); // works
    print(5, std::compare_weak_order_fallback(e, f)); // works
}

Ausgabe

1) less
2) greater
3) greater
4) equal
5) equal

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2114 (P2167R3)	C++20	der Fallback-Mechanismus erforderte nur Rückgabetypen konvertierbar zu bool waren	Einschränkungen verstärkt

Siehe auch

weak_order (C++20)

führt einen 3-Wege-Vergleich durch und erzeugt ein Ergebnis vom Typ std::weak_ordering (Customization Point Objekt)