Пространства имён
Варианты
Действия

std::equality_comparable, std::equality_comparable_with

Материал из cppreference.com
< cpp‎ | concepts
 
 
 
Определено в заголовочном файле <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 указывает, что два типа имеют общий тип, а константное значение lvalue ли неконстантное значение 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> моделируется, только если