# std::variant<Types...>::swap

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

void swap( variant& rhs ) noexcept(/* see below */); |  | (since C++17) (constexpr since C++20)

Swaps two `variant` objects.

- If both *this and rhs are valueless by exception, does nothing.
- Otherwise, if both *this and rhs hold the same alternative, calls swap(* std::get_if <i>(this), * std::get_if <i>( std::addressof (rhs))) where i is `index()`. If an exception is thrown, the state of the values depends on the exception safety of the `swap` function called.
- Otherwise, exchanges values of rhs and *this. If an exception is thrown, the state of *this and rhs depends on exception safety of variant's move constructor.

The program is ill-formed unless type `T_i` are Swappable and std::is_move_constructible_v <T_i> is true for all `T_i` in `Types...`.

### Parameters

rhs | - | a `variant` object to swap with

### Return value

(none)

### Exceptions

If this->index() == rhs.index(), may throw any exception thrown by swap(* std::get_if <i>(this), * std::get_if <i>( std::addressof (rhs))) with i being `index()`.

Otherwise, may throw any exception thrown by the move constructors of the alternatives currently held by *this and rhs.

`noexcept` specification:
noexcept((( std::is_nothrow_move_constructible_v <Types> &&
std::is_nothrow_swappable_v <Types>) && ...))

### Notes

Feature-test macro | Value | Std | Feature
--- | --- | --- | ---
`__cpp_lib_variant` | `202106L` | (C++20) (DR) | Fully constexpr `std::variant`

### Example

Run this code

    #include <iostream>
    #include <string>
    #include <variant>

    int main()
    {
        std::variant<int, std::string> v1{2}, v2{"abc"};
        std::visit([](auto&& x) { std::cout << x << ' '; }, v1);
        std::visit([](auto&& x) { std::cout << x << '\n'; }, v2);
        v1.swap(v2);
        std::visit([](auto&& x) { std::cout << x << ' '; }, v1);
        std::visit([](auto&& x) { std::cout << x << '\n'; }, v2);
    }

Output:

    2 abc
    abc 2

### 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 non-trivial destructors can be constexpr in C++20 | made constexpr

### See also

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

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