std::array::swap

void swap (array& x) noexcept(noexcept(swap(declval<value_type&>(),declval<value_type&>())));

Swap content

Exchanges the content of the array by the content of x, which is another array object of the same type (including the same size).

After the call to this member function, the elements in this container are those which were in x before the call, and the elements of x are those which were in

this.

Unlike with the

swap member functions of the other containers, this member function operates in linear time by performing as many individual swap operations between the individual elements as their size (see swap).

Parameters

x: Another array container of the same type (which includes same size) as this whose content is swapped with that of this container.

Return value

none.

This member function can throw an exception if one of the element-wise swap calls throws itself an exception.

Example

// swap arrays
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> first = {10, 20, 30, 40, 50};
  std::array<int,5> second = {11, 22, 33, 44, 55};

  first.swap (second);

  std::cout << "first:";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';

  std::cout << "second:";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

Output:

first: 11 22 33 44 55
second: 10 20 30 40 50

Complexity

Linear: Performs as many individual swap operations as the size of the arrays.

Iterator validity

The validity of all iterators, references and pointers is not changed: They remain associated with the same positions in the same container they were associated before the call, but the elements they still refer to have the swapped values.

Data races

Both the container and x are modified.
All elements in both containers are accessed by the call.

Exception safety

If the non-member specialization of swap for the type of the elements is non-throwing, the function never throws exceptions (no-throw guarantee).
Otherwise, the container is guaranteed to end in a valid state (basic guarantee).