Namespaces
Variants

std:: equality_comparable, std:: equality_comparable_with

From cppreference.net
Определено в заголовке <concepts>
template < class T >
concept equality_comparable = __WeaklyEqualityComparableWith < T, T > ;
(1) (начиная с C++20)
template < class T, class U >

concept equality_comparable_with =
std :: equality_comparable < T > &&
std :: equality_comparable < U > &&
__ComparisonCommonTypeWith < T, U > &&
std :: equality_comparable <
std:: common_reference_t <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & >> &&

__WeaklyEqualityComparableWith < T, U > ;
(2) (начиная с C++20)
Вспомогательные концепты
template < class T, class U >

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

} ;
(3) ( только для демонстрации* )
(4)
template < class T, class U >

concept __ComparisonCommonTypeWith =
std:: common_reference_with <
const std:: remove_reference_t < T > & ,

const std:: remove_reference_t < U > & > ;
(до C++23)
( только для демонстрации* )
template < class T, class U, class C = std:: common_reference_t < const T & , const U & > >

concept _ComparisonCommonTypeWithImpl =
std:: same_as < std:: common_reference_t < const T & , const U & > ,
std:: common_reference_t < const U & , const T & >> &&
requires {
requires std:: convertible_to < const T & , const C & > ||
std:: convertible_to < T, const C & > ;
requires std:: convertible_to < const U & , const C & > ||
std:: convertible_to < U, const C & > ;
} ;
template < class T, class U >
concept __ComparisonCommonTypeWith =

_ComparisonCommonTypeWithImpl < std:: remove_cvref_t < T > , std:: remove_cvref_t < U >> ;
(начиная с C++23)
( только для демонстрации* )
1) Концепт std::equality_comparable определяет, что операторы сравнения == и != для типа T отражают отношение равенства: == возвращает true тогда и только тогда, когда операнды равны.
2) Концепт std::equality_comparable_with определяет, что операторы сравнения == и != для (возможно, различных) операндов T и U дают результаты, соответствующие отношению равенства. Сравнение разнотипных операндов дает результаты, эквивалентные сравнению операндов, приведенных к их общему типу.
3) Экспозиционное понятие __WeaklyEqualityComparableWith определяет, что объект типа T и объект типа U могут быть сравнены на равенство друг с другом (в любом порядке) с использованием как == , так и != , и результаты сравнений являются согласованными.
4) Экспозиционное понятие __ComparisonCommonTypeWith специфицирует, что два типа имеют общий тип, а const lvalue или non-const rvalue (начиная с C++23) любого из этих типов конвертируемы в этот общий тип.

Содержание

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

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

В следующих параграфах, для данного выражения 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)
1) std :: equality_comparable < T > моделируется только тогда, когда для объектов a и b типа T , bool ( a == b ) равно true тогда и только тогда, когда a и b равны. В сочетании с требованием, что a == b является сохраняющим равенство , это подразумевает, что == является симметричным и транзитивным, а также что == является рефлексивным для всех объектов a , которые равны хотя бы одному другому объекту.
2) std :: equality_comparable_with < T, U > моделируется только если, пусть

следующее выражение истинно:

  • bool ( t == u ) == bool ( CONVERT_TO < C > ( t2 ) == CONVERT_TO < C > ( u2 ) ) .
3) __WeaklyEqualityComparableWith < T, U > моделируется только если при заданных

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

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

Соответствующая концепция common_reference_with моделируется.

(до C++23)

Пусть

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

  • CONVERT_TO < C > ( t1 ) равно CONVERT_TO < C > ( t2 ) тогда и только тогда, когда t1 равно t2 ; и
  • CONVERT_TO < C > ( u1 ) равно CONVERT_TO < C > ( u2 ) тогда и только тогда, когда u1 равно u2 .
(начиная с C++23)

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

Выражения, объявленные в requires выражениях концепций стандартной библиотеки, должны быть equality-preserving (если не указано иное).

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

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

Ссылки

  • Стандарт C++23 (ISO/IEC 14882:2024):
  • 18.5.4 Концепт equality_comparable [concept.equalitycomparable]
  • Стандарт C++20 (ISO/IEC 14882:2020):
  • 18.5.3 Концепт equality_comparable [concept.equalitycomparable]