Namespaces
Variants

    operator==(std::expected)

    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'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
    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'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::expected
     
    Gabarit principal
    		 
    template< class T2, class E2 >
    requires (!std::is_void_v<T2>)
friend constexpr bool operator==( const expected& lhs,
                                  const std::expected<T2, E2>& rhs );
    		(1) (depuis C++23) 
    template< class E2 >
friend constexpr bool operator==( const expected& lhs,
                                  const std::unexpected<E2>& unex );
    		(2) (depuis C++23) 
    template< class T2 >
friend constexpr bool operator==( const expected& lhs, const T2& val );
    		(3) (depuis C++23)
    void spécialisation partielle
    		 
    template< class T2, class E2 >
  requires std::is_void_v<T2>
friend constexpr bool operator==( const expected& lhs,
                                  const std::expected<T2, E2>& rhs );
    		(4) (depuis C++23) 
    template< class E2 >
friend constexpr bool operator==( const expected& lhs,
                                  const std::unexpected<E2>& unex );
    		(5) (depuis C++23)

    Effectue des opérations de comparaison sur des objets std::expected.

    1) Compare deux objets std::expected. Les objets sont égaux si et seulement si les deux lhs et rhs contiennent des valeurs attendues qui sont égales, ou les deux contiennent des valeurs inattendues qui sont égales.

    Si l'une des expressions suivantes est mal formée, ou si 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 uniquement si toutes les expressions suivantes sont bien formées et que leurs résultats sont convertibles en bool :

    		(depuis C++26)
    • *lhs == *rhs
    • lhs.error() == rhs.error()
    2) Compare un objet std::expected avec un objet std::unexpected. Les objets sont égaux si et seulement si lhs contient une valeur inattendue qui est égale à unex.error().

    Si l'expression lhs.error() == unex.error() est mal formée, ou si 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 uniquement si l'expression lhs.error() == unex.error() est bien formée et que son résultat est convertible en bool.

    		(depuis C++26)
    3) Compare un objet std::expected avec une valeur attendue. Les objets sont égaux si et seulement si lhs contient une valeur attendue qui est égale à val.

    Si l'expression *lhs == val est mal formée, ou si 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 uniquement si toutes les conditions suivantes sont satisfaites :

    • T2 n'est pas une spécialisation de std::expected.
    • L'expression *lhs == val est bien formée et son résultat est convertible en bool.
    		 (depuis C++26)
    4) Compare deux objets std::expected. Les objets sont égaux si et seulement si lhs et rhs représentent tous deux des valeurs attendues, ou contiennent tous deux des valeurs inattendues qui sont égales.

    Si l'expression lhs.error() == rhs.error() est mal formée, ou si 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 uniquement si l'expression lhs.error() == rhs.error() est bien formée et que son résultat est convertible en bool.

    		(depuis C++26)
    5) Compare un objet std::expected avec un objet std::unexpected. Les objets sont égaux si et seulement si lhs contient une valeur inattendue qui est égale à unex.error().

    Si l'expression lhs.error() == unex.error() est mal formée, ou si 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 uniquement si l'expression lhs.error() == unex.error() est bien formée et que son résultat est convertible en bool.

    		(depuis C++26)

    Ces fonctions ne sont pas visibles par la recherche non qualifiée ou qualifiée ordinaires, et ne peuvent être trouvées que par la recherche dépendante des arguments lorsque std::expected<T, E> est une classe associée aux arguments.

    L'opérateur != est synthétisé à partir de operator==.

    Paramètres

    lhs, rhs - std::expected objet(s) à comparer
    unex - std::unexpected valeur à comparer avec lhs
    val - valeur à comparer avec la valeur attendue contenue dans lhs

    Valeur de retour

    1)
    lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
    ( lhs. has_value ( ) ? * lhs == * rhs : lhs. error ( ) == rhs. error ( ) )
    **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises spécifiques et contient des termes techniques C++ qui doivent rester en anglais. Seul le texte numéroté "1)" a été conservé tel quel, car il s'agit d'un simple numéro qui ne nécessite pas de traduction.
    2) ! lhs. has_value ( ) && static_cast < bool > ( lhs. error ( ) == unex. error ( ) )
    3) lhs. has_value ( ) && static_cast < bool > ( * lhs == val )

    4)
    lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
    lhs. has_value ( ) || static_cast < bool > ( lhs. error ( ) == rhs. error ( ) )
    5) ! lhs. has_value ( ) && static_cast < bool > ( lhs. error ( ) == unex. error ( ) )

    Exceptions

    Lance lorsque et ce que la comparaison lance.

    Notes

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

    Exemple

    Exécuter ce code 
    #include <expected>
#include <iostream>
#include <string_view>
using namespace std::string_view_literals;
int main()
{
    auto x1{"\N{GREEN HEART}"sv};
    auto x2{"\N{CROSS MARK}"sv};
    std::expected<std::string_view, int> e1{x1}, e2{x1}, e3{x2};
    std::unexpected u1{13};
    std::cout << "Overload (1):\n"
              << e1.value() << (e1 == e2 ? " == " : " != ") << *e2 << '\n'
              << e1.value() << (e1 != e3 ? " != " : " == ") << *e3 << "\n\n";
    std::cout << "Overload (2):\n"
              << e1.value() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{13};
    std::cout << e1.error() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{31};
    std::cout << e1.error() << (e1 != u1 ? " != " : " == ") << u1.error() << '\n';
    std::cout << "Overload (3):\n"
              << *e1 << (e1 == x1 ? " == " : " != ") << x1 << '\n'
              << *e1 << (e1 != x2 ? " != " : " == ") << x2 << "\n\n";
}

    Sortie : 

    Overload (1):
💚 == 💚
💚 != ❌
Overload (2):
💚 != 13
13 == 13
31 != 13
Overload (3):
💚 == 💚
💚 != ❌

    Voir aussi

    (C++23)
    		compare std::unexpected les objets
    (modèle de fonction)