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

CKTIS / C++

Operador de comparación definido por defecto

`= default` indica al compilador que genere la implementación de un operador de comparación. Si se definen por defecto, `operator==` y `operator<=>` comparan los subobjetos de la clase en un orden establecido: el primero comprueba la igualdad y el segundo determina el orden. Los operadores secundarios definidos por defecto, como `!=` y `<`, usan comparaciones reescritas en vez de comparar los subobjetos por sí mismos.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

struct T {
    bool operator==(const T&) const = default;
    auto operator<=>(const T&) const = default;
};

Un Defaulted comparison operator es un operador de comparación cuya implementación genera el compilador mediante = default. Debe ser una función que no sea plantilla: una función miembro no estática o una función friend de una clase. Una definición con = default dentro de la clase debe ser la primera declaración de esa función.

La comparación visita primero las clases base directas y después los miembros de datos no estáticos, en orden de declaración. Los arrays se expanden en sus elementos. operator== debe devolver bool y se detiene en el primer par desigual. operator<=> compara lexicográficamente: el primer par que produce un resultado de comparación distinto de cero determina el resultado. Por eso, en el ejemplo, a < b es verdadero aunque 9 > 0.

Con auto operator<=>, el compilador deduce la categoría de comparación común de los subobjetos: std::strong_ordering, std::weak_ordering o std::partial_ordering. Si la clase no declara explícitamente un miembro o una función friend llamada operator==, un operator<=> definido por defecto dentro de la clase también declara implícitamente un operator== definido por defecto. Definir operator== por defecto por sí solo no proporciona orden.

Los operadores secundarios !=, <, <=, > y >= también pueden definirse por defecto; requieren un resultado bool y una reescritura válida de la comparación, en lugar de comparar los miembros de forma independiente. En el uso habitual, las expresiones usan una reescritura basada en == o <=>, sin declaraciones separadas de estos operadores.

= default no garantiza que el operador sea válido: una comparación de subobjeto inaccesible o no admitida puede hacer que se defina como eliminado. Esto también se aplica a == y <=> en clases con miembros de datos de referencia o miembros variante de uniones. Escribe una implementación propia si no todos los subobjetos deben contribuir al resultado.

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 Point c{1, 9};

    std::cout << std::boolalpha;
    std::cout << (a == c) << '\n';
    std::cout << (a != b) << '\n';
    std::cout << (a < b) << '\n';
}

Resultado

true
true
true

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes