Espacios de nombres
Variantes
Acciones

std::strong_ordering

De cppreference.com
< cpp‎ | utility
 
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
 
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.

Contenido

[editar] 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)

[editar] 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.

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
 implicit conversion to 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.

[editar] 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.

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

operator==

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<

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

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>

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

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

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.

[editar] Ejemplo

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

[editar] 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]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/utility/compare/strong_ordering&oldid=37786»