17 Concepts library [concepts]

17.5 Comparison concepts [concepts.compare]

17.5.1 General [concepts.compare.general]

1
#
This subclause describes concepts that establish relationships and orderings on values of possibly differing object types.

17.5.2 Concept Boolean [concept.boolean]

1
#
The Boolean concept specifies the requirements on a type that is usable in Boolean contexts.
🔗
template<class B> concept Boolean = Movable<remove_cvref_t<B>> && // (see [concepts.object]) requires(const remove_reference_t<B>& b1, const remove_reference_t<B>& b2, const bool a) { requires ConvertibleTo<const remove_reference_t<B>&, bool>; !b1; requires ConvertibleTo<decltype(!b1), bool>; b1 && a; requires Same<decltype(b1 && a), bool>; b1 || a; requires Same<decltype(b1 || a), bool>; b1 && b2; requires Same<decltype(b1 && b2), bool>; a && b2; requires Same<decltype( a && b2), bool>; b1 || b2; requires Same<decltype(b1 || b2), bool>; a || b2; requires Same<decltype( a || b2), bool>; b1 == b2; requires ConvertibleTo<decltype(b1 == b2), bool>; b1 == a; requires ConvertibleTo<decltype(b1 == a), bool>; a == b2; requires ConvertibleTo<decltype( a == b2), bool>; b1 != b2; requires ConvertibleTo<decltype(b1 != b2), bool>; b1 != a; requires ConvertibleTo<decltype(b1 != a), bool>; a != b2; requires ConvertibleTo<decltype( a != b2), bool>; };
2
#
Let b1 and b2 be lvalues of type const remove_­reference_­t<B>.
Boolean<B> is satisfied only if
  • (2.1)
    bool(b1) == !bool(!b1).
  • (2.2)
    (b1 && b2), (b1 && bool(b2)), and (bool(b1) && b2) are all equal to (bool(b1) && bool(b2)), and have the same short-circuit evaluation.
  • (2.3)
    (b1 || b2), (b1 || bool(b2)), and (bool(b1) || b2) are all equal to (bool(b1) || bool(b2)), and have the same short-circuit evaluation.
  • (2.4)
    bool(b1 == b2), bool(b1 == bool(b2)), and bool(bool(b1) == b2) are all equal to (bool(b1) == bool(b2)).
  • (2.5)
    bool(b1 != b2), bool(b1 != bool(b2)), and bool(bool(b1) != b2) are all equal to (bool(b1) != bool(b2)).
3
#
[ Example
:
The types bool, true_­type ([meta.type.synop]), and bitset<N>​::​reference ([template.bitset]) are Boolean types.
Pointers, smart pointers, and types with only explicit conversions to bool are not Boolean types.
— end example
 ]

17.5.3 Concept EqualityComparable [concept.equalitycomparable]

🔗
template<class T, class U> concept weakly-equality-comparable-with = // exposition only requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { t == u; requires Boolean<decltype(t == u)>; t != u; requires Boolean<decltype(t != u)>; u == t; requires Boolean<decltype(u == t)>; u != t; requires Boolean<decltype(u != t)>; };
1
#
Let t and u be lvalues of types const remove_­reference_­t<T> and const remove_­reference_­t<U> respectively.
weakly-equality-comparable-with<T, U> is satisfied only if:
  • (1.1)
    t == u, u == t, t != u, and u != t have the same domain.
  • (1.2)
    bool(u == t) == bool(t == u).
  • (1.3)
    bool(t != u) == !bool(t == u).
  • (1.4)
    bool(u != t) == bool(t != u).
🔗
template<class T> concept EqualityComparable = weakly-equality-comparable-with<T, T>;
2
#
Let a and b be objects of type T.
EqualityComparable<T> is satisfied only if bool(a == b) is true when a is equal to b ([concepts.equality]), and false otherwise.
3
#
[ Note
:
The requirement that the expression a == b is equality-preserving implies that == is transitive and symmetric.
— end note
 ]
🔗
template<class T, class U> concept EqualityComparableWith = EqualityComparable<T> && EqualityComparable<U> && CommonReference<const remove_reference_t<T>&, const remove_reference_t<U>&> && EqualityComparable< common_reference_t< const remove_reference_t<T>&, const remove_reference_t<U>&>> && weakly-equality-comparable-with<T, U>;
4
#
Let t be an lvalue of type const remove_­reference_­t<T>, u be an lvalue of type const remove_­reference_­t<U>, and C be: 
common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>
EqualityComparableWith<T, U> is satisfied only if bool(t == u) == bool(C(t) == C(u)).

17.5.4 Concept StrictTotallyOrdered [concept.stricttotallyordered]

🔗
template<class T> concept StrictTotallyOrdered = EqualityComparable<T> && requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) { a < b; requires Boolean<decltype(a < b)>; a > b; requires Boolean<decltype(a > b)>; a <= b; requires Boolean<decltype(a <= b)>; a >= b; requires Boolean<decltype(a >= b)>; };
1
#
Let a, b, and c be lvalues of type const remove_­reference_­t<T>.
StrictTotallyOrdered<T> is satisfied only if
  • (1.1)
    Exactly one of bool(a < b), bool(a > b), or bool(a == b) is true.
  • (1.2)
    If bool(a < b) and bool(b < c), then bool(a < c).
  • (1.3)
    bool(a > b) == bool(b < a).
  • (1.4)
    bool(a <= b) == !bool(b < a).
  • (1.5)
    bool(a >= b) == !bool(a < b).
🔗
template<class T, class U> concept StrictTotallyOrderedWith = StrictTotallyOrdered<T> && StrictTotallyOrdered<U> && CommonReference<const remove_reference_t<T>&, const remove_reference_t<U>&> && StrictTotallyOrdered< common_reference_t< const remove_reference_t<T>&, const remove_reference_t<U>&>> && EqualityComparableWith<T, U> && requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) { t < u; requires Boolean<decltype(t < u)>; t > u; requires Boolean<decltype(t > u)>; t <= u; requires Boolean<decltype(t <= u)>; t >= u; requires Boolean<decltype(t >= u)>; u < t; requires Boolean<decltype(u < t)>; u > t; requires Boolean<decltype(u > t)>; u <= t; requires Boolean<decltype(u <= t)>; u >= t; requires Boolean<decltype(u >= t)>; };
2
#
Let t be an lvalue of type const remove_­reference_­t<T>, u be an lvalue of type const remove_­reference_­t<U>, and C be: 
common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>
StrictTotallyOrderedWith<T, U> is satisfied only if
  • (2.1)
    bool(t < u) == bool(C(t) < C(u)).
  • (2.2)
    bool(t > u) == bool(C(t) > C(u)).
  • (2.3)
    bool(t <= u) == bool(C(t) <= C(u)).
  • (2.4)
    bool(t >= u) == bool(C(t) >= C(u)).
  • (2.5)
    bool(u < t) == bool(C(u) < C(t)).
  • (2.6)
    bool(u > t) == bool(C(u) > C(t)).
  • (2.7)
    bool(u <= t) == bool(C(u) <= C(t)).
  • (2.8)
    bool(u >= t) == bool(C(u) >= C(t)).