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

NAME
     std::tuple::swap - std::tuple::swap

Synopsis
	Defined in header <tuple>
	void  swap(  tuple&  other  )  noexcept(/* see below */);     (1) (since
     C++11)
								     (constexpr
     since C++20)
	constexpr void swap( const tuple&  other  )  noexcept(/*     (2)  (since
     C++23)
	see below */) const;

	Calls  swap  (which  might  be std::swap, or might be found via ADL) for
     each element in
	*this and its corresponding element in other.

	If any selected swap function call is ill-formed, or does not  swap  the
     (until C++23)
	corresponding elements of both tuples, the behavior is undefined.
	If any selected swap function call does not swap the corresponding
	elements of both tuples, the behavior is undefined.

	1)  The  program is ill-formed if (std::is_swappable_v<Types> && ...) is
     (since C++23)
	not true.
	2) The program is ill-formed if (std::is_swappable_v<const Types> &&
	...) is not true.

Parameters
	other - tuple of values to swap

Return value
	(none)

Exceptions
	noexcept specification:
	noexcept(

	    noexcept(swap(std::declval<T0&>>(), std::declval<T0&>())) &&
	    noexcept(swap(std::declval<T1&>>(), std::declval<T1&>())) &&
	    noexcept(swap(std::declval<T2&>>(),     std::declval<T2&>()))     &&
     (until C++17)
	    ...

	)

	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.
	1)
	noexcept specification:
	noexcept((std::is_nothrow_swappable_v<Types>	       &&	   ...))
     (since C++17)
	2)
	noexcept specification:
	noexcept((std::is_nothrow_swappable_v<const Types> && ...))

Example
     // Run this code

      #include <iostream>
      #include <string>
      #include <tuple>

      int main()
      {
	  std::tuple<int, std::string, float> p1{42, "ABCD", 2.71}, p2;
	  p2 = std::make_tuple(10, "1234", 3.14);

	  auto print_p1_p2 = [&](auto rem)
	  {
	      std::cout << rem
			<< "p1 = {" << std::get<0>(p1)
			<< ", "     << std::get<1>(p1)
			<< ", "     << std::get<2>(p1) << "}, "
			<< "p2 = {" << std::get<0>(p2)
			<< ", "     << std::get<1>(p2)
			<< ", "     << std::get<2>(p2) << "}\n";
	  };

	  print_p1_p2("Before p1.swap(p2): ");
	  p1.swap(p2);
	  print_p1_p2("After  p1.swap(p2): ");
	  swap(p1, p2);
	  print_p1_p2("After swap(p1, p2): ");
      }

Output:
      Before p1.swap(p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}
      After  p1.swap(p2): p1 = {10, 1234, 3.14}, p2 = {42, ABCD, 2.71}
      After swap(p1, p2): p1 = {42, ABCD, 2.71}, p2 = {10, 1234, 3.14}

	Defect reports

	The following behavior-changing defect	reports  were  applied	retroac-
     tively to
	previously published C++ standards.

	   DR	 Applied to	     Behavior as published	     Correct be-
     havior
	LWG  2456  C++11       the  noexcept specification is ill-formed made to
     work

See also
	std::swap(std::tuple) specializes the std::swap algorithm
	(C++11) 	      (function template)
	swap		      swaps the contents
	(C++11) 	      (public member function of std::pair<T1,T2>)

Category:
	  * conditionally noexcept

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