std::equality_comparable, std::equality_comparable_with

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Konzeptbibliothek

Kernsprachen-Konzepte same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

Vergleichskonzepte equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) Objektkonzepte movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) Aufrufbare Konzepte invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

Exposition-only Konzepte boolean-testable  (C++20)

 

Definiert in der Header-Datei <concepts>
template< class T > Konzept equality_comparable = __WeaklyEqualityComparableWith<T, T>;	(1)	(seit C++20)
template< class T, class U > Konzept 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)	(seit C++20)
Hilfskonzepte
template< class T, class U > Konzept __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)	(nur Exposition*)
	(4)
template< class T, class U > Konzept __ComparisonCommonTypeWith =     std::common_reference_with<         const std::remove_reference_t<T>&,         const std::remove_reference_t<U>&>;			(bis C++23) (nur Exposition*)
template< class T, class U, class C = std::common_reference_t<const T&, const U&> > Konzept _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 > Konzept __ComparisonCommonTypeWith =     _ComparisonCommonTypeWithImpl<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;			(seit C++23) (nur Exposition*)

1) Das Konzept std::equality_comparable spezifiziert, dass die Vergleichsoperatoren == und != auf T die Gleichheit widerspiegeln: == ergibt true genau dann, wenn die Operanden gleich sind.

2) Das Konzept std::equality_comparable_with spezifiziert, dass die Vergleichsoperatoren == und != auf (möglicherweise gemischten) T- und U-Operanden Ergebnisse liefern, die mit der Gleichheit übereinstimmen. Das Vergleichen gemischter Operanden liefert Ergebnisse, die äquivalent sind zum Vergleichen der Operanden, konvertiert zu ihrem gemeinsamen Typ.

3) Das exposition-only-Konzept __WeaklyEqualityComparableWith spezifiziert, dass ein Objekt vom Typ T und ein Objekt vom Typ U mit einander (in beliebiger Reihenfolge) mittels beider Operatoren == und != auf Gleichheit verglichen werden können und die Ergebnisse der Vergleiche konsistent sind.

4) Das exposition-only-Konzept __ComparisonCommonTypeWith spezifiziert, dass zwei Typen einen gemeinsamen Typ teilen und ein const Lvalue oder ein non-const Rvalue(seit C++23) eines der Typen in diesen gemeinsamen Typ konvertierbar ist.

Semantische Anforderungen

Diese Konzepte werden nur modelliert, wenn sie erfüllt sind und alle Konzepte, die sie umfassen, modelliert sind.

In den folgenden Absätzen ist, gegeben ein Ausdruck E und ein Typ C, CONVERT_TO<C>(E) definiert als

static_cast<C>(std::as_const(E)).	(bis C++23)
static_cast<const C&>(std::as_const(E)), falls dies ein gültiger Ausdruck ist, static_cast<const C&>(std::move(E)) andernfalls.	(seit C++23)

1) std::equality_comparable<T> wird nur modelliert, wenn für Objekte a und b vom Typ T bool(a == b) genau dann true ist, wenn a und b gleich sind. Zusammen mit der Anforderung, dass a == b gleichheitserhaltend ist, impliziert dies, dass == symmetrisch und transitiv ist und weiterhin, dass == für alle Objekte a, die zu mindestens einem anderen Objekt gleich sind, reflexiv ist.

2) std::equality_comparable_with<T, U> wird nur modelliert, wenn Folgendes gilt:

• t und t2 sind Lvalues, die unterschiedliche, gleiche Objekte der Typen const std::remove_reference_t<T> und std::remove_cvref_t<T> bezeichnen,
• u und u2 sind Lvalues, die unterschiedliche, gleiche Objekte der Typen const std::remove_reference_t<U> und std::remove_cvref_t<U> bezeichnen,
• C ist std::common_reference_t<const std::remove_reference_t<T>&, const std::remove_reference_t<U>&>,

ist der folgende Ausdruck wahr

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

3) __WeaklyEqualityComparableWith<T, U> wird nur modelliert, wenn gilt

• t, ein Lvalue vom Typ const std::remove_reference_t<T> und
• u, ein Lvalue vom Typ const std::remove_reference_t<U>,

die folgenden Bedingungen erfüllt sind

• t == u, u == t, t != u, u != t haben dieselbe Domäne;
• bool(u == t) == bool(t == u);
• bool(t != u) == !bool(t == u); und
• bool(u != t) == bool(t != u).

4) __WeaklyEqualityComparableWith<T, U> wird nur modelliert, wenn

Das entsprechende common_reference_with-Konzept modelliert wird.

(bis C++23)

Seien C sei std::common_reference_t<const T&, const U&>, t1 und t2 sind gleichheitserhaltende Ausdrücke, die Lvalues vom Typ std::remove_cvref_t<T> sind, u1 und u2 sind gleichheitserhaltende Ausdrücke, die Lvalues vom Typ std::remove_cvref_t<U> sind, gelten die folgenden Bedingungen CONVERT_TO<C>(t1) ist gleich CONVERT_TO<C>(t2) genau dann, wenn t1 gleich t2 ist; und CONVERT_TO<C>(u1) ist gleich CONVERT_TO<C>(u2) genau dann, wenn u1 gleich u2 ist.

(seit C++23)

Gleichheitserhaltung

Ausdrücke, die in requires-Ausdrücken der Standardbibliothekskonzepte deklariert sind, müssen gleichheitserhaltend sein (sofern nicht anders angegeben).

Implizite Ausdrucksvariationen

Ein requires-Ausdruck, der einen Ausdruck verwendet, der für einen konstanten Lvalue-Operanden nicht-modifizierend ist, erfordert ebenfalls implizite Ausdrucksvariationen.

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 18.5.4 Konzept equality_comparable [concept.equalitycomparable]

• C++20 Standard (ISO/IEC 14882:2020)

• 18.5.3 Konzept equality_comparable [concept.equalitycomparable]