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) Le concept std::equality_comparable spécifie que les opérateurs de comparaison == et != sur T reflètent l'égalité : == donne true si et seulement si les opérandes sont égaux.

2) Le concept std::equality_comparable_with spécifie que les opérateurs de comparaison == et != sur des opérandes (éventuellement mixtes) T et U produisent des résultats cohérents avec l'égalité. Comparer des opérandes mixtes donne des résultats équivalents à la comparaison des opérandes convertis à leur type commun.

3) Le concept exposé uniquement __WeaklyEqualityComparableWith spécifie qu'un objet de type T et un objet de type U peuvent être comparés pour l'égalité entre eux (dans les deux ordres) en utilisant à la fois == et !=, et les résultats des comparaisons sont cohérents.

4) Le concept exposé uniquement __ComparisonCommonTypeWith spécifie que deux types partagent un type commun, et une lvalue const ou une rvalue non-const(depuis C++23) de chaque type est convertible en ce type commun.

1) std :: equality_comparable < T > est modélisé seulement si, étant donné les objets a et b de type T , bool ( a == b ) est true si et seulement si a et b sont égaux. Conjointement avec l'exigence que a == b soit préservateur d'égalité , cela implique que == est symétrique et transitif, et de plus que == est réflexif pour tous les objets a qui sont égaux à au moins un autre objet.

2) std :: equality_comparable_with < T, U > est modélisé seulement si, soit

• t et t2 des lvalues désignant des objets distincts égaux de types const std:: remove_reference_t < T > et std:: remove_cvref_t < T > respectivement,
• u et u2 des lvalues désignant des objets distincts égaux de types const std:: remove_reference_t < U > et std:: remove_cvref_t < U > respectivement,
• C soit std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > ,

l'expression suivante est vraie :

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

3) __WeaklyEqualityComparableWith < T, U > est modélisé seulement si, étant donnés

• t , une lvalue de type const std:: remove_reference_t < T > et
• u , une lvalue de type const std:: remove_reference_t < U > ,

les conditions suivantes sont vraies :

• t == u , u == t , t ! = u , u ! = t ont le même domaine ;
• bool ( u == t ) == bool ( t == u ) ;
• bool ( t ! = u ) == ! bool ( t == u ) ; et
• bool ( u ! = t ) == bool ( t ! = u ) .

4) __WeaklyEqualityComparableWith < T, U > est modélisé seulement si :

Le concept correspondant common_reference_with est modélisé.

(jusqu'à C++23)

Soient C le type std:: common_reference_t < const T & , const U & > , t1 et t2 des expressions préservant l'égalité qui sont des lvalues de type std:: remove_cvref_t < T > , u1 et u2 des expressions préservant l'égalité qui sont des lvalues de type std:: remove_cvref_t < U > , les conditions suivantes sont satisfaites : CONVERT_TO < C > ( t1 ) est égal à CONVERT_TO < C > ( t2 ) si et seulement si t1 est égal à t2 ; et CONVERT_TO < C > ( u1 ) est égal à CONVERT_TO < C > ( u2 ) si et seulement si u1 est égal à u2 .

(depuis C++23)