22 General utilities library [utilities]

22.8 Expected objects [expected]

22.8.3 Class template unexpected [expected.unexpected]

22.8.3.1 General [expected.un.general]

1
#
Subclause [expected.unexpected] describes the class template unexpected that represents unexpected objects stored in expected objects.
🔗
namespace std { template<class E> class unexpected { public: // [expected.un.cons], constructors 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(see below); 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; // exposition only }; template<class E> unexpected(E) -> unexpected<E>; }
2
#
A program that instantiates the definition of unexpected for a non-object type, an array type, a specialization of unexpected, or a cv-qualified type is ill-formed.

22.8.3.2 Constructors [expected.un.cons]

🔗
template<class Err = E> constexpr explicit unexpected(Err&& e);
1
#
Constraints:
  • (1.1)
    is_same_v<remove_cvref_t<Err>, unexpected> is false; and
  • (1.2)
    is_same_v<remove_cvref_t<Err>, in_place_t> is false; and
  • (1.3)
    is_constructible_v<E, Err> is true.
2
#
Effects: Direct-non-list-initializes unex with std​::​forward<Err>(e).
3
#
Throws: Any exception thrown by the initialization of unex.
🔗
template<class... Args> constexpr explicit unexpected(in_place_t, Args&&... args);
4
#
Constraints: is_constructible_v<E, Args...> is true.
5
#
Effects: Direct-non-list-initializes unex with std​::​forward<Args>(args)....
6
#
Throws: Any exception thrown by the initialization of unex.
🔗
template<class U, class... Args> constexpr explicit unexpected(in_place_t, initializer_list<U> il, Args&&... args);
7
#
Constraints: is_constructible_v<E, initializer_list<U>&, Args...> is true.
8
#
Effects: Direct-non-list-initializes unex with il, std​::​forward<Args>(args)....
9
#
Throws: Any exception thrown by the initialization of unex.

22.8.3.3 Observers [expected.un.obs]

🔗
constexpr const E& error() const & noexcept; constexpr E& error() & noexcept;
1
#
Returns: unex.
🔗
constexpr E&& error() && noexcept; constexpr const E&& error() const && noexcept;
2
#
Returns: std​::​move(unex).

22.8.3.4 Swap [expected.un.swap]

🔗
constexpr void swap(unexpected& other) noexcept(is_nothrow_swappable_v<E>);
1
#
Mandates: is_swappable_v<E> is true.
2
#
Effects: Equivalent to: using std​::​swap; swap(unex, other.unex);
🔗
friend constexpr void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y)));
3
#
Constraints: is_swappable_v<E> is true.
4
#
Effects: Equivalent to x.swap(y).

22.8.3.5 Equality operator [expected.un.eq]

🔗
template<class E2> friend constexpr bool operator==(const unexpected& x, const unexpected<E2>& y);
1
#
Mandates: The expression x.error() == y.error() is well-formed and its result is convertible to bool.
2
#
Returns: x.error() == y.error().