Namespaces
Variants

    std::weak_ordering

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
    Funciones de comparación de enteros
    (C++20)(C++20)(C++20)    
    (C++20)
    Operaciones de intercambio y
    ranges::swap
    exchange
    declval
    to_underlying
    forward
    forward_like
    move
    move_if_noexcept
    as_const
    (C++17)
    tuple_size
    tuple_element
    apply
    make_from_tuple
    expected



     
    (C++23)<compare> 
    class weak_ordering;
    		Definido en el encabezado

    (desde C++20)std::weak_orderingEl tipo de clase 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) puede no ser equivalente a f(b), donde f denota una función que lee solo el estado relevante para la comparación que es accesible a través de los miembros públicos constantes del argumento. En otras palabras, los valores equivalentes pueden ser distinguibles.
    • No permite valores incomparables: exactamente uno de a < b, a == b o a > b debe ser true.

    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)