Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Opérateur <=> — comparaison à trois voies

L’opérateur <=>, appelé « spaceship », décrit une relation d’ordre entre des valeurs. Les catégories de résultat standard distinguent inférieur, équivalent, supérieur et parfois non ordonné. Dans une classe, une définition par défaut permet de comparer les sous-objets de façon lexicographique.

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

Syntaxe

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

Dans a <=> b, l’opérateur intégré renvoie une valeur d’un type de catégorie de comparaison standard, et non un bool. Un operator<=> défini par l’utilisateur peut renvoyer un bool. Les comparaisons intégrées d’entiers renvoient std::strong_ordering, tandis que celles des nombres à virgule flottante renvoient std::partial_ordering. Incluez <compare>. Testez un résultat de catégorie standard avec result < 0, result == 0 ou result > 0 ; ne le traitez pas comme un entier contenant -1, 0 ou 1.

std::strong_ordering décrit un ordre total avec égalité ; std::weak_ordering autorise des valeurs équivalentes qui ne sont pas nécessairement substituables du point de vue des observations portant sur l’état pertinent pour la comparaison. std::partial_ordering autorise aussi unordered, par exemple lors d’une comparaison avec NaN. Dans ce cas, les trois tests < 0, == 0 et > 0 valent false ; nier un test ne suffit pas à établir la relation opposée.

Dans une classe, auto operator<=>(const T&) const = default; effectue une comparaison lexicographique : d’abord les classes de base directes, puis les membres de données non statiques, dans l’ordre de déclaration. Le premier résultat différent de zéro termine la comparaison, y compris s’il vaut unordered. Le type de retour tient compte de la catégorie la plus faible des sous-objets. Si une comparaison requise d’un sous-objet n’est pas disponible, l’opérateur par défaut peut être défini comme supprimé.

La résolution de surcharge peut utiliser <=> pour prendre en charge <, <=, > et >= ; cela ne génère pas quatre fonctions distinctes. Un <=> défini par défaut et déclaré dans une classe déclare aussi implicitement un operator== par défaut si la classe ne déclare pas son propre operator== ; != peut utiliser ==. Un <=> implémenté manuellement ne fournit pas à lui seul ==.

Dans l’exemple, x décide du résultat avant y : 1 < 2, donc a < b est vrai malgré 9 > 0. L’exemple est destiné à être compilé avec -std=c++23. Son exécution a été vérifiée dans un environnement isolé. Les sources présentent un projet en évolution, et non un texte C++23 figé.

Exemples

#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';
}

Résultat

true
true
false

Le code affiché a été exécuté sans modification dans un environnement isolé. La sortie standard (`stdout`) correspondait exactement à la sortie indiquée.

Sources