Espacios de nombres
Variantes

    std::strong_ordering

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios 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 apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de servicios
     
    <tbody> </tbody>
    Definido en el archivo de encabezado <compare>
    class strong_ordering;
    		 (desde C++20)

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

    • permite todos 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 solo el estado saliente de comparación que es accesible a través de los miembros públicos const del argumento. En otras palabras, los valores equivalentes son indistinguibles.
    • no implica sustituibilidad: si a es equivalente a b, f(a) puede no ser equivalente a f(b), where f denota una función que lee solo el estado saliente de comparación que es accesible a través de los miembros públicos const del argumento. En otras palabras, los valores equivalentes pueden ser indistinguibles.
    • no permite los valores incomparables: exactamente uno de a < b, a == b, or a > b debe ser verdadero.

    Constantes

    El tipo std::strong_ordering tiene cuatro valores válidos, implementados como datos miembro const static de su tipo:

    Constante miembro Definición
    less(inline constexpr)
    [estático]
    		 Un valor válido de tipo std::strong_ordering que indica una relación menor-que (ordenado antes).
    (constante miembro pública estática)
    equivalent(inline constexpr)
    [estático]
    		 Un valor válido de tipo std::strong_ordering que indica equivalencia (ordenado ni antes ni después), igual que equal.
    (constante miembro pública estática)
    equal(inline constexpr)
    [estático]
    		 Un valor válido de tipo std::strong_ordering que indica equivalencia (ordenado ni antes ni después), igual que equivalent.
    (constante miembro pública estática)
    greater(inline constexpr)
    [estático]
    		 Un valor válido de tipo std::strong_ordering que indica una relación mayor-que (ordenado después).
    (constante miembro pública estática)

    Conversiones

    std::strong_ordering es la más fuerte de las tres categorías de comparación: no es convertible implícitamente de cualquier otra categoría, y es implícitamente convertible a cualquiera de las otras dos categorías.

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

    std::strong_ordering::operator partial_ordering

    <tbody> </tbody>
    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.

    		implicit conversion to std::weak_ordering
    (función miembro pública)

    std::strong_ordering::operator weak_ordering

    <tbody> </tbody>
    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 están definidos entre valores de este tipo y el literal 0. Esto soporta las expresiones a <=> b == 0 o a <=> b < 0 que pueden usarse para convertir el resultado de una comparación de tres vías a una relación Booleana; véase std::is_eq, std::is_lt, etc.

    Estas funciones no son visibles a una búsqueda no calificada o calificada, y pueden encontrarse solamente mediante la búsqueda dependiente de argumento 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 no está definido.

    		Se compara con cero o un strong_ordering.
    (función)

    operator==

    <tbody> </tbody>
    friend constexpr bool operator==(strong_ordering v, /*no especificado*/ u) noexcept;
    		 (1)
    friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default;
    		 (2)

    Parámetros

    v, w - Valores std::strong_ordering a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    Valor de retorno

    1) true si v es equivalent o equal, false si v es less o greater
    2) true si ambos parámetros albergan el mismo valor; de lo contrario, false. Ten en cuenta que equal es igual que equivalent.

    operator<

    <tbody> </tbody>
    friend constexpr bool operator<(strong_ordering v, /*no especificado*/ u) noexcept;
    		 (1)
    friend constexpr bool operator<(/*no especificado*/ u, strong_ordering v) noexcept;
    		 (2)

    Parámetros

    v - Un valor std::strong_ordering a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    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<=

    <tbody> </tbody>
    friend constexpr bool operator<=(strong_ordering v, /*no especificado*/ u) noexcept;
    		 (1)
    friend constexpr bool operator<=(/*no especificado*/ u, strong_ordering v) noexcept;
    		 (2)

    Parámetros

    v - Un valor std::strong_ordering valor a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    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>

    <tbody> </tbody>
    friend constexpr bool operator>(strong_ordering v, /*no especificado*/ u) noexcept;
    		 (1)
    friend constexpr bool operator>(/*no especificado*/ u, strong_ordering v) noexcept;
    		 (2)

    Parámetros

    v - Un valor std::strong_ordering a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    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>=

    <tbody> </tbody>
    friend constexpr bool operator>=(strong_ordering v, /*no especificado*/ u) noexcept;
    		 (1)
    friend constexpr bool operator>=(/*no especificado*/ u, strong_ordering v) noexcept;
    		 (2)

    Parámetros

    v - Un valor std::strong_ordering a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    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<=>

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

    Parámetros

    v - Un valor std::strong_ordering a comprobar.
    u - Un parámetro sin usar de cualquier tipo que acepte el literal cero como argumento.

    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 del resultado de una comparación de tres vías que soporta todos los 6 operadores y no es sustituible.
    (clase) [editar]
    (C++20)
    		 El tipo del resultado de una comparación de tres vías que soporta todos los 6 operadores, no es sustituible y permite valores incomparables.
    (clase) [editar]