home | help 
std::forward_list::swap(3)     C++ Standard Libary    std::forward_list::swap(3)

NAME
     std::forward_list::swap - std::forward_list::swap

Synopsis
	void  swap(  forward_list&  other  );				  (since
     C++11)
								     (until
     C++17)
	void swap( forward_list& other )  noexcept(/*  see  below  */);   (since
     C++17)

	Exchanges  the	contents  of the container with those of other. Does not
     invoke any
	move, copy, or swap operations on individual elements.

	All iterators and references remain valid. It is unspecified whether  an
     iterator
	holding  the  end()  value  in	this container will refer to this or the
     other container
	after the operation.

	If		std::allocator_traits<allocator_type>::propagate_on_con-
     tainer_swap::value
	is  true, then the allocators are exchanged using an unqualified call to
     (since
	non-member swap. Otherwise, they are not swapped (and if get_allocator()
     !=   C++11)
	other.get_allocator(), the behavior is undefined).

Parameters
	other - container to exchange the contents with

Return value
	(none)

Exceptions
	(none)								    (un-
     til C++17)
	noexcept						  specification:
     (since C++17)
	noexcept(std::allocator_traits<Allocator>::is_always_equal::value)

Complexity
	Constant.

Example
     // Run this code

      #include <iostream>
      #include <forward_list>

      template<class Os, class Co>
      Os& operator<<(Os& os, const Co& co)
      {
	  os << '{';
	  for (auto const& i : co)
	      os << ' ' << i;
	  return os << " } ";
      }

      int main()
      {
	  std::forward_list<int> a1{1, 2, 3}, a2{4, 5};

	  auto it1 = std::next(a1.begin());
	  auto it2 = std::next(a2.begin());

	  int& ref1 = a1.front();
	  int& ref2 = a2.front();

	  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 the iterators and references	stay  associated
     with their
	  // original elements, e.g. it1 that pointed to an element in 'a1' with
     value 2
	  //  still  points  to  the same element, though this element was moved
     into 'a2'.
      }

Output:
      { 1 2 3 } { 4 5 } 2 5 1 4
      { 4 5 } { 1 2 3 } 2 5 1 4

See also
	std::swap(std::forward_list) specializes the std::swap algorithm
	(C++11) 		     (function template)

Category:
	  * conditionally noexcept

http://cppreference.com 	   2024.06.10	      std::forward_list::swap(3)
home | help