Namespaces
Variants

    operator==, !=, <, <=, >, >=, <=>(std::optional)

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Installations autonomes et hébergées
    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 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'utilitaires
    Support linguistique
    Support des types (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 (obsolète en C++20)
     
    std::optional
     
    Défini dans l'en-tête <optional>
    Compare deux optional objets
    		 
    template< class T, class U >
constexpr bool operator==( const optional<T>& lhs, const optional<U>& rhs );
    		(1) (depuis C++17) 
    template< class T, class U >
constexpr bool operator!=( const optional<T>& lhs, const optional<U>& rhs );
    		(2) (depuis C++17) 
    template< class T, class U >
constexpr bool operator<( const optional<T>& lhs, const optional<U>& rhs );
    		(3) (depuis C++17) 
    template< class T, class U >
constexpr bool operator<=( const optional<T>& lhs, const optional<U>& rhs );
    		(4) (depuis C++17) 
    template< class T, class U >
constexpr bool operator>( const optional<T>& lhs, const optional<U>& rhs );
    		(5) (depuis C++17) 
    template< class T, class U >
constexpr bool operator>=( const optional<T>& lhs, const optional<U>& rhs );
    		(6) (depuis C++17) 
    template< class T, std::three_way_comparable_with<T> U >
constexpr std::compare_three_way_result_t<T, U>
    operator<=>( const optional<T>& lhs, const optional<U>& rhs );
    		(7) (depuis C++20)
    Compare un optional objet avec un nullopt
    		 
    template< class T >
constexpr bool operator==( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(8) (depuis C++17) 
    template< class T >
constexpr bool operator==( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(9) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator!=( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(10) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator!=( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(11) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator<( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(12) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator<( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(13) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator<=( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(14) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator<=( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(15) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator>( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(16) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr bool operator>( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(17) (depuis C++17)
    (jusqu'à C++20) 
    template< class T > 
constexpr bool operator>=( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(18) (depuis C++17)
    (jusqu'à C++20) 
    template< class T > 
constexpr bool operator>=( std::nullopt_t, const optional<T>& opt ) noexcept;
    		(19) (depuis C++17)
    (jusqu'à C++20) 
    template< class T >
constexpr std::strong_ordering
    operator<=>( const optional<T>& opt, std::nullopt_t ) noexcept;
    		(20) (depuis C++20)
    Compare un optional objet avec une valeur
    		 
    template< class T, class U >
constexpr bool operator==( const optional<T>& opt, const U& value );
    		(21) (depuis C++17) 
    template< class U, class T >
constexpr bool operator==( const U& value, const optional<T>& opt );
    		(22) (depuis C++17) 
    template< class T, class U >
constexpr bool operator!=( const optional<T>& opt, const U& value );
    		(23) (depuis C++17) 
    template< class U, class T >
constexpr bool operator!=( const U& value, const optional<T>& opt );
    		(24) (depuis C++17) 
    template< class T, class U >
constexpr bool operator<( const optional<T>& opt, const U& value );
    		(25) (depuis C++17) 
    template< class U, class T >
constexpr bool operator<( const U& value, const optional<T>& opt );
    		(26) (depuis C++17) 
    template< class T, class U >
constexpr bool operator<=( const optional<T>& opt, const U& value );
    		(27) (depuis C++17) 
    template< class U, class T >
constexpr bool operator<=( const U& value, const optional<T>& opt );
    		(28) (depuis C++17) 
    template< class T, class U >
constexpr bool operator>( const optional<T>& opt, const U& value );
    		(29) (depuis C++17) 
    template< class U, class T >
constexpr bool operator>( const U& value, const optional<T>& opt );
    		(30) (depuis C++17) 
    template< class T, class U >
constexpr bool operator>=( const optional<T>& opt, const U& value );
    		(31) (depuis C++17) 
    template< class U, class T >
constexpr bool operator>=( const U& value, const optional<T>& opt );
    		(32) (depuis C++17) 
    template< class T, std::three_way_comparable_with<T> U >
constexpr std::compare_three_way_result_t<T, U>
    operator<=>( const optional<T>& opt, const U& value );
    		(33) (depuis C++20)

    Effectue des opérations de comparaison sur les optional objets.

    1-7) Compare deux optional objets, lhs et rhs. Les valeurs contenues sont comparées (en utilisant l'opérateur correspondant de T) seulement si lhs et rhs contiennent tous deux des valeurs. Sinon,
    • lhs est considéré égal à rhs si, et seulement si, lhs et rhs ne contiennent pas tous deux de valeur.
    • lhs est considéré inférieur à rhs si, et seulement si, rhs contient une valeur et lhs n'en contient pas.
    1-6) Soit @ l'opérateur de comparaison correspondant, pour chacune de ces fonctions :

    Si l'expression correspondante *lhs @ *rhs est mal formée ou que son résultat n'est pas convertible en bool, le programme est mal formé.

    		(jusqu'à C++26)

    Cette surcharge participe à la résolution de surcharge seulement si l'expression correspondante *lhs @ *rhs est bien formée et que son résultat est convertible en bool.

    		(depuis C++26)
    8-20) Compare opt avec un nullopt. Équivalent à (1-6) lors de la comparaison avec un optional qui ne contient pas de valeur.

    Les opérateurs <, <=, >, >=, et != sont synthétisés à partir de operator<=> et operator== respectivement.

    		(depuis C++20)
    21-33) Compare opt avec une value. Les valeurs sont comparées (en utilisant l'opérateur correspondant de T) seulement si opt contient une valeur. Sinon, opt est considéré inférieur à value.
    21-32) Soit @ l'opérateur de comparaison correspondant, pour chacune de ces fonctions :

    Si l'expression correspondante *opt @ value ou value @ *opt (selon les positions des opérandes) est mal formée ou que son résultat n'est pas convertible en bool, le programme est mal formé.

    		(jusqu'à C++26)

    Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

    • U n'est pas une spécialisation de std::optional.
    • L'expression correspondante *opt @ value ou value @ *opt (selon les positions des opérandes) est bien formée et son résultat est convertible en bool.
    		 (depuis C++26)

    Paramètres

    lhs, rhs, opt - un objet optional à comparer
    value - valeur à comparer avec la valeur contenue

    Valeur de retour

    1) lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
    ( lhs. has_value ( ) == false ? true : * lhs == * rhs )
    2) lhs. has_value ( ) ! = rhs. has_value ( ) ? true :
    ( lhs. has_value ( ) == false ? false : * lhs ! = * rhs )
    3) ! rhs ? false : ( ! lhs ? true : * lhs < * rhs )
    4) ! lhs ? true : ( ! rhs ? false : * lhs <= * rhs )
    5) ! lhs ? false : ( ! rhs ? true : * lhs > * rhs )
    6) ! rhs ? true : ( ! lhs ? false : * lhs >= * rhs )
    7) lhs && rhs ? * lhs <=> * rhs : lhs. has_value ( ) <=> rhs. has_value ( )
    8,9) ! opt
    10,11) opt. has_value ( )
    12) false
    13) opt. has_value ( )
    14) ! opt
    15) true
    16) opt. has_value ( )
    17) false
    18) true
    19) ! opt
    20) opt. has_value ( ) <=> false
    21) opt. has_value ( ) ? * opt == value : false
    22) opt. has_value ( ) ? value == * opt : false
    23) opt. has_value ( ) ? * opt ! = value : true
    24) opt. has_value ( ) ? value ! = * opt : true
    25) opt. has_value ( ) ? * opt < value : true
    26) opt. has_value ( ) ? value < * opt : false
    27) opt. has_value ( ) ? * opt <= value : true
    **Note:** Aucune traduction n'a été effectuée car : - Le texte contenu dans les balises ` ` est du code C++ - Les termes C++ spécifiques (`opt`, `has_value`, `value`, `true`) ne doivent pas être traduits - La structure HTML et les attributs ont été préservés intacts Le contenu représente une expression ternaire C++ qui ne nécessite pas de traduction pour conserver sa signification technique.
    28) opt. has_value ( ) ? value <= * opt : false
    29) opt. has_value ( ) ? * opt > value : false
    30) opt. has_value ( ) ? value > * opt : true
    31) opt. has_value ( ) ? * opt >= value : false
    32) opt. has_value ( ) ? value >= * opt : true
    **Note:** Le code C++ n'a pas été traduit car il se trouve dans une balise ` ` qui équivaut à une balise ` ` pour le code C++. Seul le numéro "32)" a été conservé tel quel car il fait partie de la numérotation et ne nécessite pas de traduction.
    33) opt. has_value ( ) ? * opt <=> value : std :: strong_ordering :: less

    Exceptions

    1-7) Peut lever des exceptions définies par l'implémentation.
    21-33) Lance lorsque et ce que la comparaison lance.

    Notes

    Macro de test de fonctionnalité Valeur Std Fonctionnalité
    __cpp_lib_constrained_equality 202403L (C++26) opérateurs de comparaison contraints pour std::optional

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Applicable à Comportement publié Comportement corrigé
    LWG 2945 C++17 ordre des paramètres de template incohérent pour les cas de comparaison-avec-T rendu cohérent