Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Operador <=> — comparación de tres vías

El operador <=>, llamado «spaceship», describe una relación de orden entre valores. Las categorías de resultado estándar distinguen menor, equivalente, mayor y, a veces, desordenado. En una clase, una definición predeterminada permite comparar lexicográficamente los subobjetos.

Versión: C++23; repository compiler flag; example execution verified in isolation, production runtime not attested

Sintaxis

a <=> b
 auto operator<=>(const T&) const = default;

En a <=> b, el operador integrado devuelve un valor de un tipo de categoría de comparación estándar, no un bool. Un operator<=> definido por el usuario puede devolver bool. Las comparaciones integradas de enteros devuelven std::strong_ordering, mientras que las de punto flotante devuelven std::partial_ordering. Incluye <compare>. Comprueba un resultado de categoría estándar con result < 0, result == 0 o result > 0; no lo trates como un entero con valor -1, 0 o 1.

std::strong_ordering describe un orden total con igualdad; std::weak_ordering permite valores equivalentes que no tienen por qué ser intercambiables en observaciones del estado relevante para la comparación. std::partial_ordering también permite unordered, por ejemplo, al comparar con NaN. En ese caso, las tres pruebas < 0, == 0 y > 0 dan false; negar una prueba no establece por sí solo la relación opuesta.

En una clase, auto operator<=>(const T&) const = default; compara lexicográficamente: primero las clases base directas y después los miembros de datos no estáticos, en orden de declaración. El primer resultado distinto de cero pone fin a la comparación, incluido un resultado unordered. El tipo de retorno refleja la categoría más débil de los subobjetos. Si no está disponible una comparación necesaria de algún subobjeto, el operador predeterminado puede definirse como eliminado.

La resolución de sobrecargas puede usar <=> para admitir <, <=, > y >=; esto no genera cuatro funciones separadas. Un <=> predeterminado declarado dentro de una clase también declara implícitamente un operator== predeterminado si la clase no declara uno propio; != puede usar ==. Un <=> implementado manualmente no proporciona == por sí solo.

En el ejemplo, x decide la comparación antes que y: 1 < 2, así que a < b es verdadero aunque 9 > 0. El ejemplo está pensado para compilarse con -std=c++23. Su ejecución se verificó en un entorno aislado. Las fuentes presentan un borrador de trabajo en evolución, no un texto C++23 congelado.

Ejemplos

#include <compare>
#include <iostream>

struct Point {
    int x;
    int y;
    auto operator<=>(const Point&) const = default;
};

int main() {
    const Point a{1, 9};
    const Point b{2, 0};
    const auto result = a <=> b;
    std::cout << std::boolalpha
              << (result < 0) << '\n'
              << (a < b) << '\n'
              << (a == b) << '\n';
}

Resultado

true
true
false

El código mostrado se ejecutó sin cambios en un entorno aislado. La salida estándar (`stdout`) coincidió exactamente con la salida indicada.

Fuentes