Namespaces
Variants

    std::weak_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 diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes de caractères
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et d'heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de 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'utilitaires
    Support linguistique
    Support de type (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires 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)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
     
    Défini dans l'en-tête <compare> 
    class weak_ordering;
    		(depuis C++20)

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

    • Accepte 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.
    • Ne permet pas de valeurs incomparables : exactement un de a < b, a == b, ou a > b doit être true.

    Constantes

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

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

    Conversions

    std::weak_ordering est implicitement convertible en std::partial_ordering , tandis que std::strong_ordering est implicitement convertible en weak_ordering .

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

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

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

    operator==

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

    Paramètres

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

    Valeur de retour

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

    operator<

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

    Paramètres

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

    operator<=

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

    Paramètres

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

    operator>

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

    Paramètres

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

    operator>=

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

    Paramètres

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

    operator<=>

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

    Paramètres

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

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

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