std::equality_comparable, std::equality_comparable_with

Определено в заголовочном файле `<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)	(только для иллюстрации*)
template< class T, class U > concept __ComparisonCommonTypeWith = std::common_reference_with< const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>;	(4)	(до 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>>;	(4)		(начиная с C++23) (только для иллюстрации*)

1) Концепт std::equality_comparable задаёт, что операторы сравнения == и != для T отражают равенство: == возвращает true тогда и только тогда, когда операнды равны.

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

3) Концепт __WeaklyEqualityComparableWith, используемый только для иллюстрации, задаёт, что объект типа T и объект типа U можно сравнить друг с другом на равенство (в любом порядке), используя оба == и !=, причём результаты сравнений согласованы.

4) Концепт __ComparisonCommonTypeWith, используемый только для иллюстрации, задаёт, что два типа имеют общий тип, а константное lvalue или неконстантное rvalue(начиная с C++23) каждого из типов преобразуемо к этому общему типу.

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

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

В следующих абзацах для выражения 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)

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

2) std::equality_comparable_with<T,U> считается выполненным, только если для следующих объектов:

t и t2 — lvalue, обозначающие различные равные объекты типов const std::remove_reference_t<T> и std::remove_cvref_t<T> соответственно,
u и u2 — lvalue, обозначающие различные равные объекты типов const std::remove_reference_t и std::remove_cvref_t соответственно,
C — std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t&>,

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

bool(t == u) == bool(CONVERT_TO<C>(t2) == CONVERT_TO<C>(u2)).

3) __WeaklyEqualityComparableWith<T, U> считается выполненным, только если для следующих выражений:

t — lvalue типа const std::remove_reference_t<T>, и
u — lvalue типа const std::remove_reference_t,

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

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)

Пусть

C — std::common_reference_t<const T&, const U&>,
t1 и t2 — сохраняющие равенство выражения, являющиеся lvalue типа std::remove_cvref_t<T>,
u1 и u2 — сохраняющие равенство выражения, являющиеся lvalue типа std::remove_cvref_t,

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

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

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

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

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

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

Выражение requires, использующее выражение, которое не изменяет некоторый константный операнд-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]

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