NAME¶

std::tuple::swap - std::tuple::swap

Synopsis¶

Defined in header <tuple>
void swap( tuple& other ) noexcept(/* see below */); (since C++11)
(until C++20)
constexpr void swap( tuple& other ) noexcept(/* see below */); (1) (since C++20)
constexpr void swap( const tuple& other ) noexcept(/* see (2) (since C++23)
below */) const;

Calls swap (which might be std::swap, or might be found via ADL) for each element in
*this and its corresponding element in other.

If any selected swap function call is ill-formed, or does not swap the (until C++23)
corresponding elements of both tuples, the behavior is undefined.
If any selected swap function call does not swap the corresponding
elements of both tuples, the behavior is undefined.

1) The program is ill-formed if (std::is_swappable_v<Types> && ...) is (since C++23)
not true.
2) The program is ill-formed if (std::is_swappable_v<const Types> &&
...) is not true.

Parameters¶

other - tuple of values to swap

Return value¶

(none)

Exceptions¶

noexcept specification:
noexcept(

noexcept(swap(std::declval<T0&>>(), std::declval<T0&>())) &&
noexcept(swap(std::declval<T1&>>(), std::declval<T1&>())) &&
noexcept(swap(std::declval<T2&>>(), std::declval<T2&>())) && (until C++17)
...

)

In the expression above, the identifier swap is looked up in the same
manner as the one used by the C++17 std::is_nothrow_swappable trait.
1)
noexcept specification:
noexcept((std::is_nothrow_swappable_v<Types> && ...)) (since C++17)
2)
noexcept specification:
noexcept((std::is_nothrow_swappable_v<const Types> && ...))

Example¶

// Run this code

#include <iostream>
#include <string>
#include <tuple>

int main()
{
std::tuple<int, std::string, float>
p1{42, "ABCD", 2.71},
p2;
p2 = std::make_tuple(10, "1234", 3.14);

auto print_p1_p2 = [&](auto rem) {
std::cout << rem
<< "p1 = {" << std::get<0>(p1)
<< ", " << std::get<1>(p1)
<< ", " << std::get<2>(p1) << "}, "
<< "p2 = {" << std::get<0>(p2)
<< ", " << std::get<1>(p2)
<< ", " << std::get<2>(p2) << "}\n";
};

print_p1_p2("Before p1.swap(p2): ");
p1.swap(p2);
print_p1_p2("After p1.swap(p2): ");
swap(p1, p2);
print_p1_p2("After swap(p1, p2): ");
}

Output:¶

Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
After p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2456 C++11 the noexcept specification is ill-formed made to work

See also¶

std::swap(std::tuple) specializes the std::swap algorithm
(C++11) (function template)
swap swaps the contents
(C++11) (public member function of std::pair<T1,T2>)