Namespaces
Variants

std:: three_way_comparable, std:: three_way_comparable_with

From cppreference.net
C++
Utilities library
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt gemäß den Anforderungen unverändert.)
Definiert im Header <compare>
template < class T, class Cat = std:: partial_ordering >

Konzept three_way_comparable =
__WeaklyEqualityComparableWith < T, T > &&
__PartiallyOrderedWith < T, T > &&
erfordert ( const std:: remove_reference_t < T > & a,
const std:: remove_reference_t < T > & b ) {
{ a <=> b } - > __ComparesAs < Cat > ;

} ;
(1) (seit C++20)
template < class T, class U, class Cat = std:: partial_ordering >

Konzept three_way_comparable_with =
std :: three_way_comparable < T, Cat > &&
std :: three_way_comparable < U, Cat > &&
__ComparisonCommonTypeWith < T, U > &&
std :: three_way_comparable <
std:: common_reference_t <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & > , Cat > &&
__WeaklyEqualityComparableWith < T, U > &&
__PartiallyOrderedWith < T, U > &&
erfordert ( const std:: remove_reference_t < T > & t,
const std:: remove_reference_t < U > & u ) {
{ t <=> u } - > __ComparesAs < Cat > ;
{ u <=> t } - > __ComparesAs < Cat > ;

} ;
(2) (seit C++20)
template < class T, class Cat >

concept __ComparesAs =

std:: same_as < std:: common_comparison_category_t < T, Cat > , Cat > ;
(3) ( exposition only* )
1) Das Konzept std::three_way_comparable spezifiziert, dass der Drei-Wege-Vergleichsoperator <=> auf T Ergebnisse liefert, die mit der durch Cat implizierten Vergleichskategorie konsistent sind.
2) Das Konzept std::three_way_comparable_with spezifiziert, dass der Drei-Wege-Vergleichsoperator <=> für (möglicherweise gemischte) T - und U -Operanden Ergebnisse liefert, die mit der durch Cat implizierten Vergleichskategorie konsistent sind. Der Vergleich gemischter Operanden liefert Ergebnisse, die äquivalent zum Vergleich der in ihren gemeinsamen Typ konvertierten Operanden sind.

__WeaklyEqualityComparableWith , __PartiallyOrderedWith und __ComparisonCommonTypeWith sind ausschließlich Darstellungskonzepte. Siehe Beschreibungen von equality_comparable und totally_ordered .

Inhaltsverzeichnis

Semantische Anforderungen

Diese Konzepte sind nur modelliert, wenn sie erfüllt sind und alle von ihnen subsumierten Konzepte modelliert sind.

1) T und Cat modellieren std :: three_way_comparable < T, Cat > nur dann, wenn für Lvalues a und b vom Typ const std:: remove_reference_t < T > Folgendes zutrifft:
  • ( a <=> b == 0 ) == bool ( a == b ) ,
  • ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
  • ( ( a <=> b ) <=> 0 ) und ( 0 <=> ( b <=> a ) ) gleich sind,
  • bool ( a > b ) == bool ( b < a ) ,
  • bool ( a >= b ) == ! bool ( a < b ) ,
  • bool ( a <= b ) == ! bool ( b < a ) ,
  • ( a <=> b < 0 ) == bool ( a < b ) ,
  • ( a <=> b > 0 ) == bool ( a > b ) ,
  • ( a <=> b <= 0 ) == bool ( a <= b ) , und
  • ( a <=> b >= 0 ) == bool ( a >= b ) , und
  • falls Cat konvertierbar zu std::strong_ordering ist, T modelliert totally_ordered .
2) T , U , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

Sei C definiert als std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > und für einen gegebenen Ausdruck E und einen Typ C sei 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)

Folgendes trifft zu:

  • t <=> u und u <=> t haben denselben Definitionsbereich,
  • ( ( t <=> u ) <=> 0 ) und ( 0 <=> ( u <=> t ) ) sind gleich,
  • ( t <=> u == 0 ) == bool ( t == u ) ,
  • ( t <=> u ! = 0 ) == bool ( t ! = u ) ,
  • Cat ( t <=> u ) == Cat ( CONVERT_TO < C > ( t2 ) <=> CONVERT_TO < C > ( u2 ) ) ,
  • ( t <=> u < 0 ) == bool ( t < u ) ,
  • ( t <=> u > 0 ) == bool ( t > u ) ,
  • ( t <=> u <= 0 ) == bool ( t <= u ) ,
  • ( t <=> u >= 0 ) == bool ( t >= u ) , und
  • falls Cat konvertierbar zu std::strong_ordering ist, modellieren T und U std:: totally_ordered_with < T, U > .

Gleichheitserhaltung

In requires expressions deklarierte Ausdrücke der Standardbibliothekskonzepte müssen gleichheitserhaltend 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 .

Siehe auch

(C++20)
spezifiziert, dass der Operator == eine Äquivalenzrelation ist
(Konzept)
(C++20)
spezifiziert, dass die Vergleichsoperatoren des Typs eine Totalordnung ergeben
(Konzept)