Namespaces
Variants

std:: three_way_comparable, std:: three_way_comparable_with

From cppreference.net
C++
Utilities library
Definido en el encabezado <compare>
template < class T, class Cat = std:: partial_ordering >

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

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

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

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

concepto __ComparesAs =

std:: same_as < std:: common_comparison_category_t < T, Cat > , Cat > ;
(3) ( solo para exposición* )
1) El concepto std::three_way_comparable especifica que el operador de comparación de tres vías <=> en T produce resultados consistentes con la categoría de comparación implícita en Cat .
2) El concepto std::three_way_comparable_with especifica que el operador de comparación de tres vías <=> en operandos (posiblemente mixtos) de T y U produce resultados consistentes con la categoría de comparación implícita en Cat . Comparar operandos mixtos produce resultados equivalentes a comparar los operandos convertidos a su tipo común.

__WeaklyEqualityComparableWith , __PartiallyOrderedWith y __ComparisonCommonTypeWith son conceptos solo de exposición. Consulte las descripciones de equality_comparable y totally_ordered .

Contenidos

Requisitos semánticos

Estos conceptos se modelan solo si se satisfacen y todos los conceptos que subsumen están modelados.

1) T y Cat modelan std :: three_way_comparable < T, Cat > solo si, dados los lvalues a y b de tipo const std:: remove_reference_t < T > , lo siguiente es verdadero:
  • ( a <=> b == 0 ) == bool ( a == b ) ,
  • ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
  • ( ( a <=> b ) <=> 0 ) y ( 0 <=> ( b <=> a ) ) son iguales,
  • 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 ) , y
  • ( a <=> b >= 0 ) == bool ( a >= b ) , y
  • si Cat es convertible a std::strong_ordering , T modela totally_ordered .
2) T , U , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

Sea C el tipo std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > y dada una expresión E y un tipo C , sea CONVERT_TO < C > ( E ) definido como:

(hasta C++23)
  • static_cast < const C & > ( std:: as_const ( E ) ) si es una expresión válida,
  • static_cast < const C & > ( std :: move ( E ) ) en caso contrario.
(desde C++23)

lo siguiente es cierto:

  • t <=> u y u <=> t tienen el mismo dominio,
  • ( ( t <=> u ) <=> 0 ) y ( 0 <=> ( u <=> t ) ) son iguales,
  • ( 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 ) , y
  • si Cat es convertible a std::strong_ordering , T y U modelan std:: totally_ordered_with < T, U > .

Preservación de igualdad

Las expresiones declaradas en las requires expressions de los conceptos de la biblioteca estándar deben ser equality-preserving (excepto donde se indique lo contrario).

Variaciones de expresión implícita

Una requires expresión que utiliza una expresión que no es modificadora para algún operando constante lvalue también requiere variaciones de expresión implícitas .

Véase también

(C++20)
especifica que el operador == es una relación de equivalencia
(concepto)
(C++20)
especifica que los operadores de comparación en el tipo producen un orden total
(concepto)