cppreference.com

Namespaces

Variants

Actions

std::tuple<Types...>::swap

From cppreference.com

< cpp‎ | utility‎ | tuple

Compiler support

Freestanding and hosted

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

External libraries

Utilities library

Language support

Type support (basic types, RTTI)

Library feature-test macros (C++20)

Program utilities

Variadic functions

initializer_list

(C++11)

is_constant_evaluated

(C++20)

is_within_lifetime

(C++26)

source_location

(C++20)

Coroutine support (C++20)

Contract support (C++26)

Three-way comparison

three_way_comparablethree_way_comparable_with

(C++20)(C++20)

strong_ordering

(C++20)

(C++20)

partial_ordering

(C++20)

common_comparison_category

(C++20)

compare_three_way_result

(C++20)

compare_three_way

(C++20)

(C++20)

(C++20)

(C++20)

compare_strong_order_fallback

(C++20)

compare_weak_order_fallback

(C++20)

compare_partial_order_fallback

(C++20)

is_eqis_ltis_lteq

(C++20)(C++20)(C++20)

is_neqis_gtis_gteq

(C++20)(C++20)(C++20)

General utilities

Function objects

Bit manipulation (C++20)

C-style bit manipulation (C++26)

(C++11)

Relational operators (deprecated in C++20)

rel_ops::operator!=rel_ops::operator>

rel_ops::operator<=rel_ops::operator>=

Integer comparison functions

cmp_equalcmp_lesscmp_less_than

(C++20)(C++20)(C++20)

cmp_not_equalcmp_greatercmp_greater_than

(C++20)(C++20)(C++20)

(C++20)

Swap and type operations

(C++20)

(C++14)

(C++11)

(C++23)

(C++11)

(C++23)

(C++11)

move_if_noexcept

(C++11)

(C++17)

Common vocabulary types

(C++11)

(C++17)

(C++17)

(C++17)

(C++11)

(C++11)

(C++17)

make_from_tuple

(C++17)

(C++23)

Member functions

tuple::operator=

tuple::swap

Non-member functions

forward_as_tuple

operator==operator!=operator<operator<=operator>operator>=operator<=>

(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)

swap(std::tuple)

get(std::tuple)

Helper concepts

(C++23)

tuple_size<std::tuple>

tuple_element<std::tuple>

uses_allocator<std::tuple>

basic_common_reference<std::tuple>

(C++23)

common_type<std::tuple>

(C++23)

formatter<std::tuple>

(C++23)

Deduction guides (C++17)

Defined in header <tuple>

void swap( tuple& other ) noexcept(/* see below */);

(1) (since C++11)
(constexpr since C++20)

constexpr void swap( const tuple& other ) noexcept(/* see below */) const;

(2) (since C++23)

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 corresponding elements of both tuples, the behavior is undefined.

(until C++23)

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

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

(since C++23)

Contents

[edit] Parameters

other - tuple of values to swap

[edit] Return value

(none)

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

)

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.

(until C++17)

1)

noexcept specification:

noexcept((std::is_nothrow_swappable_v <Types> && ...))

2)

noexcept specification:

noexcept((std::is_nothrow_swappable_v <const Types> && ...))

(since C++17)

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

[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
LWG 2456	C++11	the `noexcept` specification is ill-formed	made to work

[edit] See also

std::swap(std::tuple)

(C++11)

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

(C++11)

swaps the contents
(public member function of std::pair<T1,T2>) [edit]

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

conditionally noexcept