std::forward_list::swap

void swap (forward_list& fwdlst);

Swap content

Exchanges the content of the container by the content of fwdlst, which is another forward_list object of the same type. Sizes may differ.

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

Notice that a non-member function exists with the same name, swap, overloading that algorithm with an optimization that behaves like this member function.

Whether the container allocators are also swapped is not defined, unless in the case the appropriate allocator trait indicates explicitly that they shall propagate.

Parameters

fwdlst: Another forward_list container of the same type as this (i.e., with the same template parameters, T and Alloc) whose content is swapped with that of this container.

Return value

none

Example

// forward_list::swap
#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;

  first.swap(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 the container and fwdlst are modified.
No contained elements are accessed by the call (although see iterator validity above).

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.

member functions

non-member overloads