std::unexpected — cppreference.com

Материал из cppreference.com

Определено в заголовочном файле `<expected>`
`template< class E > class unexpected;`		(начиная с C++23)

Шаблонный класс std::unexpected представляет неожидаемое значение, хранящееся в std::expected. В частности, std::expected имеет конструкторы с std::unexpected в качестве единственного аргумента, которые создают объект expected, содержащий неожидаемое значение.

Программа некорректна, если она создаёт экземпляр unexpected с необъектным типом, типом массива, специализацией std::unexpected или с cv-квалифицированным типом.

Параметры шаблона

E — тип неожидаемого значения. Тип не должен быть типом массива, необъектным типом, специализацией std::unexpected или cv-квалифицированным типом.

Функции-элементы

	создаёт объект `unexpected` (public функция-элемент)
(деструктор) (объявлено неявно) (C++23)	уничтожает объект `unexpected` вместе с сохранённым значением (public функция-элемент)
operator= (объявлено неявно) (C++23)	присваивает сохранённое значение (public функция-элемент)
	обращается к сохранённому значению (public функция-элемент)
	обменивает сохранённые значения (public функция-элемент)

Функции, не являющиеся элементами

	сравнивает сохранённые значения (шаблон функции)
	специализирует алгоритм std::swap (шаблон функции)

std::unexpected::unexpected

`constexpr unexpected( const unexpected& ) = default;`	(1)	(начиная с C++23)
`constexpr unexpected( unexpected&& ) = default;`	(2)	(начиная с C++23)
`template< class Err = E > constexpr explicit unexpected( Err&& e );`	(3)	(начиная с C++23)
`template< class... Args > constexpr explicit unexpected( std::in_place_t, Args&&... args );`	(4)	(начиная с C++23)
`template< class U, class... Args > constexpr explicit unexpected( std::in_place_t, std::initializer_list<U> il, Args&&... args );`	(5)	(начиная с C++23)

Создаёт объект std::unexpected.

1,2) Конструктор копирования/перемещения. Копирует или перемещает сохранённое значение.

3) Создаёт сохранённое значение, как если бы путём прямой инициализации значения типа E из std::forward<Err>(e).

Эта перегрузка участвует в разрешении перегрузки, только если
- std::is_same_v<std::remove_cvref_t<Err>, unexpected> равно false, и
- std::is_same_v<std::remove_cvref_t<Err>, std::in_place_t> равно false, и
- std::is_constructible_v<E, Err> равно true.

4) Создаёт сохранённое значение, как будто путём прямой инициализации значения типа E из аргументов std::forward<Args>(args)....

Эта перегрузка участвует в разрешении перегрузки, только если std::is_constructible_v<E, Args...> равно true.

5) Создаёт сохранённое значение, как будто путём прямой инициализации значения типа E из аргументов il, std::forward<Args>(args)....

Эта перегрузка участвует в разрешении перегрузки, только если std::is_constructible_v<E, std::initializer_list<U>&, Args...> равно true.

Параметры

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;`		(начиная с C++23)

Возвращает ссылку на сохранённое значение.

std::unexpected::swap

`constexpr void swap( unexpected& other ) noexcept(std::is_nothrow_swappable_v<E>);`		(начиная с C++23)

Меняет местами сохранённые значения, как если бы using std::swap; swap(error(), other.error());.

Программа некорректна, если std::is_swappable_v<E> равно false.

operator==(std::unexpected)

`template< class E2 > friend constexpr bool operator==( unexpected& x, std::unexpected<E2>& y );`		(начиная с C++23)

Сравнивает сохранённые значения, как если бы return x.error() == y.error().

Если выражение x.error() == e.error() некорректно или если его результат не может быть преобразован в bool, программа некорректна.

Эта функция не видна обычному неквалифицированному или квалифицированному поиску и может быть найдена только с помощью зависящего от аргумента поиска, когда std::unexpected<E> является ассоциированным классом аргументом.

swap(std::unexpected)

`friend constexpr void swap( unexpected& x, unexpected& y ) noexcept(noexcept(x.swap(y)));`		(начиная с C++23)

Эквивалент x.swap(y).

Эта перегрузка участвует в разрешении перегрузки, только если std::is_swappable_v<E> равно true.

Правила вывода

`template< class E > unexpected(E) -> unexpected<E>;`		(начиная с C++23)

Правила вывода предоставляются для unexpected, чтобы разрешить вывод из аргумента конструктора.

Примечание

До C++17 имя std::unexpected обозначало функцию, вызываемую средой выполнения C++ при нарушении спецификации динамического исключения.

Пример

#include <expected>
#include <iostream>

int main() {
    std::expected<double, int> ex = std::unexpected(3);

    if (!ex) {
        std::cout << "ex содержит значение ошибки\n";
    }

    if (ex == std::unexpected(3)) {
        std::cout << "Значение ошибки равно 3\n";
    }
}

Вывод:

ex содержит значение ошибки
Значение ошибки равно 3

Пример с enum

#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()
{
    const auto e = unexpected_runtime_error();

    e.and_then([](const auto& e) -> std::expected<int, error> {
         std::cout << "and_then: " << int(e); // не печатает
         return {};
     }).or_else([](const auto& e) -> std::expected<int, error> {
        std::cout << "or_else: " << int(e); // печатает эту строку
        return {};
    });

    return 0;
}

Вывод:

Смотрите также

Категории: