std::array<T,N>::swap

void swap( array& other ) noexcept(/* see below */);		(since C++11) (until C++20)
constexpr void swap( array& other ) noexcept(/* see below */);		(since C++20)

Exchanges the contents of the container with those of other. Does not cause iterators and references to associate with the other container.

Parameters

other

-

container to exchange the contents with

Return value

(none)

Exceptions

`noexcept` specification: noexcept(noexcept(swap(std::declval<T&>(), std::declval<T&>()))) 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)
`noexcept` specification: noexcept(std::is_nothrow_swappable_v<T>)	(since C++17)

For zero-sized arrays,

noexcept specification:

noexcept

Complexity

Linear in size of the container.

Example

Run this code

#include <array>
#include <iostream>
 
template<class Os, class V> Os& operator<<(Os& os, const V& v) {
    os << "{";
    for (auto i : v) os << ' ' << i;
    return os << " } ";
}
 
int main()
{
    std::array<int, 3> a1{1, 2, 3}, a2{4, 5, 6};
 
    auto it1 = a1.begin();
    auto it2 = a2.begin();
    int& ref1 = a1[1];
    int& ref2 = a2[1];
 
    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
    a1.swap(a2);
    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
 
    // Note that after swap iterators and references stay associated with their original
    // array, e.g. `it1` still points to element a1[0], `ref1` still refers to a1[1].
}

Output:

{ 1 2 3 } { 4 5 6 } 1 4 2 5
{ 4 5 6 } { 1 2 3 } 4 1 5 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
LWG 2456	C++11	the `noexcept` specification is ill-formed	made to work

Compiler support
Freestanding and hosted
Language
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Sequence
array (C++11)
vector
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
Views
span (C++20)

Member functions
Element access
array::at
array::operator[]
array::front
array::back
array::data
Iterators
array::beginarray::cbegin
array::endarray::cend
array::rbeginarray::crbegin
array::rendarray::crend
Capacity
array::empty
array::size
array::max_size
Modifiers
array::fill
array::swap
Non-member functions
get
std::swap
to_array (C++20)
operator==operator!=operator<operator>operator<=operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
Helper classes
tuple_size
tuple_element
Deduction guides(C++17)