Namespaces
Variants

std:: strong_ordering

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

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

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

Contenidos

Constantes

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

Nombre Definición
inline constexpr std :: strong_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 :: strong_ordering equivalent
[static]
un valor válido que indica equivalencia (ni ordenado antes ni ordenado después), igual que equal
(constante de miembro público estático)
inline constexpr std :: strong_ordering equal
[static]
un valor válido que indica equivalencia (ni ordenado antes ni ordenado después), igual que equivalent
(constante de miembro público estático)
inline constexpr std :: strong_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::strong_ordering es el más fuerte de las tres categorías de comparación: no es convertible implícitamente desde ninguna otra categoría y es convertible implícitamente a las otras dos.

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

std::strong_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 equal o equivalent .

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

std::strong_ordering:: operator weak_ordering

constexpr operator weak_ordering ( ) const noexcept ;

Valor de retorno

std::weak_ordering::less si v es less , std::weak_ordering::greater si v es greater , std::weak_ordering::equivalent si v es equal o 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::strong_ordering es una clase asociada de los argumentos.

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

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

operator==

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

Parámetros

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

Valor de retorno

1) true si v es equivalent o equal , false si v es less o greater
2) true si ambos parámetros contienen el mismo valor, false en caso contrario. Nótese que equal es lo mismo que equivalent .

operator<

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

Parámetros

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

Valor de retorno

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

operator<=

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

Parámetros

v - un valor de std::strong_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 less , equivalent , o equal , y false si v es greater
2) true si v es greater , equivalent , o equal , y false si v es less

operator>

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

Parámetros

v - un valor std::strong_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 , equivalent , o equal
2) true si v es less , y false si v es greater , equivalent , o equal

operator>=

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

Parámetros

v - un valor std::strong_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 greater , equivalent , o equal , y false si v es less
2) true si v es less , equivalent , o equal , y false si v es greater

operator<=>

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

Parámetros

v - un valor std::strong_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

Ejecutar este código 
#include <compare>
#include <iostream>
struct Point
{
    int x{}, y{};
    friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs)
    {
        if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y))
            return std::strong_ordering::less;
        if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y))
            return std::strong_ordering::greater;
        return std::strong_ordering::equivalent;
    }
    friend std::ostream& operator<<(std::ostream& os, Point s)
    {
        return os << '(' << s.x << ',' << s.y << ')';
    }
};
void print_three_way_comparison(const auto& p, const auto& q)
{
    const auto cmp{p <=> q};
    std::cout << p
              << (cmp < 0 ? " <  " : cmp > 0 ? " >  " : " == " ) // compara con 0
              << q << '\n';
}
void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // compara p y q
              << q << '\n';
}
int main()
{
    const Point p1{0, 1}, p2{0, 1}, p3{0, 2};
    print_three_way_comparison(p1, p2);
    print_two_way_comparison(p1, p2);
    print_three_way_comparison(p2, p3);
    print_two_way_comparison(p2, p3);
    print_three_way_comparison(p3, p2);
    print_two_way_comparison(p3, p2);
}

Salida: 

(0,1) == (0,1)
(0,1) == (0,1)
(0,1) <  (0,2)
(0,1) <  (0,2)
(0,2) >  (0,1)
(0,2) >  (0,1)

Véase también

(C++20)
el tipo de resultado de comparación de 3 vías que admite los 6 operadores y no 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)