Namespaces
Variants

std:: partial_ordering

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

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

  • Admet les six opérateurs relationnels ( == , != , < , <= , > , >= ).
  • N'implique pas la substituabilité : si a est équivalent à b , f ( a ) peut ne pas être é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, des valeurs équivalentes peuvent être distinguables.
  • Admet des valeurs incomparables : a < b , a == b , et a > b peuvent toutes être false .

Table des matières

Constantes

Le type std::partial_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 :: partial_ordering less
[static]
une valeur valide indiquant une relation d'infériorité (ordonné avant)
(constante de membre public static)
inline constexpr std :: partial_ordering equivalent
[static]
une valeur valide indiquant une équivalence (ni ordonné avant ni ordonné après)
(constante de membre public static)
inline constexpr std :: partial_ordering greater
[static]
une valeur valide indiquant une relation de supériorité (ordonné après)
(constante de membre public static)
inline constexpr std :: partial_ordering unordered
[static]
une valeur valide indiquant une relation avec une valeur non comparable
(constante de membre public static)

Conversions

std::partial_ordering ne peut pas être implicitement converti en d'autres types de catégories de comparaison, tandis que std::strong_ordering et std::weak_ordering sont implicitement convertibles en partial_ordering .

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::partial_ordering est une classe associée des arguments.

Le comportement d'un programme qui tente de comparer un partial_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 partial_ordering
(fonction)

operator==

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

Paramètres

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

Valeur de retour

1) true si v est equivalent , false si v est less , greater , ou unordered
2) true si les deux paramètres contiennent la même valeur, false sinon

operator<

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

Paramètres

v - une valeur std::partial_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 less , et false si v est greater , equivalent , ou unordered
2) true si v est greater , et false si v est less , equivalent , ou unordered

operator<=

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

Paramètres

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

Valeur de retour

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

operator>

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

Paramètres

v - une valeur std::partial_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 unordered
2) true si v est less , et false si v est greater , equivalent , ou unordered

operator>=

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

Paramètres

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

Valeur de retour

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

operator<=>

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

Paramètres

v - une valeur std::partial_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 .

Notes

Le opérateur intégré operator<=> entre les valeurs à virgule flottante utilise cet ordre : le zéro positif et le zéro négatif sont comparés comme équivalents , mais peuvent être distingués, et les valeurs NaN sont comparées comme non ordonnées avec toute autre valeur.

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

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