Namensräume
Varianten

    std::compare_weak_order_fallback

    Aus cppreference.com
     
    C++
     
    Utilities-Bibliothek
     
    <tbody> </tbody>
    definiert in Header <compare>
    inline namespace /* unspecified */ { inline constexpr /* unspecified */ compare_weak_order_fallback = /* unspecified */; }
    Call signature
    template< class T, class U > requires /* see below */ constexpr std::weak_ordering compare_weak_order_fallback(T&& t, U&& u) noexcept(/* 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ß t und u nur einmal evaluiert werden.
    • 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.

    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::compare_weak_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_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_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...> 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.

    Beispiele

    #include <iostream>
#include <compare>

// 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;
}

void print(std::weak_ordering value)
{
    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};
    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

    Referenzen

    (C++20)
    		 führt einen 3-Wegevergleich durch und erzeugt ein Ergebnis vom Typ std::weak_ordering
    (Anpassungspunkt) [edit]