Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/algorithm/swap"

From cppreference.com
< cpp‎ | algorithm
m (Text replace - "par req concept" to "par req named")
(P0551R3, LWG2139)
Line 42: Line 42:
  
 
===Exceptions===
 
===Exceptions===
−
@1@ {{rev begin}}
+
@1@ {{rrev multi|until1=c++11
−
{{rev|until=c++11|(none)}}
+
|rev1=(none)
−
{{rev|since=c++11|
+
|rev2=
 
{{noexcept|
 
{{noexcept|
 
     std::is_nothrow_move_constructible<T>::value &&
 
     std::is_nothrow_move_constructible<T>::value &&
 
     std::is_nothrow_move_assignable<T>::value
 
     std::is_nothrow_move_assignable<T>::value
 
}}
 
}}
−
}}{{rev end}}
+
}}
−
@2@ {{rev begin}}
+
@2@ {{rrev multi|until1=c++17|rev1=
−
{{rev|until=c++17|{{noexcept|noexcept(swap(*a, *b))}} <!-- LWG 2554 -->The lookup for the identifier {{tt|swap}} in the exception specification finds this function template in addition to anything found by the usual lookup rules, making the exception specification equivalent to C++17 {{lc|std::is_nothrow_swappable}}.}}
+
{{noexcept|noexcept(swap(*a, *b))}} <!-- LWG 2554 -->The lookup for the identifier {{tt|swap}} in the exception specification finds this function template in addition to anything found by the usual lookup rules, making the exception specification equivalent to C++17 {{lc|std::is_nothrow_swappable}}.
−
{{rev|since=c++17|{{noexcept|std::is_nothrow_swappable_v<T2>}}}}
+
|rev2={{noexcept|std::is_nothrow_swappable_v<T2>}}
−
{{rev end}}
+
}}
  
 
===Complexity===
 
===Complexity===
Line 61: Line 61:
  
 
===Specializations===
 
===Specializations===
−
 
+
{{rrev|until=c++20|
−
{{lc|std::swap}} may be [[cpp/language/extending_std|specialized in namespace std]] for user-defined types, but such specializations are not found by [[cpp/language/adl|ADL]] (the namespace std is not the associated namespace for the user-defined type). The expected way to make a user-defined type swappable is to provide a non-member function swap in the same namespace as the type: see {{named req|Swappable}} for details.  
+
{{tt|std::swap}} may be [[cpp/language/extending_std|specialized in namespace std]] for program-defined types, but such specializations are not found by [[cpp/language/adl|ADL]] (the namespace std is not the associated namespace for the program-defined type).
 +
}}
 +
The expected way to make a program-defined type swappable is to provide a non-member function swap in the same namespace as the type: see {{named req|Swappable}} for details.  
  
 
The following overloads are already provided by the standard library:
 
The following overloads are already provided by the standard library:
Line 147: Line 149:
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/algorithm/swap]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/algorithm/swap]]
+
−
[[fr:cpp/algorithm/swap]]
+
−
[[it:cpp/algorithm/swap]]
+
−
[[ja:cpp/algorithm/swap]]
+
−
[[pt:cpp/algorithm/swap]]
+
−
[[ru:cpp/algorithm/swap]]
+
−
[[zh:cpp/algorithm/swap]]
+

Revision as of 23:54, 25 June 2018

 
C++
 
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
(C++11)                (C++11)(C++11)

Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
swap
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17)(C++11)
(C++20)(C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
 
Defined in header <algorithm>
Defined in header <utility>
(until C++11)
(since C++11)
(1)
template< class T >
void swap( T& a, T& b );
 (until C++11)
template< class T >
void swap( T& a, T& b ) noexcept(/* see below */);
 (since C++11)
(until C++20)
template< class T >
constexpr void swap( T& a, T& b ) noexcept(/* see below */);
 (since C++20)
(2)
template< class T2, std::size_t N >
void swap( T2 (&a)[N], T2 (&b)[N]) noexcept(/* see below */);
 (since C++11)
(until C++20)
template< class T2, std::size_t N >
constexpr void swap( T2 (&a)[N], T2 (&b)[N]) noexcept(/* see below */);
 (since C++20)

Exchanges the given values.

1) Swaps the values a and b. This overload does not participate in overload resolution unless std::is_move_constructible_v<T> && std::is_move_assignable_v<T> is true.(since C++17)
2) Swaps the arrays a and b. In effect calls std::swap_ranges(a, a+N, b). This overload does not participate in overload resolution unless std::is_swappable_v<T2> is true.(since C++17)

Contents

Parameters

a, b - the values to be swapped
Type requirements
-
T must meet the requirements of MoveAssignable and MoveConstructible.
-
T2 must meet the requirements of Swappable.

Return value

(none)

Exceptions

1)

(none)

(until C++11)
noexcept specification:  
noexcept(

    std::is_nothrow_move_constructible<T>::value &&
    std::is_nothrow_move_assignable<T>::value

)
 (since C++11)
2)
noexcept specification:  
noexcept(noexcept(swap(*a, *b)))
The lookup for the identifier swap in the exception specification finds this function template in addition to anything found by the usual lookup rules, making the exception specification equivalent to C++17 std::is_nothrow_swappable. 		(until C++17)
noexcept specification:  
noexcept(std::is_nothrow_swappable_v<T2>)
 (since C++17)

Complexity

1) Constant
2) Linear in N

Specializations

std::swap may be specialized in namespace std for program-defined types, but such specializations are not found by ADL (the namespace std is not the associated namespace for the program-defined type).

(until C++20)

The expected way to make a program-defined type swappable is to provide a non-member function swap in the same namespace as the type: see Swappable for details.

The following overloads are already provided by the standard library:

(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++20)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
({{{1}}})
 specializes the std::swap algorithm
(function) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++11)
 specializes the std::swap algorithm
(function template) [edit]
(C++17)
 specializes the std::swap algorithm
(function template) [edit]
(C++17)
 specializes the std::swap algorithm
(function) [edit]
(C++17)
 specializes the std::swap algorithm
(function template) [edit]
(C++17)
 specializes the std::swap algorithm
(function) [edit]

Example

Run this code
#include <algorithm>
#include <iostream>
 
int main()
{
   int a = 5, b = 3;
 
   // before
   std::cout << a << ' ' << b << '\n';
 
   std::swap(a,b);
 
   // after
   std::cout << a << ' ' << b << '\n';
}

Output: 

5 3
3 5

Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 2554 C++11 swapping multi-dimensional arrays can never be noexcept due to name lookup problems made to work

See also

 swaps the elements pointed to by two iterators
(function template) [edit]
swaps two ranges of elements
(function template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/swap&oldid=104452"