std::equality_comparable, std::equality_comparable_with

template< class T >
concept equality_comparable = __WeaklyEqualityComparableWith<T, T>;

template< class T, class U >
concept equality_comparable_with =
    std::equality_comparable<T> &&
    std::equality_comparable<U> &&
    __ComparisonCommonTypeWith<T, U> &&
    std::equality_comparable<
        std::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>> &&
    __WeaklyEqualityComparableWith<T, U>;

template< class T, class U >
concept __WeaklyEqualityComparableWith =
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
        { t == u } -> boolean-testable;
        { t != u } -> boolean-testable;
        { u == t } -> boolean-testable;
        { u != t } -> boolean-testable;
    };

template< class T, class U >
concept __ComparisonCommonTypeWith =
    std::common_reference_with<
        const std::remove_reference_t<T>&,
        const std::remove_reference_t<U>&>;

template< class T, class U, class C = std::common_reference_t<const T&, const U&> >
concept _ComparisonCommonTypeWithImpl =
    std::same_as<std::common_reference_t<const T&, const U&>,
                 std::common_reference_t<const U&, const T&>> &&
    requires {
        requires std::convertible_to<const T&, const C&> ||
            std::convertible_to<T, const C&>;
        requires std::convertible_to<const U&, const C&> ||
            std::convertible_to<U, const C&>;
    };
template< class T, class U >
concept __ComparisonCommonTypeWith =
    _ComparisonCommonTypeWithImpl<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;

1) Das Konzept std::equality_comparable legt fest, dass die Vergleichsoperatoren == und != auf T die Gleichheit widerspiegeln: == ergibt true genau dann, wenn die Operanden gleich sind.

2) Das Konzept std::equality_comparable_with legt fest, dass die Vergleichsoperatoren == und != auf (möglicherweise gemischten) T und U Operanden Ergebnisse liefern, die mit der Gleichheit konsistent sind. Der Vergleich gemischter Operanden liefert Ergebnisse, die dem Vergleich der in ihren gemeinsamen Typ konvertierten Operanden entsprechen.

3) Das nur zur Veranschaulichung dienende Konzept __WeaklyEqualityComparableWith legt fest, dass ein Objekt vom Typ T und ein Objekt vom Typ U mit beiden Operatoren == und != auf Gleichheit miteinander (in beliebiger Reihenfolge) verglichen werden können, und die Ergebnisse der Vergleiche sind konsistent.

4) Das nur zur Veranschaulichung dienende Konzept __ComparisonCommonTypeWith legt fest, dass zwei Typen einen gemeinsamen Typ teilen, und ein const lvalue oder ein nicht-const rvalue(seit C++23) jedes der beiden Typen in diesen gemeinsamen Typ konvertierbar ist.

1) std :: equality_comparable < T > wird nur dann modelliert, wenn für Objekte a und b vom Typ T , bool ( a == b ) genau dann true ist, wenn a und b gleich sind. Zusammen mit der Anforderung, dass a == b gleichheitserhaltend ist, impliziert dies, dass == symmetrisch und transitiv ist, und weiterhin, dass == reflexiv für alle Objekte a ist, die zu mindestens einem anderen Objekt gleich sind.

2) std :: equality_comparable_with < T, U > wird nur modelliert, wenn, seien

• t und t2 Lvalues, die unterschiedliche gleiche Objekte der Typen const std:: remove_reference_t < T > und std:: remove_cvref_t < T > bezeichnen,
• u und u2 Lvalues, die unterschiedliche gleiche Objekte der Typen const std:: remove_reference_t < U > und std:: remove_cvref_t < U > bezeichnen,
• C sei std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > ,

der folgende Ausdruck wahr ist:

• bool ( t == u ) == bool ( CONVERT_TO < C > ( t2 ) == CONVERT_TO < C > ( u2 ) ) .

3) __WeaklyEqualityComparableWith < T, U > wird nur modelliert, wenn gegeben

• t , ein Lvalue vom Typ const std:: remove_reference_t < T > und
• u , ein Lvalue vom Typ const std:: remove_reference_t < U > ,

Folgendes zutrifft:

• t == u , u == t , t ! = u , u ! = t dieselbe Domäne haben;
• bool ( u == t ) == bool ( t == u ) ;
• bool ( t ! = u ) == ! bool ( t == u ) ; und
• bool ( u ! = t ) == bool ( t ! = u ) .

4) __WeaklyEqualityComparableWith < T, U > wird nur modelliert, wenn:

Das entsprechende common_reference_with -Konzept modelliert wird.

(bis C++23)

Seien C std:: common_reference_t < const T & , const U & > , t1 und t2 gleichheitserhaltende Ausdrücke, die Lvalues vom Typ std:: remove_cvref_t < T > sind, u1 und u2 gleichheitserhaltende Ausdrücke, die Lvalues vom Typ std:: remove_cvref_t < U > sind, dann gelten folgende Bedingungen: CONVERT_TO < C > ( t1 ) gleich CONVERT_TO < C > ( t2 ) genau dann, wenn t1 gleich t2 ist; und CONVERT_TO < C > ( u1 ) gleich CONVERT_TO < C > ( u2 ) genau dann, wenn u1 gleich u2 ist.

(seit C++23)