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> только если, учитывая lvalues 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, 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)

следующие утверждения являются истинными:

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)	определяет, что оператор `==` является отношением эквивалентности (концепция)
totally_orderedtotally_ordered_with (C++20)	определяет, что операторы сравнения для типа порождают полное упорядочение (концепция)

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