std::three_way_comparable, std::three_way_comparable_with

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, RTTI) Макросы тестирования функциональности библиотеки (C++20)     Управление динамической памятью Программные утилиты Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Трёхстороннее сравнение (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

Общие утилиты Дата и время Функциональные объекты Библиотека форматирования (C++20) bitset hash (C++11) Операторы отношения (устарело в C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Целочисленные функции сравнения cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Операции обмена и типа swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Общие лексические типы pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

<tbody> </tbody>

Определено в заголовочном файле <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)	(только для пояснения*)

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, также неявно требует дополнительных вариаций этого выражения, которые принимают неконстантное lvalue или (возможно, константное) rvalue для данного операнда, если только такое изменение выражения явно требуется с различной семантикой. Эти вариации неявных выражений должны соответствовать тем же семантическим требованиям, что и объявленное выражение. Степень, в которой реализация проверяет синтаксис вариантов, не определена.

Смотрите также

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