17 Concepts library [concepts]

17.5 Comparison concepts [concepts.compare]

17.5.1 General [concepts.compare.general]

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

17.5.2 Concept Boolean [concept.boolean]

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 } -> ConvertibleTo<bool>;
      { b1 &&  a } -> Same<bool>;
      { b1 ||  a } -> Same<bool>;
      { b1 && b2 } -> Same<bool>;
      {  a && b2 } -> Same<bool>;
      { b1 || b2 } -> Same<bool>;
      {  a || b2 } -> Same<bool>;
      { b1 == b2 } -> ConvertibleTo<bool>;
      { b1 ==  a } -> ConvertibleTo<bool>;
      {  a == b2 } -> ConvertibleTo<bool>;
      { b1 != b2 } -> ConvertibleTo<bool>;
      { b1 !=  a } -> ConvertibleTo<bool>;
      {  a != b2 } -> ConvertibleTo<bool>;
    };

Let b1 and b2 be lvalues of type const remove_reference_t.

Boolean 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)).

[ 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 } -> Boolean;
      { t != u } -> Boolean;
      { u == t } -> Boolean;
      { u != t } -> Boolean;
    };

Let t and u be lvalues of types const remove_reference_t<T> and const remove_reference_t 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>;

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.

[ 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>;

Let t be an lvalue of type const remove_reference_t<T>, u be an lvalue of type const remove_reference_t, 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 } -> Boolean;
      { a >  b } -> Boolean;
      { a <= b } -> Boolean;
      { a >= b } -> Boolean;
    };

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 } -> Boolean;
      { t >  u } -> Boolean;
      { t <= u } -> Boolean;
      { t >= u } -> Boolean;
      { u <  t } -> Boolean;
      { u >  t } -> Boolean;
      { u <= t } -> Boolean;
      { u >= t } -> Boolean;
    };

Let t be an lvalue of type const remove_reference_t<T>, u be an lvalue of type const remove_reference_t, 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)).