Namespaces
Variants

    std::partial_ordering

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostic
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilités générales
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilités
    Support linguistique
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilités de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilités générales
    Opérateurs relationnels (obsolète en C++20)
     
    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 const publics de l'argument. En d'autres termes, des valeurs équivalentes peuvent être distinguables.
    • Admet des valeurs non comparables : a < b, a == b et a > b peuvent tous être false.

    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)