Namespaces
Variants

std:: three_way_comparable, std:: three_way_comparable_with

From cppreference.net
C++
Utilities library
(Примечание: В данном фрагменте HTML отсутствует текстовое содержимое для перевода - присутствуют только HTML-теги и атрибуты, которые согласно инструкциям не подлежат переводу)
Определено в заголовочном файле <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 >

концепт 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 > только если, для l-значений 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 , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

Пусть C будет std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > и для данного выражения E и типа C , пусть CONVERT_TO < C > ( 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 выражениях концептов стандартной библиотеки, должны быть equality-preserving (если не указано иное).

Вариации неявных выражений

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

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

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