std:: equality_comparable, std:: equality_comparable_with

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é. La comparaison d'opérandes mixtes produit des résultats équivalents à la comparaison des opérandes convertis vers leur type commun.

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

4) Le concept d'exposition uniquement __ComparisonCommonTypeWith spécifie que deux types partagent un type commun, et qu'une lvalue const ou une rvalue non-const (depuis C++23) de l'un ou l'autre 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)