NAME¶

std::swap(std::optional) - std::swap(std::optional)

Synopsis¶

Defined in header <optional>
template< class T >
(since C++17)
void swap( std::optional<T>& lhs, (until C++20)

std::optional<T>& rhs ) noexcept(/* see below */);
template< class T >

constexpr void swap( std::optional<T>& lhs, (since C++20)

std::optional<T>& rhs ) noexcept(/* see below */);

Overloads the std::swap algorithm for std::optional. Exchanges the state of lhs with
that of rhs. Effectively calls lhs.swap(rhs).

This overload participates in overload resolution only if
std::is_move_constructible_v<T> and std::is_swappable_v<T> are both true.

Parameters¶

lhs, rhs - optional objects whose states to swap

Return value¶

(none)

Exceptions¶

noexcept specification:
noexcept(noexcept(lhs.swap(rhs)))

Example¶

// Run this code

#include <iostream>
#include <optional>
#include <string>

int main()
{
std::optional<std::string> a{"██████"}, b{"▒▒▒▒▒▒"};

auto print = [&](auto const& s) {
std::cout
<< s << "\t"
<< "a = " << a.value_or("(null)") << " "
<< "b = " << b.value_or("(null)") << '\n';
};

print("Initially:");
std::swap(a, b);
print("swap(a, b):");
a.reset();
print("\n""a.reset():");
std::swap(a, b);
print("swap(a, b):");
}

Output:¶

Initially: a = ██████ b = ▒▒▒▒▒▒
swap(a, b): a = ▒▒▒▒▒▒ b = ██████

a.reset(): a = (null) b = ██████
swap(a, b): a = ██████ b = (null)

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
P2231R1 C++20 swap was not constexpr while the required made constexpr
operations can be constexpr in C++20

See also¶

swap exchanges the contents
(public member function)