std::expected<T,E>::swap
| Основной шаблон |
||
constexpr void swap( expected& other ) noexcept(/* see below */);
|
(1) | (начиная с C++23) |
void частичная специализация |
||
constexpr void swap( expected& other ) noexcept(/* see below */);
|
(2) | (начиная с C++23) |
Обменивает содержимое с содержимым other.
Значениеhas_value()
|
Значение other.has_value()
| |
|---|---|---|
true
|
false
| |
true
|
using std::swap;swap(val, rhs.val);
|
см. ниже |
false
|
other.swap(*this);
|
using std::swap;swap(unex, rhs.unex);
|
has_value() является true, а other.has_value() является false, эквивалентно:
// Case 1: the move constructions of unexpected values are non-throwing:
// “other.unex” will be restored if the construction of “other.val” fails
if constexpr (std::is_nothrow_move_constructible_v<E>)
{
E temp(std::move(other.unex));
std::destroy_at(std::addressof(other.unex));
try
{
std::construct_at(std::addressof(other.val), std::move(val)); // may throw
std::destroy_at(std::addressof(val));
std::construct_at(std::addressof(unex), std::move(temp));
}
catch(...)
{
std::construct_at(std::addressof(other.unex), std::move(temp));
throw;
}
}
// Case 2: the move constructions of expected values are non-throwing:
// “this->val” will be restored if the construction of “this->unex” fails
else
{
T temp(std::move(val));
std::destroy_at(std::addressof(val));
try
{
std::construct_at(std::addressof(unex), std::move(other.unex)); // may throw
std::destroy_at(std::addressof(other.unex));
std::construct_at(std::addressof(other.val), std::move(temp));
}
catch(...)
{
std::construct_at(std::addressof(val), std::move(temp));
throw;
}
}
has_val = false;
rhs.has_val = true;
true:
std::is_swappable_v<T>std::is_swappable_v<E>std::is_move_constructible_v<T> && std::is_move_constructible_v<E>std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<E>
Значениеhas_value()
|
Значение other.has_value()
| |
|---|---|---|
true
|
false
| |
true
|
using std::swap;swap(val, rhs.val);
|
std::construct_at(std::addressof(unex), std::move(rhs.unex));std::destroy_at(std::addressof(rhs.unex));has_val = false;rhs.has_val = true;
|
false
|
other.swap(*this);
|
using std::swap;swap(unex, rhs.unex);
|
std::is_swappable_v<E> и std::is_move_constructible_v<E> оба являются true.Параметры
| other | - |
объект
expected
для обмена содержимым
|
Исключения
std::
is_nothrow_move_constructible_v
<
T
>
&&
std::
is_nothrow_swappable_v
<
T
>
&&
std::
is_nothrow_move_constructible_v
<
E
>
&&
std::
is_nothrow_swappable_v
<
E
>
std::
is_nothrow_move_constructible_v
<
E
>
&&
std::
is_nothrow_swappable_v
<
E
>
Пример
#include <expected> #include <iostream> #include <string_view> using Ex = std::expected<std::string, int>; void show(const Ex& ex1, const Ex& ex2, std::string_view term = "\n") { for (int i{}; i != 2; ++i) { std::cout << (i ? "ex2" : "ex1"); if (const Ex& ex = (i ? ex2 : ex1); ex.has_value()) std::cout << ".value() = " << *ex << " "; else std::cout << ".error() = " << ex.error() << " "; } std::cout << term; } int main() { Ex ex1("\N{CAT FACE}"); Ex ex2{"\N{GREEN HEART}"}; show(ex1, ex2, "after ex1.swap(ex2):\n"); ex1.swap(ex2); show(ex1, ex2, "\n\n"); ex2 = std::unexpected(13); show(ex1, ex2, "after ex1.swap(ex2):\n"); ex1.swap(ex2); show(ex1, ex2, "\n\n"); ex2 = std::unexpected(37); show(ex1, ex2, "after ex1.swap(ex2):\n"); ex1.swap(ex2); show(ex1, ex2); }
Вывод:
ex1.value() = 🐱 ex2.value() = 💚 after ex1.swap(ex2): ex1.value() = 💚 ex2.value() = 🐱 ex1.value() = 💚 ex2.error() = 13 after ex1.swap(ex2): ex1.error() = 13 ex2.value() = 💚 ex1.error() = 13 ex2.error() = 37 after ex1.swap(ex2): ex1.error() = 37 ex2.error() = 13
Смотрите также
|
(C++23)
|
специализирует алгоритм
std::swap
(функция) |