# std::optional<T>::swap

> C++ Atlas: `cppatlas.com/w/cpp/utility/optional/swap` | Source: https://en.cppreference.com/w/cpp/utility/optional/swap | Domain: Utility | Standards: C++17, C++20

Swaps the contents with those of other.

## Official Specification Summary (cppreference)

```cpp
void swap( optional& other ) noexcept(/* see below */); // (since C++17) (constexpr 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)`.

The program is ill-formed unless type `T` is *Swappable* and `std::is_move_constructible_v<T>` is `true`.

### 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.

| Feature-test macro | Value | Std | Feature |
| --- | --- | --- | --- |
| `__cpp_lib_optional` | `202106L` | (C++20) (DR20) | Fully `constexpr` |

### Example

```cpp
#include <iostream>
#include <optional>
#include <string>

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:

```text
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)`](https://en.cppreference.com/w/cpp/utility/optional/swap2) (C++17): specializes the `std::swap` algorithm (function template)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/optional/swap (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.