Namespaces
Variants

std:: totally_ordered, std:: totally_ordered_with

From cppreference.net
C++
Concepts library
Exposition-only concepts
 (C++20)
Definido en el encabezado <concepts>
template < class T >

concepto totalmente_ordenado =

std:: equality_comparable < T > && __PartiallyOrderedWith < T, T > ;
(1) (desde C++20)
template < class T, class U >

concepto totalmente_ordenado_con =
std :: totally_ordered < T > &&
std :: totally_ordered < U > &&
std:: equality_comparable_with < T, U > &&
std :: totally_ordered <
std:: common_reference_t <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & >> &&

__PartiallyOrderedWith < T, U > ;
(2) (desde C++20)
Conceptos auxiliares
template < class T, class U >

concepto __PartiallyOrderedWith =
requiere ( const std:: remove_reference_t < T > & t,
const std:: remove_reference_t < U > & u ) {
{ t < u } - > boolean-testable ;
{ t > u } - > boolean-testable ;
{ t <= u } - > boolean-testable ;
{ t >= u } - > boolean-testable ;
{ u < t } - > boolean-testable ;
{ u > t } - > boolean-testable ;
{ u <= t } - > boolean-testable ;
{ u >= t } - > boolean-testable ;

} ;
(3) ( solo para exposición* )
1) El concepto std::totally_ordered especifica que los operadores de comparación ==,!=,<,>,<=,>= en un tipo producen resultados consistentes con un orden total estricto en el tipo.
2) El concepto std::totally_ordered_with especifica que los operadores de comparación ==,!=,<,>,<=,>= en operandos (posiblemente mixtos) de T y U producen resultados consistentes con un orden total estricto. La comparación de operandos mixtos produce resultados equivalentes a comparar los operandos convertidos a su tipo común.
3) El concepto de solo exposición __PartiallyOrderedWith especifica que un valor de tipo T y un valor de tipo U pueden ser comparados en un orden parcial entre sí (en cualquier orden) usando < , > , <= , y >= , y los resultados de las comparaciones son consistentes.

Contenidos

Requisitos semánticos

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

1) std :: totally_ordered < T > se modela solo si, dados lvalues a , b y c de tipo const std:: remove_reference_t < T > :
  • Exactamente uno de bool ( a < b ) , bool ( a > b ) y bool ( a == b ) es true ;
  • Si bool ( a < b ) y bool ( b < c ) son ambos true , entonces bool ( a < c ) es 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

sea C el 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 ) :

(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:

  • 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 > se modela solo si, dados

lo siguiente es verdadero:

  • t < u , t <= u , t > u , t >= u , u < t , u <= t , u > t , y u >= t tienen el mismo dominio;
  • bool ( t < u ) == bool ( u > t ) ;
  • bool ( u < t ) == bool ( t > u ) ;
  • bool ( t <= u ) == bool ( u >= t ) ; y
  • bool ( u <= t ) == bool ( t >= u ) .

Preservación de la igualdad

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

Variaciones de expresión implícita

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

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 18.5.5 Concepto totally_ordered [concept.totallyordered]
  • Estándar C++20 (ISO/IEC 14882:2020):
  • 18.5.4 Concepto totally_ordered [concept.totallyordered]

Véase también

(C++20)
especifica que el operador <=> produce un resultado consistente en los tipos dados
(concept)