std:: totally_ordered, std:: totally_ordered_with

1) Das Konzept std::totally_ordered spezifiziert, dass die Vergleichsoperatoren ==,!=,<,>,<=,>= für einen Typ Ergebnisse liefern, die mit einer strengen Totalordnung auf dem Typ konsistent sind.

2) Das Konzept std::totally_ordered_with spezifiziert, dass die Vergleichsoperatoren ==,!=,<,>,<=,>= auf (möglicherweise gemischten) T und U Operanden Ergebnisse liefern, die mit einer strengen Totalordnung 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 __PartiallyOrderedWith spezifiziert, dass ein Wert vom Typ T und ein Wert vom Typ U in einer partiellen Ordnung miteinander verglichen werden können (in beliebiger Reihenfolge) unter Verwendung von < , > , <= , und >= , und die Ergebnisse der Vergleiche konsistent sind.

1) std :: totally_ordered < T > wird nur dann modelliert, wenn für Lvalues a , b und c vom Typ const std:: remove_reference_t < T > gilt:

• Genau einer der Ausdrücke bool ( a < b ) , bool ( a > b ) und bool ( a == b ) ist true ;
• Wenn bool ( a < b ) und bool ( b < c ) beide true sind, dann ist bool ( a < c ) ebenfalls true ;
• bool ( a > b ) == bool ( b < a )
• bool ( a >= b ) == ! bool ( a < b )
• bool ( a <= b ) == ! bool ( b < a )

2) std :: totally_ordered_with < T, U > is modeled only if, given

• t und t2 , Lvalues, die unterschiedliche gleiche Objekte der Typen const std:: remove_reference_t < T > und std:: remove_reference_t < T > bezeichnen, und
• u und u2 , Lvalues, die unterschiedliche gleiche Objekte der Typen const std:: remove_reference_t < U > und std:: remove_reference_t < U > bezeichnen,

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

Folgendes trifft zu:

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

**Anmerkung:** Da der gesamte Text innerhalb von ` ` Tags liegt (was Code-Formatierung entspricht) und gemäß Ihrer Anweisung Code nicht übersetzt werden soll, bleibt der gesamte Inhalt unverändert. Die HTML-Struktur und alle C++-spezifischen Begriffe wurden beibehalten.

3) __PartiallyOrderedWith < T, U > wird nur modelliert, wenn für

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

Folgendes zutrifft:

• t < u , t <= u , t > u , t >= u , u < t , u <= t , u > t , und u >= t denselben Definitionsbereich haben;
• bool ( t < u ) == bool ( u > t ) ;
• bool ( u < t ) == bool ( t > u ) ;
• bool ( t <= u ) == bool ( u >= t ) ; und
• bool ( u <= t ) == bool ( t >= u ) .