Standard library header <expected> (C++23)
From cppreference.net
このヘッダは 汎用ユーティリティ ライブラリの一部です。
クラス |
||
|
(C++23)
|
期待される値またはエラー値のいずれかを含むラッパー
(クラステンプレート) |
|
|
(C++23)
|
予期しない値として表現される
(クラステンプレート) |
|
|
(C++23)
|
予期しない値を含む
expected
へのチェック付きアクセスを示す例外
(クラステンプレート) |
|
|
(C++23)
|
expected
内の予期しない値に対するインプレース構築タグ
(タグ) |
|
概要
// 主にフリースタンディング namespace std { // クラステンプレート unexpected template<class E> class unexpected; // クラステンプレート bad_expected_access template<class E> class bad_expected_access; // void の特殊化 template<> class bad_expected_access<void>; // unexpected 値のインプレース構築 struct unexpect_t { explicit unexpect_t() = default; }; inline constexpr unexpect_t unexpect{}; // クラステンプレート expected template<class T, class E> class expected; // 部分的にフリースタンディング // void 型に対する expected の部分特殊化 template<class T, class E> requires is_void_v<T> class expected<T, E>; // 部分的にフリースタンディング }
クラステンプレート std::unexpected
namespace std { template<class E> class unexpected { public: // コンストラクタ constexpr unexpected(const unexpected&) = default; constexpr unexpected(unexpected&&) = default; template<class Err = E> constexpr explicit unexpected(Err&&); template<class... Args> constexpr explicit unexpected(in_place_t, Args&&...); template<class U, class... Args> constexpr explicit unexpected(in_place_t, initializer_list<U>, Args&&...); constexpr unexpected& operator=(const unexpected&) = default; constexpr unexpected& operator=(unexpected&&) = default; constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept; constexpr void swap(unexpected& other) noexcept(/* 説明を参照 */); template<class E2> friend constexpr bool operator==(const unexpected&, const unexpected<E2>&); friend constexpr void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y))); private: E /*unex*/; // 説明専用 }; template<class E> unexpected(E) -> unexpected<E>; }
クラステンプレート std::bad_expected_access
namespace std { template<class E> class bad_expected_access : public bad_expected_access<void> { public: constexpr explicit bad_expected_access(E); constexpr const char* what() const noexcept override; constexpr E& error() & noexcept; constexpr const E& error() const& noexcept; constexpr E&& error() && noexcept; constexpr const E&& error() const&& noexcept; private: E /*unex*/; // 説明専用 }; }
クラステンプレート特殊化 std::bad_expected_access<void>
namespace std { template<> class bad_expected_access<void> : public exception { protected: constexpr bad_expected_access() noexcept; constexpr bad_expected_access(const bad_expected_access&) noexcept; constexpr bad_expected_access(bad_expected_access&&) noexcept; constexpr bad_expected_access& operator=(const bad_expected_access&) noexcept; constexpr bad_expected_access& operator=(bad_expected_access&&) noexcept; constexpr ~bad_expected_access(); public: constexpr const char* what() const noexcept override; }; }
クラステンプレート std::expected
namespace std { template<class T, class E> class expected { public: using value_type = T; using error_type = E; using unexpected_type = unexpected<E>; template<class U> using rebind = expected<U, error_type>; // コンストラクタ constexpr expected(); constexpr expected(const expected&); constexpr expected(expected&&) noexcept(/* 説明を参照 */); template<class U, class G> constexpr explicit(/* 説明を参照 */) expected(const expected<U, G>&); template<class U, class G> constexpr explicit(/* 説明を参照 */) expected(expected<U, G>&&); template<class U = remove_cv_t<T>> constexpr explicit(/* 説明を参照 */) expected(U&& v); template<class G> constexpr explicit(/* 説明を参照 */) expected(const unexpected<G>&); template<class G> constexpr explicit(/* 説明を参照 */) expected(unexpected<G>&&); template<class... Args> constexpr explicit expected(in_place_t, Args&&...); template<class U, class... Args> constexpr explicit expected(in_place_t, initializer_list<U>, Args&&...); template<class... Args> constexpr explicit expected(unexpect_t, Args&&...); template<class U, class... Args> constexpr explicit expected(unexpect_t, initializer_list<U>, Args&&...); // デストラクタ constexpr ~expected(); // assignment constexpr expected& operator=(const expected&); constexpr expected& operator=(expected&&) noexcept(/* 説明を参照 */); template<class U = remove_cv_t<T>> constexpr expected& operator=(U&&); template<class G> constexpr expected& operator=(const unexpected<G>&); template<class G> constexpr expected& operator=(unexpected<G>&&); template<class... Args> constexpr T& emplace(Args&&...) noexcept; template<class U, class... Args> constexpr T& emplace(initializer_list<U>, Args&&...) noexcept; // swap constexpr void swap(expected&) noexcept(/* 説明を参照 */); friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y))); // オブザーバー constexpr const T* operator->() const noexcept; constexpr T* operator->() noexcept; constexpr const T& operator*() const& noexcept; constexpr T& operator*() & noexcept; constexpr const T&& operator*() const&& noexcept; constexpr T&& operator*() && noexcept; constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr const T& value() const&; // freestanding-deleted constexpr T& value() &; // freestanding-deleted constexpr const T&& value() const&&; // freestanding-deleted constexpr T&& value() &&; // freestanding-deleted constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept; template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const&; template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&; template<class G = E> constexpr E error_or(G&&) const&; template<class G = E> constexpr E error_or(G&&) &&; // モナド演算 template<class F> constexpr auto and_then(F&& f) &; template<class F> constexpr auto and_then(F&& f) &&; template<class F> constexpr auto and_then(F&& f) const&; template<class F> constexpr auto and_then(F&& f) const&&; template<class F> constexpr auto or_else(F&& f) &; template<class F> constexpr auto or_else(F&& f) &&; template<class F> constexpr auto or_else(F&& f) const&; template<class F> constexpr auto or_else(F&& f) const&&; template<class F> constexpr auto transform(F&& f) &; template<class F> constexpr auto transform(F&& f) &&; template<class F> constexpr auto transform(F&& f) const&; template<class F> constexpr auto transform(F&& f) const&&; template<class F> constexpr auto transform_error(F&& f) &; template<class F> constexpr auto transform_error(F&& f) &&; template<class F> constexpr auto transform_error(F&& f) const&; template<class F> constexpr auto transform_error(F&& f) const&&; // 等価演算子 template<class T2, class E2> requires(!is_void_v<T2>) friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y); template<class T2> friend constexpr bool operator==(const expected&, const T2&); template<class E2> friend constexpr bool operator==(const expected&, const unexpected<E2>&); private: bool /*has-val*/; // 説明専用 union { T /*val*/; // 説明専用 E /*未実装*/; // 説明専用 }; }; }
void型に対する std::expected の部分特殊化
template<class T, class E> requires is_void_v<T> class expected<T, E> { public: using value_type = T; using error_type = E; using unexpected_type = unexpected<E>; template<class U> using rebind = expected<U, error_type>; // コンストラクタ constexpr expected() noexcept; constexpr expected(const expected&); constexpr expected(expected&&) noexcept(/* 説明を参照 */); template<class U, class G> constexpr explicit(/* 説明を参照 */) expected(const expected<U, G>&); template<class U, class G> constexpr explicit(/* 説明を参照 */) expected(expected<U, G>&&); template<class G> constexpr explicit(/* 説明を参照 */) expected(const unexpected<G>&); template<class G> constexpr explicit(/* 説明を参照 */) expected(unexpected<G>&&); constexpr explicit expected(in_place_t) noexcept; template<class... Args> constexpr explicit expected(unexpect_t, Args&&...); template<class U, class... Args> constexpr explicit expected(unexpect_t, initializer_list<U>, Args&&...); // デストラクタ constexpr ~expected(); // assignment constexpr expected& operator=(const expected&); constexpr expected& operator=(expected&&) noexcept(/* 説明を参照 */); template<class G> constexpr expected& operator=(const unexpected<G>&); template<class G> constexpr expected& operator=(unexpected<G>&&); constexpr void emplace() noexcept; // swap constexpr void swap(expected&) noexcept(/* 説明を参照 */); friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y))); // オブザーバー constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr void operator*() const noexcept; constexpr void value() const&; // freestanding-deleted constexpr void value() &&; // freestanding-deleted constexpr const E& error() const& noexcept; constexpr E& error() & noexcept; constexpr const E&& error() const&& noexcept; constexpr E&& error() && noexcept; template<class G = E> constexpr E error_or(G&&) const&; template<class G = E> constexpr E error_or(G&&) &&; // モナド演算 template<class F> constexpr auto and_then(F&& f) &; template<class F> constexpr auto and_then(F&& f) &&; template<class F> constexpr auto and_then(F&& f) const&; template<class F> constexpr auto and_then(F&& f) const&&; template<class F> constexpr auto or_else(F&& f) &; template<class F> constexpr auto or_else(F&& f) &&; template<class F> constexpr auto or_else(F&& f) const&; template<class F> constexpr auto or_else(F&& f) const&&; template<class F> constexpr auto transform(F&& f) &; template<class F> constexpr auto transform(F&& f) &&; template<class F> constexpr auto transform(F&& f) const&; template<class F> constexpr auto transform(F&& f) const&&; template<class F> constexpr auto transform_error(F&& f) &; template<class F> constexpr auto transform_error(F&& f) &&; template<class F> constexpr auto transform_error(F&& f) const&; template<class F> constexpr auto transform_error(F&& f) const&&; // 等価演算子 template<class T2, class E2> requires is_void_v<T2> friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y); template<class E2> friend constexpr bool operator==(const expected&, const unexpected<E2>&); private: bool /*has-val*/; // 説明専用 union { E /*未使用*/; // 説明専用 }; };