std::unexpected

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

ユーティリティライブラリ

言語サポート 型のサポート (基本型、RTTI) ライブラリ機能検査マクロ (C++20) プログラムユーティリティ 可変引数関数 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) コルーチンサポート (C++20) 契約サポート (C++26) 三方比較 three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

汎用ユーティリティ 関数オブジェクト ビット操作 (C++20) bitset hash (C++11) 関係演算子 (C++20で非推奨) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= 整数比較関数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) スワップと型操作 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 共通語彙型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::expected

メンバ関数

expected::expected

expected::~expected

expected::operator=

監視

expected::operator->expected::operator*

expected::operator boolexpected::has_value

expected::value

expected::error

expected::value_or

expected::error_or

モナド操作

expected::and_then

expected::or_else

expected::transform

expected::transform_error

変更

expected::emplace

expected::swap

非メンバ関数

operator==(std::expected)

swap(std::expected)

ヘルパークラス

unexpected

bad_expected_access

unexpect_tunexpect

 

ヘッダ <expected> で定義
template< class E > class unexpected;		(C++23から)

クラステンプレートstd::unexpectedは、std::expectedに格納される予期しない値を表します。特に、std::expectedには、std::unexpectedを単一の引数とするコンストラクタがあり、これにより予期しない値を含むexpectedオブジェクトが作成されます。

オブジェクト型でない型、配列型、std::unexpectedの特殊化、またはcv修飾された型でunexpectedをインスタンス化すると、プログラムはill-formed（不正な形式）となります。

テンプレートパラメータ

E

-

予期しない値の型。この型は、配列型、オブジェクト型でない型、std::unexpectedの特殊化、またはcv修飾された型であってはなりません。

メンバ関数

(コンストラクタ)	unexpectedオブジェクトを構築します。 (public member function)
(デストラクタ) (暗黙的に宣言)	格納された値と共にunexpectedオブジェクトを破棄します。 (public member function)
operator= (暗黙的に宣言)	格納された値を代入します。 (public member function)
error	格納された値にアクセスします。 (public member function)
swap	格納された値を交換します。 (public member function)

非メンバ関数

operator== (C++23)	格納された値を比較します。 (関数テンプレート)
swap(std::unexpected) (C++23)	std::swap アルゴリズムを特殊化する (関数テンプレート)

std::unexpected::unexpected

constexpr unexpected( const unexpected& ) = default;	(1)
constexpr unexpected( unexpected&& ) = default;	(2)
template< class Err = E > constexpr explicit unexpected( Err&& e );	(3)
template< class... Args > constexpr explicit unexpected( std::in_place_t, Args&&... args );	(4)
template< class U, class... Args > constexpr explicit unexpected( std::in_place_t,                                std::initializer_list<U> il, Args&&... args );	(5)

std::unexpectedオブジェクトを構築します。

1,2) コピー/ムーブコンストラクタ。それぞれ格納された値をコピーまたはムーブします。

3) 格納された値を構築します。これは、直接初期化によって型Eの値をstd::forward<Err>(e)から初期化するのと似ています。

• このオーバーロードは、以下の場合にのみオーバーロード解決に参加します。
  • std::is_same_v<std::remove_cvref_t<Err>, unexpected> が偽であり、
  • std::is_same_v<std::remove_cvref_t<Err>, std::in_place_t> が偽であり、
  • std::is_constructible_v<E, Err> が真である。

4) 格納された値を構築します。これは、直接初期化によって型Eの値を引数std::forward<Args>(args)...から初期化するのと似ています。

• このオーバーロードは、std::is_constructible_v<E, Args...>が真である場合にのみオーバーロード解決に参加します。

5) 格納された値を構築します。これは、直接初期化によって型Eの値を引数il, std::forward<Args>(args)...から初期化するのと似ています。

• このオーバーロードは、std::is_constructible_v<E, std::initializer_list<U>&, Args...>が真である場合にのみオーバーロード解決に参加します。

パラメータ

e	-	含まれる値を初期化するための値
args...	-	含まれる値を初期化するための引数
il	-	含まれる値を初期化するための初期化子リスト

例外

Eのコンストラクタが例外をスローした場合、その例外をスローします。

std::unexpected::error

constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept;

格納された値への参照を返します。

std::unexpected::swap

constexpr void swap( unexpected& other ) noexcept(std::is_nothrow_swappable_v<E>);

格納された値を交換します。これは、using std::swap; swap(error(), other.error());のように呼び出すのと似ています。

std::is_swappable_v<E>が偽の場合、プログラムはill-formed（不正な形式）となります。

operator==(std::unexpected)

template< class E2 > friend constexpr bool operator==( unexpected& x, std::unexpected<E2>& y );

格納された値を比較します。これは、return x.error() == y.error();のように呼び出すのと似ています。

式x.error() == y.error()がwell-formedでない場合、またはその結果がboolに変換できない場合、プログラムはill-formed（不正な形式）となります。

この関数は、通常の非修飾または修飾ルックアップからは見えず、std::unexpected<E>が引数の関連クラスである場合にのみ引数依存ルックアップで見つけることができます。

swap(std::unexpected)

friend constexpr void swap( unexpected& x, unexpected& y ) noexcept(noexcept(x.swap(y)));

x.swap(y)と同等です。

このオーバーロードは、std::is_swappable_v<E>が真である場合にのみオーバーロード解決に参加します。

この関数は、通常の非修飾または修飾ルックアップからは見えず、std::unexpected<E>が引数の関連クラスである場合にのみ引数依存ルックアップで見つけることができます。

推論ガイド

template< class E > unexpected(E) -> unexpected<E>;		(C++23から)

unexpectedのための推論ガイドが提供されており、コンストラクタ引数からの推論を可能にします。

備考

C++17より前は、名前std::unexpectedは、動的例外指定が違反されたときにC++ランタイムによって呼び出される関数を指していました。

例

このコードを実行

#include <expected>
#include <iostream>
 
enum class error
{
    compile_time_error,
    runtime_error
};
 
[[nodiscard]] auto unexpected_runtime_error() -> std::expected<int, error>
{
    return std::unexpected(error::runtime_error);
}
 
int main()
{
    std::expected<double, int> ex = std::unexpected(3);
 
    if (!ex)
        std::cout << "ex contains an error value\n";
 
    if (ex == std::unexpected(3))
        std::cout << "The error value is equal to 3\n";
 
    const auto e = unexpected_runtime_error();
 
    e.and_then([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "and_then: " << int(e); // not printed
        return {};
    })
    .or_else([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "or_else: " << int(e); // prints this line
        return {};
    });
}

出力

ex contains an error value
The error value is equal to 3
or_else: 1

関連項目

(コンストラクタ)	expected オブジェクトを構築する (public member function)
operator== (C++23)	expectedオブジェクトを比較します。 (関数テンプレート)