Namespaces
Variants

std:: three_way_comparable, std:: three_way_comparable_with

From cppreference.net
C++
Utilities library
Défini dans l'en-tête <compare>
template < class T, class Cat = std:: partial_ordering >

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

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

concept 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 > &&
requires ( const std:: remove_reference_t < T > & t,
const std:: remove_reference_t < U > & u ) {
{ t <=> u } - > __ComparesAs < Cat > ;
{ u <=> t } - > __ComparesAs < Cat > ;

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

concept __ComparesAs =

std:: same_as < std:: common_comparison_category_t < T, Cat > , Cat > ;
(3) ( exposition uniquement* )
1) Le concept std::three_way_comparable spécifie que l'opérateur de comparaison à trois voies <=> sur T produit des résultats cohérents avec la catégorie de comparaison impliquée par Cat .
2) Le concept std::three_way_comparable_with spécifie que l'opérateur de comparaison à trois voies <=> sur des opérandes (éventuellement mixtes) T et U produit des résultats cohérents avec la catégorie de comparaison impliquée par Cat . La comparaison d'opérandes mixtes produit des résultats équivalents à la comparaison des opérandes convertis en leur type commun.

__WeaklyEqualityComparableWith , __PartiallyOrderedWith , et __ComparisonCommonTypeWith sont des concepts d'exposition uniquement. Voir les descriptions de equality_comparable et totally_ordered .

Table des matières

Exigences sémantiques

Ces concepts sont modélisés uniquement s'ils sont satisfaits et si tous les concepts qu'ils subsument sont modélisés.

1) T et Cat modélisent std :: three_way_comparable < T, Cat > seulement si, étant donné des lvalues a et b de type const std:: remove_reference_t < T > , les conditions suivantes sont vraies :
  • ( a <=> b == 0 ) == bool ( a == b ) ,
  • ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
  • ( ( a <=> b ) <=> 0 ) et ( 0 <=> ( b <=> a ) ) sont égaux,
  • 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 ) , et
  • ( a <=> b >= 0 ) == bool ( a >= b ) , et
  • si Cat est convertible en std::strong_ordering , T modélise totally_ordered .
2) T , U , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

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

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

les affirmations suivantes sont vraies :

  • t <=> u et u <=> t ont le même domaine,
  • ( ( t <=> u ) <=> 0 ) et ( 0 <=> ( u <=> t ) ) sont égaux,
  • ( 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 ) , et
  • si Cat est convertible en std::strong_ordering , T et U modélisent std:: totally_ordered_with < T, U > .

Préservation de l'égalité

Les expressions déclarées dans les requires expressions des concepts de la bibliothèque standard doivent être equality-preserving (sauf indication contraire).

Variations d'expressions implicites

Une requires expression qui utilise une expression non modifiante pour un opérande constant lvalue requiert également des variations d'expression implicites .

Voir aussi

(C++20)
spécifie que l'opérateur == est une relation d'équivalence
(concept)
(C++20)
spécifie que les opérateurs de comparaison sur le type produisent un ordre total
(concept)