Namespaces
Variants

std:: strong_ordering

From cppreference.net
C++
Utilities library
Défini dans l'en-tête <compare>
class strong_ordering ;
(depuis C++20)

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 , 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. Autrement dit, les valeurs équivalentes sont indiscernables.
  • N'autorise pas de valeurs incomparables : exactement une des expressions a < b , a == b , ou a > b doit être true .

Table des matières

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 :

Nom Définition
inline constexpr std :: strong_ordering less
[static]
une valeur valide indiquant une relation d'infériorité (ordonné avant)
(constante de membre public static)
inline constexpr std :: strong_ordering equivalent
[static]
une valeur valide indiquant une équivalence (ni ordonné avant ni ordonné après), identique à equal
(constante de membre public static)
inline constexpr std :: strong_ordering equal
[static]
une valeur valide indiquant une équivalence (ni ordonné avant ni ordonné après), identique à equivalent
(constante de membre public static)
inline constexpr std :: strong_ordering greater
[static]
une valeur valide indiquant une relation de supériorité (ordonné après)
(constante de membre public static)

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.

operator partial_ordering
conversion implicite en std::partial_ordering
(fonction membre publique)

std::strong_ordering:: operator partial_ordering

constexpr operator partial_ordering ( ) const noexcept ;

Valeur de retour

std::partial_ordering::less si v est less , std::partial_ordering::greater si v est greater , std::partial_ordering::equivalent si v est equal ou equivalent .

operator weak_ordering
conversion implicite en std::weak_ordering
(fonction membre publique)

std::strong_ordering:: operator weak_ordering

constexpr operator weak_ordering ( ) const noexcept ;

Valeur de retour

std::weak_ordering::less si v est less , std::weak_ordering::greater si v est greater , std::weak_ordering::equivalent si v est equal ou equivalent .

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.

operator== operator< operator> operator<= operator>= operator<=>
compare avec zéro ou un strong_ordering
(fonction)

operator==

friend constexpr bool
operator == ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool
operator == ( strong_ordering v, strong_ordering w ) noexcept = default ;
(2)

Paramètres

v, w - std::strong_ordering valeurs à vérifier
u - un paramètre inutilisé de tout type qui accepte l'argument littéral zéro

Valeur de retour

1) true si v est equivalent ou equal , false si v est less ou greater
2) true si les deux paramètres contiennent la même valeur, false sinon. Notez que equal est identique à equivalent .

operator<

friend constexpr bool operator < ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator < ( /*unspecified*/ u, strong_ordering v ) noexcept ;
(2)

Paramètres

v - une valeur std::strong_ordering à vérifier
u - un paramètre inutilisé de tout type acceptant un argument zéro littéral

Valeur de retour

1) true si v est less , et false si v est greater , equivalent , ou equal
2) true si v est greater , et false si v est less , equivalent , ou equal

operator<=

friend constexpr bool operator <= ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator <= ( /*unspecified*/ u, strong_ordering v ) noexcept ;
(2)

Paramètres

v - une valeur std::strong_ordering à vérifier
u - un paramètre inutilisé de tout type qui accepte l'argument littéral zéro

Valeur de retour

1) true si v est less , equivalent , ou equal , et false si v est greater
2) true si v est greater , equivalent , ou equal , et false si v est less

operator>

friend constexpr bool operator > ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator > ( /*unspecified*/ u, strong_ordering v ) noexcept ;
(2)

Paramètres

v - une valeur std::strong_ordering à vérifier
u - un paramètre inutilisé de tout type qui accepte l'argument zéro littéral

Valeur de retour

1) true si v est greater , et false si v est less , equivalent , ou equal
2) true si v est less , et false si v est greater , equivalent , ou equal

operator>=

friend constexpr bool operator >= ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr bool operator >= ( /*unspecified*/ u, strong_ordering v ) noexcept ;
(2)

Paramètres

v - une valeur std::strong_ordering à vérifier
u - un paramètre inutilisé de tout type qui accepte l'argument littéral zéro

Valeur de retour

1) true si v est greater , equivalent , ou equal , et false si v est less
2) true si v est less , equivalent , ou equal , et false si v est greater

operator<=>

friend constexpr strong_ordering
operator <=> ( strong_ordering v, /*unspecified*/ u ) noexcept ;
(1)
friend constexpr strong_ordering
operator <=> ( /*unspecified*/ u, strong_ordering v ) noexcept ;
(2)

Paramètres

v - une valeur std::strong_ordering à vérifier
u - un paramètre inutilisé de tout type acceptant un argument zéro littéral

Valeur de retour

1) v .
2) greater si v est less , less si v est greater , sinon v .

Exemple

Exécuter ce code 
#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);
}

Sortie : 

(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

(C++20)
le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs et n'est pas substituable
(classe)
(C++20)
le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs, n'est pas substituable et autorise des valeurs incomparables
(classe)