¿Cuál es el operador <=> en C ++?

Mientras intentaba aprender sobre los operadores de C ++ , me topé con un extraño operador de comparación en cppreference.com , ^* en una tabla que se veía así:

"Bueno, si estos son operadores comunes en C ++, será mejor que los aprenda", pensé. Pero todos mis intentos de dilucidar este misterio no tuvieron éxito. Incluso aquí, en Stack Overflow, no tuve suerte en mi búsqueda.

¿Hay alguna conexión entre <=> y C ++ ?

Y si lo hay, ¿qué hace exactamente este operador?

_{* Mientras tanto, cppreference.com actualizó esa página y ahora contiene información sobre el <=>operador.}

Esto se llama el operador de comparación de tres vías .

De acuerdo con la propuesta de papel P0515 :

Hay un nuevo operador de comparación de tres vías, <=>. La expresión a <=> bdevuelve un objeto que compara <0if a < b, compara >0if a > by compara ==0if ay bson iguales / equivalentes.

Para escribir todas las comparaciones para su tipo, solo escriba operator<=>que devuelva el tipo de categoría apropiado:

• Devolver un _ordering Si el tipo de soportes, naturalmente <, y vamos a generar de manera eficiente <, >, <=, >=, ==, y !=; de lo contrario, devolverá una _equality , y generaremos eficientemente == y ! = .

• Regrese fuerte si para su tipo a == bimplica f(a) == f(b)(sustituibilidad, donde f lee solo el estado relevante de comparación accesible usando la interfaz const no privada), de lo contrario, devuelva débil.

La cppreference dice:

Las expresiones de operador de comparación de tres vías tienen la forma

lhs <=> rhs   (1)  

La expresión devuelve un objeto que

• compara <0silhs < rhs
• compara >0silhs > rhs
• y compara ==0si lhsy rhsson iguales / equivalentes.

El 11-11-2017 , el comité ISO C ++ adoptó la propuesta de Herb Sutter para el operador de comparación de tres vías <=> "nave espacial" como una de las nuevas características que se agregaron a C ++ 20 . En el artículo titulado Comparación consistente Sutter, Maurer y Brown demuestran los conceptos del nuevo diseño. Para obtener una descripción general de la propuesta, aquí hay un extracto del artículo:

La expresión a <=> b devuelve un objeto que compara <0 si a <b , compara > 0 si a> b , y compara == 0 si a y b son iguales / equivalentes.

Caso común: para escribir todas las comparaciones para su tipo X con el tipo Y , con la semántica de miembro, simplemente escriba:

auto X::operator<=>(const Y&) =default;

Casos avanzados: para escribir todas las comparaciones para su tipo X con el tipo Y , simplemente escriba el operador <=> que toma una Y , puede usar = default para obtener la semántica de miembro si lo desea, y devuelve el tipo de categoría apropiado:

• Devuelva una orden si su tipo admite naturalmente < , y generaremos eficientemente < , > , <= , > = , == y ! = ; de lo contrario, devolverá una _equality y generaremos eficientemente simétrica == y ! = .
• Devuelva strong_ si para su tipo a == b implica f (a) == f (b) (sustituibilidad, donde f lee solo el estado relevante de comparación al que se puede acceder utilizando los miembros de const público ), de lo contrario, devuelve débil_ .

Categorías de comparación

Cinco categorías de comparación se definen como std::tipos, cada una con los siguientes valores predefinidos:

+--------------------------------------------------------------------+
|                  |          Numeric  values          | Non-numeric |
|     Category     +-----------------------------------+             |
|                  | -1   | 0          | +1            |   values    |
+------------------+------+------------+---------------+-------------+
| strong_ordering  | less | equal      | greater       |             |
| weak_ordering    | less | equivalent | greater       |             |
| partial_ordering | less | equivalent | greater       | unordered   |
| strong_equality  |      | equal      | nonequal      |             |
| weak_equality    |      | equivalent | nonequivalent |             |
+------------------+------+------------+---------------+-------------+

Las conversiones implícitas entre estos tipos se definen de la siguiente manera:

• strong_orderingcon valores { less, equal, greater} convierte implícitamente a:
  • weak_orderingcon los valores { less, equivalent, greater}
  • partial_orderingcon los valores { less, equivalent, greater}
  • strong_equalitycon los valores { unequal, equal, unequal}
  • weak_equalitycon los valores { nonequivalent, equivalent, nonequivalent}
• weak_orderingcon valores { less, equivalent, greater} convierte implícitamente a:
  • partial_orderingcon los valores { less, equivalent, greater}
  • weak_equalitycon los valores { nonequivalent, equivalent, nonequivalent}
• partial_orderingcon valores { less, equivalent, greater, unordered} convierte implícitamente a:
  • weak_equalitycon los valores { nonequivalent, equivalent, nonequivalent, nonequivalent}
• strong_equalitycon valores { equal, unequal} se convierte implícitamente en:
  • weak_equalitycon valores { equivalent, nonequivalent}

Comparación de tres vías

Se <=>introduce el token. La secuencia de caracteres se <=>tokeniza <= >en el código fuente anterior. Por ejemplo, X<&Y::operator<=>necesita agregar un espacio para retener su significado.

El operador sobrecargable <=>es una función de comparación de tres vías y tiene prioridad mayor que <y menor que <<. Devuelve un tipo que se puede comparar con el literal, 0pero se permiten otros tipos de retorno, como para admitir plantillas de expresión. Todos los <=>operadores definidos en el idioma y en la biblioteca estándar devuelven uno de los 5 std::tipos de categorías de comparación mencionados anteriormente .

Para los tipos de idioma, se proporcionan las siguientes <=>comparaciones integradas del mismo tipo. Todos son constexpr , excepto donde se indique lo contrario. Estas comparaciones no pueden invocarse heterogéneamente usando promociones / conversiones escalares.

• For bool, integral y tipos de puntero, <=>devuelve strong_ordering.
• Para los tipos de puntero, las diferentes calificaciones de cv y las conversiones derivadas a base pueden invocar una función integrada homogénea <=>, y hay funciones heterogéneas integradas operator<=>(T*, nullptr_t). Solo las comparaciones de punteros al mismo objeto / asignación son expresiones constantes.
• Para los tipos de coma flotante fundamentales, <=>retornos partial_ordering, y se puede invocar de manera heterogénea ampliando los argumentos a un tipo de coma flotante más grande.
• Para las enumeraciones, <=>devuelve lo mismo que los tipos subyacentes de la enumeración <=>.
• Para nullptr_t, <=>vuelve strong_orderingy siempre rinde equal.
• Para matrices copiables, T[N] <=> T[N]devuelve el mismo tipo que T's <=>y realiza una comparación lexicográfica por elementos. No hay <=>para otras matrices.
• Por voidallí no está <=>.

_{Para comprender mejor el funcionamiento interno de este operador, lea el documento original . Esto es justo lo que descubrí usando los motores de búsqueda.}

Esta respuesta se ha vuelto irrelevante desde que la página web referenciada ha cambiado

La página web a la que hace referencia estaba rota. Se estaba editando mucho ese día y las diferentes partes no estaban sincronizadas. El estado cuando lo miraba era:

En la parte superior de la página, enumera los operadores de comparación existentes actualmente (en C ++ 14). No hay <=>ahi.

En la parte inferior de la página, deberían haber enumerado los mismos operadores, pero se burlaron y agregaron esta sugerencia futura.

gccaún no lo sabe <=>(y con -std=c++14, nunca lo sabrá), por lo que cree que lo quiso decir a <= > b. Esto explica el mensaje de error.

Si intenta lo mismo dentro de cinco años, probablemente obtendrá un mejor mensaje de error, algo como <=> not part of C++14.