Namespaces
Variants

operator== (std::expected)

From cppreference.net
C++
Utilities library
std::expected
プライマリテンプレート
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) (C++23以降)
template < class E2 >

friend constexpr bool operator == ( const expected & lhs,

const std:: unexpected < E2 > & unex ) ;
(2) (C++23以降)
template < class T2 >
friend constexpr bool operator == ( const expected & lhs, const T2 & val ) ;
(3) (C++23以降)
void 部分特殊化
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) (C++23以降)
template < class E2 >

friend constexpr bool operator == ( const expected & lhs,

const std:: unexpected < E2 > & unex ) ;
(5) (C++23以降)

std::expected オブジェクトに対する比較操作を実行します。

1) 2つの std::expected オブジェクトを比較する。両方の lhs と rhs が等しい期待値を含む場合、または両方が等しい非期待値を含む場合にのみ、オブジェクトは等しいと比較される。

以下の式のいずれかが不適格であるか、その結果が bool に変換できない場合、プログラムは不適格となる：

(C++26まで)

このオーバーロードは、以下のすべての式が適格であり、その結果が bool に変換可能な場合にのみ、オーバーロード解決に参加する：

(C++26以降)
  • * lhs == * rhs
  • lhs. error ( ) == rhs. error ( )
2) std::expected オブジェクトと std::unexpected オブジェクトを比較する。両オブジェクトが等しいと評価されるのは、 lhs が unex. error ( ) と等しい予期せぬ値を持つ場合のみである。

式 lhs. error ( ) == unex. error ( ) が不適格な形式であるか、その結果が bool に変換できない場合、プログラムは不適格となる。

(C++26まで)

このオーバーロードは、式 lhs. error ( ) == unex. error ( ) が適格な形式であり、その結果が bool に変換可能な場合にのみ、オーバーロード解決に参加する。

(C++26以降)
3) std::expected オブジェクトと期待値を比較します。オブジェクトは、 lhs が期待値を持ち、かつその値が val と等しい場合にのみ等しくなります。

式 * lhs == val が不適格な形式である場合、またはその結果が bool に変換できない場合、プログラムは不適格となります。

(C++26まで)

このオーバーロードは、以下の条件がすべて満たされる場合にのみオーバーロード解決に参加します:

  • T2 が std::expected の特殊化ではないこと。
  • 式 * lhs == val が適格な形式であり、その結果が bool に変換可能であること。
(C++26以降)
4) 2つの std::expected オブジェクトを比較する。両オブジェクトは、 lhs と rhs の両方が期待値を表す場合、または両方が等しい非期待値を含む場合にのみ等しいと比較される。

式 lhs. error ( ) == rhs. error ( ) が不適格であるか、その結果が bool に変換できない場合、プログラムは不適格となる。

(C++26まで)

このオーバーロードは、式 lhs. error ( ) == rhs. error ( ) が適格であり、その結果が bool に変換可能な場合にのみ、オーバーロード解決に参加する。

(C++26以降)
5) std::expected オブジェクトと std::unexpected オブジェクトを比較する。両オブジェクトが等しいと評価されるのは、 lhs が予期しない値を持ち、かつその値が unex. error ( ) と等しい場合のみである。

式 lhs. error ( ) == unex. error ( ) が不適格であるか、その結果が bool に変換できない場合、プログラムは不適格となる。

(C++26以前)

このオーバーロードは、式 lhs. error ( ) == unex. error ( ) が適格であり、かつその結果が bool に変換可能な場合にのみ、オーバーロード解決に参加する。

(C++26以降)

これらの関数は通常の unqualified lookup または qualified lookup では可視化されず、引数に関連付けられたクラスとして std::expected<T, E> が指定されている場合にのみ argument-dependent lookup によって発見されます。

!= 演算子は synthesized され、 operator== から生成されます。

目次

パラメータ

lhs, rhs - std::expected 比較対象のオブジェクト
unex - std::unexpected lhs と比較する値
val - lhs に含まれる期待値と比較する値

戻り値

1)
lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
( lhs. has_value ( ) ? * lhs == * rhs : lhs. error ( ) == rhs. error ( ) )
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 ( ) )

例外

比較がスローするタイミングと内容をスローします。

注記

機能テスト マクロ 値 標準 機能
__cpp_lib_constrained_equality 202411L (C++26) std::expected の制約付き比較演算子

例

このコードを実行 
#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";
}

出力: 

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

関連項目

(C++23)
std::unexpected オブジェクトを比較する
(関数テンプレート)