std::totally_ordered, std::totally_ordered_with

Определено в заголовке <concepts>

Определено в заголовке `<concepts>`
template< class T > concept totally_ordered = std::equality_comparable<T> && __PartiallyOrderedWith<T, T>;	(1)	(с C++20)
template< class T, class U > concept totally_ordered_with = std::totally_ordered<T> && std::totally_ordered<U> && std::equality_comparable_with<T, U> && std::totally_ordered< std::common_reference_t< const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>> && __PartiallyOrderedWith<T, U>;	(2)	(с C++20)
template< class T, class U > concept __PartiallyOrderedWith = requires(const std::remove_reference_t<T>& t, const std::remove_reference_t<U>& u) { { t < u } -> boolean-testable; { t > u } -> boolean-testable; { t <= u } -> boolean-testable; { t >= u } -> boolean-testable; { u < t } -> boolean-testable; { u > t } -> boolean-testable; { u <= t } -> boolean-testable; { u >= t } -> boolean-testable; };	(3)	(только для иллюстрации*)

template< class T >
concept totally_ordered =
    std::equality_comparable<T> && __PartiallyOrderedWith<T, T>;

(1)

(с C++20)

template< class T, class U >
concept totally_ordered_with =
    std::totally_ordered<T> &&
    std::totally_ordered<U> &&
    std::equality_comparable_with<T, U> &&
    std::totally_ordered<
        std::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>> &&
    __PartiallyOrderedWith<T, U>;

(2)

(с C++20)

template< class T, class U >
concept __PartiallyOrderedWith =
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
        { t <  u } -> boolean-testable;
        { t >  u } -> boolean-testable;
        { t <= u } -> boolean-testable;
        { t >= u } -> boolean-testable;
        { u <  t } -> boolean-testable;
        { u >  t } -> boolean-testable;
        { u <= t } -> boolean-testable;
        { u >= t } -> boolean-testable;
    };

(3)

(только для иллюстрации*)

1) Концепция std::totally_ordered задаёт требования к операторам сравнения ==,!=,<,>,<=,>= типа, которые должны соответствовать строгому полному порядку на типе.

2) Концепция std::totally_ordered_with задаёт требования к операторам сравнения ==,!=,<,>,<=,>= над (возможно смешанными) операндами T и U, которые должны соответствовать строгому полному порядку. Сравнение смешанных операндов даёт результат, эквивалентный результату сравнения операндов, преобразованных к общему типу.

3) Концепция __PartiallyOrderedWith (только для иллюстрации) задаёт требования к сравнению значений типа T и типа U в частичном порядке друг с другом (в любом порядке) с использованием <, >, <=, и >=, а также требует согласованности результатов сравнений.

Семантические требования

Эти концепции моделируются только в том случае, если они удовлетворяются и все подчинённые им концепции также моделируются.

1) std::totally_ordered<T> моделируется только если, учитывая lvalues a, b и c типа const std::remove_reference_t<T>:

ровно один из bool(a < b), bool(a > b) и bool(a == b) является true;
если bool(a < b) и bool(b < c) оба являются true, то bool(a < c) является true;
bool(a > b) == bool(b < a)
bool(a >= b) == !bool(a < b)
bool(a <= b) == !bool(b < a)

2) std::totally_ordered_with<T, U> моделируется только если, учитывая

t и t2, lvalues, обозначающие различные равные объекты типов const std::remove_reference_t<T> и std::remove_reference_t<T> соответственно, и
u и u2, lvalues, обозначающие различные равные объекты типов const std::remove_reference_t<U> и std::remove_reference_t<U> соответственно,

пусть C будет std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>, и, учитывая выражение E и тип C, пусть CONVERT_TO<C>(E) будет:

`static_cast<C>(std::as_const(E))`.	(до C++23)
`static_cast<const C&>(std::as_const(E))` если это допустимое выражение, `static_cast<const C&>(std::move(E))` в противном случае.	(с C++23)

следующее верно:

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

3) __PartiallyOrderedWith<T, U> моделируется только если, учитывая

любой lvalue t типа const std::remove_reference_t<T>, и
любой lvalue u типа const std::remove_reference_t<U>,

следующее верно:

t < u, t <= u, t > u, t >= u, u < t, u <= t, u > t, и u >= t имеют одинаковую область определения;
bool(t < u) == bool(u > t);
bool(u < t) == bool(t > u);
bool(t <= u) == bool(u >= t); и
bool(u <= t) == bool(t >= u).

Сохранение равенства

Выражения, объявленные в выражениях requires концепций стандартной библиотеки, должны быть сохраняющими равенство (кроме случаев, когда указано иначе).

Неявные вариации выражений

Выражение requires, использующее выражение, не изменяющее некоторые константные операнды lvalue, также требует неявных вариаций выражений.

См. также

three_way_comparablethree_way_comparable_with

(C++20)

определяет, что оператор <=> даёт согласованный результат для заданных типов
(концепция)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/concepts/totally_ordered