Namespaces
Variants

std::experimental::ranges:: StrictTotallyOrdered, std::experimental::ranges:: StrictTotallyOrderedWith

From cppreference.net
C++
Experimental
Ranges
Concepts library
(Anmerkung: Da in diesem HTML-Abschnitt keinerlei Textinhalte vorhanden sind, die übersetzt werden müssten, bleibt die Ausgabe identisch mit der Eingabe. Die leeren td-Zellen enthalten keine übersetzbaren Textelemente.)
template < class T >

Konzept bool StrictTotallyOrdered =
EqualityComparable < T > &&
erfordert ( const std:: remove_reference_t < T > & a,
const std:: remove_reference_t < T > & b ) {
{ a < b } - > Boolean && ;
{ a > b } - > Boolean && ;
{ a <= b } - > Boolean && ;
{ a >= b } - > Boolean && ;

} ;
(1) (ranges TS)
template < class T, class U >

Konzept bool StrictTotallyOrderedWith =
StrictTotallyOrdered < T > &&
StrictTotallyOrdered < U > &&
CommonReference <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & > &&
StrictTotallyOrdered <
ranges:: common_reference_t <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & >> &&
EqualityComparableWith < T, U > &&
erfordert ( const std:: remove_reference_t < T > & t,
const std:: remove_reference_t < U > & u ) {
{ t < u } - > Boolean && ;
{ t > u } - > Boolean && ;
{ t <= u } - > Boolean && ;
{ t >= u } - > Boolean && ;
{ u < t } - > Boolean && ;
{ u > t } - > Boolean && ;
{ u <= t } - > Boolean && ;
{ u >= t } - > Boolean && ;

} ;
(2) (ranges TS)
1) Das Konzept StrictTotallyOrdered<T> spezifiziert, dass die Vergleichsoperatoren ==,!=,<,>,<=,>= auf T Ergebnisse liefern, die mit einer strikten Totalordnung auf T konsistent sind.

StrictTotallyOrdered<T> ist nur dann erfüllt, 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) Das Konzept StrictTotallyOrderedWith<T, U> 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.

Formal ist StrictTotallyOrderedWith<T, U> nur dann erfüllt, 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 > , und sei C definiert als ranges:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > , folgende Bedingungen gelten:

  • bool ( t < u ) == bool ( C ( t ) < C ( u ) )
  • bool ( t > u ) == bool ( C ( t ) > C ( u ) )
  • bool ( t <= u ) == bool ( C ( t ) <= C ( u ) )
  • bool ( t >= u ) == bool ( C ( t ) >= C ( u ) )
  • bool ( u < t ) == bool ( C ( u ) < C ( t ) )
  • bool ( u > t ) == bool ( C ( u ) > C ( t ) )
  • bool ( u <= t ) == bool ( C ( u ) <= C ( t ) )
  • bool ( u >= t ) == bool ( C ( u ) >= C ( t ) )

Gleichheitserhaltung

Ein Ausdruck ist gleichheitserhaltend , wenn er bei gleichen Eingaben gleiche Ausgaben liefert.

  • Die Eingaben eines Ausdrucks bestehen aus seinen Operanden.
  • Die Ausgaben eines Ausdrucks bestehen aus seinem Ergebnis und allen durch den Ausdruck modifizierten Operanden (falls vorhanden).

Jeder Ausdruck, der gleichungserhaltend sein muss, muss darüber hinaus stabil sein: Zwei Auswertungen eines solchen Ausdrucks mit denselben Eingabeobjekten müssen gleiche Ausgaben liefern, sofern keine explizite Änderung dieser Eingabeobjekte zwischen den Auswertungen erfolgt.

Sofern nicht anders angegeben, muss jeder Ausdruck, der in einem requires-expression verwendet wird, gleichheitserhaltend und stabil sein, und die Auswertung des Ausdrucks darf nur seine nicht-konstanten Operanden modifizieren. Operanden, die konstant sind, dürfen nicht modifiziert werden.

Implizite Ausdrucksvarianten

Ein requires-expression , der einen Ausdruck verwendet, der für einen konstanten Lvalue-Operanden nicht-modifizierend ist, erfordert implizit auch zusätzliche Variationen dieses Ausdrucks, die einen nicht-konstanten Lvalue oder (möglicherweise konstanten) Rvalue für den gegebenen Operanden akzeptieren, sofern nicht eine solche Ausdrucksvariation explizit mit abweichender Semantik gefordert wird. Diese impliziten Ausdrucksvariationen müssen dieselben semantischen Anforderungen erfüllen wie der deklarierte Ausdruck. Das Ausmaß, in dem eine Implementierung die Syntax der Variationen überprüft, ist nicht spezifiziert.