Namespaces
Variants

std:: equality_comparable, std:: equality_comparable_with

From cppreference.net
C++
Concepts library
Exposition-only concepts
 (C++20)
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind oder nur Klassenattribute enthalten, die nicht übersetzt werden sollen.)
Definiert in Header <concepts>
template < class T >
concept equality_comparable = __WeaklyEqualityComparableWith < T, T > ;
(1) (seit 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) (seit C++20)
Hilfskonzepte
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) ( nur zur Darstellung* )
(4)
template < class T, class U >

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

const std:: remove_reference_t < U > & > ;
(bis C++23)
( nur zur Darstellung* )
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 >> ;
(seit C++23)
( nur zur Darstellung* )
1) Das Konzept std::equality_comparable spezifiziert, dass die Vergleichsoperatoren == und != auf T Gleichheit widerspiegeln: == liefert true genau dann, wenn die Operanden gleich sind.
2) Das Konzept std::equality_comparable_with spezifiziert, dass die Vergleichsoperatoren == und != für (möglicherweise gemischte) T und U Operanden Ergebnisse liefern, die mit Gleichheit konsistent sind. Der Vergleich gemischter Operanden liefert Ergebnisse, die äquivalent zum Vergleich der in ihren gemeinsamen Typ konvertierten Operanden sind.
3) Das ausschließlich für die Darstellung verwendete Konzept __WeaklyEqualityComparableWith spezifiziert, dass ein Objekt vom Typ T und ein Objekt vom Typ U miteinander auf Gleichheit verglichen werden können (in beliebiger Reihenfolge) unter Verwendung von sowohl == als auch != , 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 (since C++23) eines der beiden Typen zu diesem gemeinsamen Typ konvertierbar ist.

Inhaltsverzeichnis

Semantische Anforderungen

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

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

(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 dann 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 == reflexiv für alle Objekte a ist, die zu mindestens einem anderen Objekt gleich sind.
2) std :: equality_comparable_with < T, U > wird nur modelliert, wenn, seien

der folgende Ausdruck wahr ist:

  • bool ( t == u ) == bool ( CONVERT_TO < C > ( t2 ) == CONVERT_TO < C > ( u2 ) ) .
3) __WeaklyEqualityComparableWith < T, U > wird nur modelliert, wenn gegeben

Folgendes zutrifft:

  • t == u , u == t , t ! = u , u ! = t dieselbe Domäne haben;
  • 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

dann gelten folgende Bedingungen:

  • CONVERT_TO < C > ( t1 ) gleich CONVERT_TO < C > ( t2 ) genau dann, wenn t1 gleich t2 ist; und
  • CONVERT_TO < C > ( u1 ) gleich CONVERT_TO < C > ( u2 ) genau dann, wenn u1 gleich u2 ist.
(seit C++23)

Gleichheitserhaltung

Ausdrücke, die in requires expressions der Standardbibliothek-Konzepte deklariert werden, müssen equality-preserving sein (sofern nicht anders angegeben).

Implizite Ausdrucksvarianten

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

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]