NAME¶

std::optional::swap - std::optional::swap

Synopsis¶

void swap( optional& other ) noexcept(/* see below */); (since C++17)
(until C++20)
constexpr void swap( optional& other ) noexcept(/* see below */); (since C++20)

Swaps the contents with those of other.

* If neither *this nor other contain a value, the function has no effect.

* If only one of *this and other contains a value (let's call this object in and
the other un), the contained value of un is direct-initialized from
std::move(*in), followed by destruction of the contained value of in as if by
in->T::~T(). After this call, in does not contain a value; un contains a value.

* If both *this and other contain values, the contained values are exchanged by
calling using std::swap; swap(**this, *other). T lvalues must satisfy Swappable.

The program is ill-formed if std::is_move_constructible_v<T> is false.

Parameters¶

other - the optional object to exchange the contents with

Return value¶

(none)

Exceptions¶

noexcept specification:
noexcept(std::is_nothrow_move_constructible_v<T> &&
std::is_nothrow_swappable_v<T>)

In the case of thrown exception, the states of the contained values of *this and
other are determined by the exception safety guarantees of swap of type T or T's
move constructor, whichever is called. For both *this and other, if the object
contained a value, it is left containing a value, and the other way round.

Example¶

// Run this code

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

int main()
{
std::optional<std::string> opt1("First example text");
std::optional<std::string> opt2("2nd text");

enum Swap { Before, After };
auto print_opts = [&](Swap e) {
std::cout << (e == Before ? "Before swap:\n" : "After swap:\n");
std::cout << "opt1 contains '" << opt1.value_or("") << "'\n";
std::cout << "opt2 contains '" << opt2.value_or("") << "'\n";
std::cout << (e == Before ? "---SWAP---\n": "\n");
};

print_opts(Before);
opt1.swap(opt2);
print_opts(After);

// Swap with only 1 set
opt1 = "Lorem ipsum dolor sit amet, consectetur tincidunt.";
opt2.reset();

print_opts(Before);
opt1.swap(opt2);
print_opts(After);
}

Output:¶

Before swap:
opt1 contains 'First example text'
opt2 contains '2nd text'
---SWAP---
After swap:
opt1 contains '2nd text'
opt2 contains 'First example text'

Before swap:
opt1 contains 'Lorem ipsum dolor sit amet, consectetur tincidunt.'
opt2 contains ''
---SWAP---
After swap:
opt1 contains ''
opt2 contains 'Lorem ipsum dolor sit amet, consectetur tincidunt.'

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¶

std::swap(std::optional) specializes the std::swap algorithm
(C++17) (function template)