std::strong_ordering

class strong_ordering;

Le type de classe std::strong_ordering est le type de résultat d'une comparaison à trois voies qui :

• Admet les six opérateurs relationnels (==, !=, <, <=, >, >=).

• Implique la substituabilité : si a est équivalent à b, alors f(a) est également équivalent à f(b), où f désigne une fonction qui lit uniquement l'état pertinent pour la comparaison accessible via les membres publics constants de l'argument. En d'autres termes, les valeurs équivalentes sont indiscernables.
• Ne permet pas de valeurs non comparables : exactement une des valeurs a < b, a == b ou a > b doit être true.

Constantes

Le type std::strong_ordering possède quatre valeurs valides, implémentées en tant que membres de données statiques constants de son type :

Conversions

std::strong_ordering est le plus fort des trois catégories de comparaison : il n'est pas implicitement convertible depuis aucune autre catégorie et est implicitement convertible vers les deux autres.

Comparaisons

Les opérateurs de comparaison sont définis entre les valeurs de ce type et le littéral ​ 0 ​ . Cela prend en charge les expressions a <=> b == 0 ou a <=> b < 0 qui peuvent être utilisées pour convertir le résultat d'un opérateur de comparaison à trois voies en une relation booléenne ; voir std::is_eq , std::is_lt , etc.

Ces fonctions ne sont pas visibles par la recherche non qualifiée ou qualifiée ordinaire, et ne peuvent être trouvées que par la recherche dépendante des arguments lorsque std::strong_ordering est une classe associée des arguments.

Le comportement d'un programme qui tente de comparer un strong_ordering avec autre chose que le littéral entier ​ 0 ​ est indéfini.

Exemple

#include <compare>
#include <iostream>
struct Point
{
    int x{}, y{};
    friend constexpr std::strong_ordering operator<=>(Point lhs, Point rhs)
    {
        if (lhs.x < rhs.x or (lhs.x == rhs.x and lhs.y < rhs.y))
            return std::strong_ordering::less;
        if (lhs.x > rhs.x or (lhs.x == rhs.x and lhs.y > rhs.y))
            return std::strong_ordering::greater;
        return std::strong_ordering::equivalent;
    }
    friend std::ostream& operator<<(std::ostream& os, Point s)
    {
        return os << '(' << s.x << ',' << s.y << ')';
    }
};
void print_three_way_comparison(const auto& p, const auto& q)
{
    const auto cmp{p <=> q};
    std::cout << p
              << (cmp < 0 ? " <  " : cmp > 0 ? " >  " : " == " ) // compare avec 0
              << q << '\n';
}
void print_two_way_comparison(const auto& p, const auto& q)
{
    std::cout << p
              << (p < q ? " <  " : p > q ? " >  " : " == ") // compare p et q
              << q << '\n';
}
int main()
{
    const Point p1{0, 1}, p2{0, 1}, p3{0, 2};
    print_three_way_comparison(p1, p2);
    print_two_way_comparison(p1, p2);
    print_three_way_comparison(p2, p3);
    print_two_way_comparison(p2, p3);
    print_three_way_comparison(p3, p2);
    print_two_way_comparison(p3, p2);
}

(0,1) == (0,1)
(0,1) == (0,1)
(0,1) <  (0,2)
(0,1) <  (0,2)
(0,2) >  (0,1)
(0,2) >  (0,1)

Voir aussi