std:: equality_comparable, std:: equality_comparable_with

1) The concept std::equality_comparable specifies that the comparison operators == and != on T reflects equality: == yields true if and only if the operands are equal.

2) The concept std::equality_comparable_with specifies that the comparison operators == and != on (possibly mixed) T and U operands yield results consistent with equality. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.

3) The exposition-only concept __WeaklyEqualityComparableWith specifies that an object of type T and an object of type U can be compared for equality with each other (in either order) using both == and != , and the results of the comparisons are consistent.

4) The exposition-only concept __ComparisonCommonTypeWith specifies that two types share a common type, and a const lvalue or a non-const rvalue (since C++23) of either type is convertible to that common type.

1) std :: equality_comparable < T > is modeled only if, given objects a and b of type T , bool ( a == b ) is true if and only if a and b are equal. Together with the requirement that a == b is equality-preserving , this implies that == is symmetric and transitive, and further that == is reflexive for all objects a that are equal to at least one other object.

2) std :: equality_comparable_with < T, U > is modeled only if, let

• t and t2 be lvalues denoting distinct equal objects of types const std:: remove_reference_t < T > and std:: remove_cvref_t < T > respectively,
• u and u2 be lvalues denoting distinct equal objects of types const std:: remove_reference_t < U > and std:: remove_cvref_t < U > respectively,
• C be std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > ,

the following expression is true:

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

3) __WeaklyEqualityComparableWith < T, U > is modeled only if given

• t , an lvalue of type const std:: remove_reference_t < T > and
• u , an lvalue of type const std:: remove_reference_t < U > ,

the following are true:

• t == u , u == t , t ! = u , u ! = t have the same domain;
• bool ( u == t ) == bool ( t == u ) ;
• bool ( t ! = u ) == ! bool ( t == u ) ; and
• bool ( u ! = t ) == bool ( t ! = u ) .

4) __WeaklyEqualityComparableWith < T, U > is modeled only if:

The corresponding common_reference_with concept is modeled.

(until C++23)

Let C be std:: common_reference_t < const T & , const U & > , t1 and t2 be equality-preserving expressions that are lvalues of type std:: remove_cvref_t < T > , u1 and u2 be equality-preserving expressions that are lvalues of type std:: remove_cvref_t < U > , the following conditions hold: CONVERT_TO < C > ( t1 ) equals CONVERT_TO < C > ( t2 ) if and only if t1 equals t2 ; and CONVERT_TO < C > ( u1 ) equals CONVERT_TO < C > ( u2 ) if and only if u1 equals u2 .

(since C++23)