function template
<forward_list>

std::swap (forward_list)

template <class T, class Alloc>
  void swap (forward_list<T,Alloc>& x, forward_list<T,Alloc>& y);
Exchanges the contents of two forward_list containers
The contents of container x are exchanged with those of y. Both container objects must be of the same type (same template parameters), although sizes may differ.

After the call to this member function, the elements in x are those which were in y before the call, and the elements of y are those which were in x. All iterators, references and pointers remain valid for the swapped objects.

This is an overload of the generic algorithm swap that improves its performance by mutually transferring ownership over their assets to the other container (i.e., the containers exchange references to their data, without actually performing any element copy or movement): It behaves as if x.swap(y) was called.

Parameters

lhs,rhs
forward_list containersof the same type (i.e., having both the same template parameters, T and Alloc).

Return value

none

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
// swap (forward_list overload)
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> first = {10, 20, 30};
  std::forward_list<int> second = {100, 200};
  std::forward_list<int>::iterator it;

  swap(first,second);

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

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

  return 0;
}


Output:
first contains: 100 200
second contains: 10 20 30

Complexity

Constant.

Iterator validity

All iterators, pointers and references referring to elements in both containers remain valid, but now are referring to elements in the other container, and iterate in it.
Note that the end iterators (including before_begin) do not refer to elements and may be invalidated.

Data races

Both containers, x and y, are modified.

Exception safety

If the allocators in both containers compare equal, or if their allocator traits indicate that the allocators shall propagate, the function never throws exceptions (no-throw guarantee).
Otherwise, it causes undefined behavior.

See also

forward_list::swap
Swap content (public member function )
swap
Exchange values of two objects (function template )
swap_ranges
Exchange values of two ranges (function template )

C++