std:: totally_ordered, std:: totally_ordered_with

1) Le concept std::totally_ordered spécifie que les opérateurs de comparaison ==,!=,<,>,<=,>= sur un type produisent des résultats cohérents avec un ordre total strict sur le type.

2) Le concept std::totally_ordered_with spécifie que les opérateurs de comparaison ==,!=,<,>,<=,>= sur des opérandes (éventuellement mixtes) T et U produisent des résultats cohérents avec un ordre total strict. La comparaison d'opérandes mixtes produit des résultats équivalents à la comparaison des opérandes convertis en leur type commun.

3) Le concept d'exposition uniquement __PartiallyOrderedWith spécifie qu'une valeur de type T et une valeur de type U peuvent être comparées selon un ordre partiel l'une avec l'autre (dans les deux sens) en utilisant < , > , <= , et >= , et que les résultats des comparaisons sont cohérents.

1) std :: totally_ordered < T > est modélisé seulement si, étant donné des lvalues a , b et c de type const std:: remove_reference_t < T > :

• Exactement une des expressions bool ( a < b ) , bool ( a > b ) et bool ( a == b ) est true ;
• Si bool ( a < b ) et bool ( b < c ) sont toutes deux true , alors bool ( a < c ) est 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 et t2 , des lvalues désignant des objets distincts mais égaux de types const std:: remove_reference_t < T > et std:: remove_reference_t < T > respectivement, et
• u et u2 , des lvalues désignant des objets distincts mais égaux de types const std:: remove_reference_t < U > et std:: remove_reference_t < U > respectivement,

Soit C le type std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > , et, étant donnée une expression E et un type C , soit CONVERT_TO < C > ( E ) défini comme suit :

static_cast < C > ( std:: as_const ( E ) ) .	(jusqu'en C++23)
static_cast < const C & > ( std:: as_const ( E ) ) si cela constitue une expression valide, static_cast < const C & > ( std :: move ( E ) ) sinon.	(depuis C++23)

les affirmations suivantes sont vraies :

• 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 ) )

3) __PartiallyOrderedWith < T, U > est modélisé seulement si, étant donnés

• toute lvalue t de type const std:: remove_reference_t < T > , et
• toute lvalue u de type const std:: remove_reference_t < U > ,

les conditions suivantes sont vraies :

• t < u , t <= u , t > u , t >= u , u < t , u <= t , u > t , et u >= t ont le même domaine ;
• bool ( t < u ) == bool ( u > t ) ;
• bool ( u < t ) == bool ( t > u ) ;
• bool ( t <= u ) == bool ( u >= t ) ; et
• bool ( u <= t ) == bool ( t >= u ) .