Namespaces
Variants
Actions

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

From cppreference.com
< cpp‎ | utility‎ | variant
 
 
Utilities library
Type support (basic types, RTTI)
(C++20)
(C++20)
(C++20)(C++20)(C++20)  
(C++20)(C++20)(C++20)

General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)  
(C++20)
Swap and type operations
(C++20)
(C++14)
(C++11)
(C++11)
(C++23)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)


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

[edit] Parameters

rhs - a variant object to swap with

[edit] Return value

(none)

[edit] 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>) && ...))

[edit] Notes

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

[edit] 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

[edit] 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

[edit] See also

specializes the std::swap algorithm
(function template) [edit]

AltStyle によって変換されたページ (->オリジナル) /