Namespaces
Variants

operator== (std::expected)

From cppreference.net
C++
Utilities library
std::expected
Modèle 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 std::expected objets.

1) Compare deux objets std::expected . Les objets sont égaux si et seulement si lhs et rhs contiennent tous deux des valeurs attendues qui sont égales, ou contiennent tous deux 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 seulement 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 l'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 seulement 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 si 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 ordinaire, et ne peuvent être trouvées que par la recherche dépendante des arguments lorsque std::expected<T, E> est une classe associée des arguments.

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

Table des matières

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)