# std::optional<T>::swap

From cppreference.com
< cpp‎ | utility‎ | optional

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 operations can be constexpr in C++20 | made constexpr

### See also

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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/optional/swap&oldid=130453"