std::three_way_comparable, std::three_way_comparable_with

Определено в заголовочном файле <compare>

Определено в заголовочном файле `<compare>`
template< class T, class Cat = std::partial_ordering > concept three_way_comparable = __WeaklyEqualityComparableWith<T, T> && __PartiallyOrderedWith<T, T> && requires(const std::remove_reference_t<T>& a, const std::remove_reference_t<T>& b) { { a <=> b } -> __ComparesAs<Cat>; };	(1)	(начиная с C++20)
template< class T, class U, class Cat = std::partial_ordering > concept three_way_comparable_with = std::three_way_comparable<T, Cat> && std::three_way_comparable<U, Cat> && __ComparisonCommonTypeWith<T, U> && std::three_way_comparable< std::common_reference_t< const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>, Cat> && __WeaklyEqualityComparableWith<T, U> && __PartiallyOrderedWith<T, U> && requires(const std::remove_reference_t<T>& t, const std::remove_reference_t<U>& u) { { t <=> u } -> __ComparesAs<Cat>; { u <=> t } -> __ComparesAs<Cat>; };	(2)	(начиная с C++20)
template< class T, class Cat > concept __ComparesAs = std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;	(3)	(только для пояснения*)

template< class T, class Cat = std::partial_ordering >
concept three_way_comparable =
    __WeaklyEqualityComparableWith<T, T> &&
    __PartiallyOrderedWith<T, T> &&
    requires(const std::remove_reference_t<T>& a,
             const std::remove_reference_t<T>& b) {
        { a <=> b } -> __ComparesAs<Cat>;
    };

(1)

(начиная с C++20)

template< class T, class U, class Cat = std::partial_ordering >
concept three_way_comparable_with =
    std::three_way_comparable<T, Cat> &&
    std::three_way_comparable<U, Cat> &&
    __ComparisonCommonTypeWith<T, U> &&
    std::three_way_comparable<
        std::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>, Cat> &&
    __WeaklyEqualityComparableWith<T, U> &&
    __PartiallyOrderedWith<T, U> &&
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
        { t <=> u } -> __ComparesAs<Cat>;
        { u <=> t } -> __ComparesAs<Cat>;
    };

(2)

(начиная с C++20)

template< class T, class Cat >
concept __ComparesAs =
    std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;

(3)

(только для пояснения*)

1) Концепция std::three_way_comparable задаёт требования к тому, чтобы оператор трёхстороннего сравнения <=> для T давал результаты, согласующиеся с категорией сравнения, подразумеваемой Cat.

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

__WeaklyEqualityComparableWith, __PartiallyOrderedWith и __ComparisonCommonTypeWith — концепции, используемые только для пояснения. См. описания equality_comparable и totally_ordered.

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

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

1) T и Cat моделируют std::three_way_comparable<T, Cat> только если для lvalue-выражений a и b типа const std::remove_reference_t<T> выполняются следующие условия:

(a <=> b == 0) == bool(a == b),
(a <=> b != 0) == bool(a != b),
((a <=> b) <=> 0) и (0 <=> (b <=> a)) равны,
bool(a > b) == bool(b < a),
bool(a >= b) == !bool(a < b),
bool(a <= b) == !bool(b < a),
(a <=> b < 0) == bool(a < b),
(a <=> b > 0) == bool(a > b),
(a <=> b <= 0) == bool(a <= b) и
(a <=> b >= 0) == bool(a >= b), и
если Cat преобразуемо в std::strong_ordering, то T моделирует totally_ordered.

2) T, U и Cat моделируют std::three_way_comparable_with<T, U, Cat> только если для следующих объектов:

t и t2 — lvalue-выражений, обозначающих различные равные объекты типов const std::remove_reference_t<T> и std::remove_reference_t<T> соответственно, и
u и u2 — lvalue-выражений, обозначающих различные равные объекты типов 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)

выполняются следующие условия:

t <=> u и u <=> t имеют одинаковую область определения,
((t <=> u) <=> 0) и (0 <=> (u <=> t)) равны,
(t <=> u == 0) == bool(t == u),
(t <=> u != 0) == bool(t != u),
Cat(t <=> u) == Cat(CONVERT_TO<C>(t2) <=> CONVERT_TO<C>(u2)),
(t <=> u < 0) == bool(t < u),
(t <=> u > 0) == bool(t > u),
(t <=> u <= 0) == bool(t <= u),
(t <=> u >= 0) == bool(t >= u) и
если Cat преобразуемо в std::strong_ordering, то T и U моделируют std::totally_ordered_with<T, U>.

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

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

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

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

См. также

equality_comparableequality_comparable_with (C++20)(C++20)	задаёт требования к тому, чтобы оператор `==` был отношением эквивалентности (концепция)
totally_orderedtotally_ordered_with (C++20)(C++20)	задаёт требования к тому, чтобы операторы сравнения для типа задавали линейный порядок (концепция)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/compare/three_way_comparable