Namespaces
Variants

std:: weak_ordering

From cppreference.net
C++
Utilities library
Definido en el encabezado <compare>
class weak_ordering ;
(desde C++20)

El tipo de clase std::weak_ordering es el tipo de resultado de una comparación de tres vías que:

  • Admite los seis operadores relacionales ( == , != , < , <= , > , >= ).
  • No implica sustituibilidad: si a es equivalente a b , f ( a ) podría no ser equivalente a f ( b ) , donde f denota una función que lee únicamente el estado relevante para comparación accesible mediante los miembros públicos const del argumento. En otras palabras, valores equivalentes pueden ser distinguibles.
  • No permite valores incomparables : exactamente una de a < b , a == b , o a > b debe ser true .

Contenidos

Constantes

El tipo std::weak_ordering tiene tres valores válidos, implementados como miembros de datos estáticos constantes de su tipo:

Nombre Definición
inline constexpr std :: weak_ordering less
[static]
un valor válido que indica relación de menor-que (ordenado antes)
(constante de miembro público estático)
inline constexpr std :: weak_ordering equivalent
[static]
un valor válido que indica equivalencia (ni ordenado antes ni ordenado después)
(constante de miembro público estático)
inline constexpr std :: weak_ordering greater
[static]
un valor válido que indica relación de mayor-que (ordenado después)
(constante de miembro público estático)

Conversiones

std::weak_ordering es implícitamente convertible a std::partial_ordering , mientras que std::strong_ordering es implícitamente convertible a weak_ordering .

operator partial_ordering
conversión implícita a std::partial_ordering
(función miembro pública)

std::weak_ordering:: operator partial_ordering

constexpr operator partial_ordering ( ) const noexcept ;

Valor de retorno

std::partial_ordering::less si v es less , std::partial_ordering::greater si v es greater , std::partial_ordering::equivalent si v es equivalent .

Comparaciones

Los operadores de comparación se definen entre valores de este tipo y el literal ​ 0 ​ . Esto permite expresiones como a <=> b == 0 o a <=> b < 0 que pueden utilizarse para convertir el resultado de un operador de comparación de tres vías a una relación booleana; consulte std::is_eq , std::is_lt , etc.

Estas funciones no son visibles para la búsqueda no calificada o calificada ordinaria, y solo pueden ser encontradas mediante búsqueda dependiente de argumentos cuando std::weak_ordering es una clase asociada de los argumentos.

El comportamiento de un programa que intenta comparar un weak_ordering con cualquier cosa que no sea el literal entero ​ 0 ​ está indefinido.

operator== operator< operator> operator<= operator>= operator<=>
compara con cero o un weak_ordering
(función)

operator==

friend constexpr bool operator == ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator == ( weak_ordering v, weak_ordering w ) noexcept = default ;
(2)

Parámetros

v, w - std::weak_ordering valores a verificar
u - un parámetro no utilizado de cualquier tipo que acepte el argumento de cero literal

Valor de retorno

1) true si v es equivalente , false si v es menor o mayor
2) true si ambos parámetros contienen el mismo valor, false en caso contrario

operator<

friend constexpr bool operator < ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator < ( /*unspecified*/ u, weak_ordering v ) noexcept ;
(2)

Parámetros

v - un valor std::weak_ordering a verificar
u - un parámetro no utilizado de cualquier tipo que acepte el argumento literal cero

Valor de retorno

1) true si v es less , y false si v es greater o equivalent
2) true si v es greater , y false si v es less o equivalent

operator<=

friend constexpr bool operator <= ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator <= ( /*unspecified*/ u, weak_ordering v ) noexcept ;
(2)

Parámetros

v - un valor std::weak_ordering a verificar
u - un parámetro no utilizado de cualquier tipo que acepte el argumento literal cero

Valor de retorno

1) true si v es less o equivalent , y false si v es greater
2) true si v es greater o equivalent , y false si v es less

operator>

friend constexpr bool operator > ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator > ( /*unspecified*/ u, weak_ordering v ) noexcept ;
(2)

Parámetros

v - un valor std::weak_ordering a verificar
u - un parámetro no utilizado de cualquier tipo que acepte argumento de cero literal

Valor de retorno

1) true si v es greater , y false si v es less o equivalent
2) true si v es less , y false si v es greater o equivalent

operator>=

friend constexpr bool operator >= ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator >= ( /*unspecified*/ u, weak_ordering v ) noexcept ;
(2)

Parámetros

v - un valor std::weak_ordering a verificar
u - un parámetro no utilizado de cualquier tipo que acepte el argumento de cero literal

Valor de retorno

1) true si v es greater o equivalent , y false si v es less
2) true si v es less o equivalent , y false si v es greater

operator<=>

friend constexpr weak_ordering operator <=> ( weak_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr weak_ordering operator <=> ( /*unspecified*/ u, weak_ordering v ) noexcept ;
(2)

Parámetros

v - un valor std::weak_ordering a verificar
u - un parámetro no utilizado de cualquier tipo que acepte argumento de cero literal

Valor de retorno

1) v .
2) greater si v es less , less si v es greater , de lo contrario v .

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Véase también

(C++20)
el tipo de resultado de comparación de 3 vías que admite los 6 operadores y es sustituible
(class)
(C++20)
el tipo de resultado de comparación de 3 vías que admite los 6 operadores, no es sustituible y permite valores incomparables
(class)