Difference between revisions of "cpp/concepts/equality comparable"
Andreas Krug (Talk | contribs) m (satisified -> satisfied) |
Andreas Krug (Talk | contribs) m (Space added: t != u,u != t -> t != u, u != t) |
||
| Line 51: | Line 51: | ||
* {{tt|u}}, an lvalue of type {{c|const std::remove_reference_t<U>}}, | * {{tt|u}}, an lvalue of type {{c|const std::remove_reference_t<U>}}, | ||
the following are true: | the following are true: | ||
| − | * {{c|1=t == u}}, {{c|1=u == t}}, {{c|1=t != u}},{{c|1=u != t}} have the same domain; | + | * {{c|1=t == u}}, {{c|1=u == t}}, {{c|1=t != u}}, {{c|1=u != t}} have the same domain; |
* {{c|1=bool(u == t) == bool(t == u)}}; | * {{c|1=bool(u == t) == bool(t == u)}}; | ||
* {{c|1=bool(t != u) == !bool(t == u)}}; and | * {{c|1=bool(t != u) == !bool(t == u)}}; and | ||
Revision as of 07:45, 6 February 2023
| Defined in header <concepts>
|
||
| template < class T > concept equality_comparable = __WeaklyEqualityComparableWith<T, T>; |
(1) | (since C++20) |
| template <class T, class U> concept equality_comparable_with = |
(2) | (since C++20) |
| template<class T, class U> concept __WeaklyEqualityComparableWith = // exposition only |
(3) | (since C++20) |
std::equality_comparable specifies that the comparison operators == and != on T reflects equality: == yields true if and only if the operands are equal.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.__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. Semantic requirements
These concepts are modeled only if they are satisfied and all concepts they subsume are modeled.
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.t of type const std::remove_reference_t<T> and any lvalue u of type const std::remove_reference_t<U>, and let C be std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>, bool(t == u) == bool(C(t) == C(u)).-
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).
Equality preservation
Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).
Implicit expression variations
A requires expression that uses an expression that is non-modifying for some constant lvalue operand also requires implicit expression variations.
