<algorithm>
template <class T> void swap ( T& a, T& b );
Exchange values of two objects
Assigns the content of a to b and the content of b to a.
The behavior of this function template is equivalent to:
1
2
3
4
|
template <class T> void swap ( T& a, T& b )
{
T c(a); a=b; b=c;
}
|
Notice how this function involves a copy construction and two assignment operations, which may not be the most efficient way of swapping the contents of classes that store large quantities of data, since each of these operations generally operate in linear time on their size.
Because this function template is used as a primitive operation by many other algorithms, it is highly recommended that large data types overload their own specialization of this function. Notably, all STL containers define such specializations (at least for the standard allocator), in such a way that instead of swapping their entire data content, only the values of a few internal pointers are swapped, making this operation to operate in real constant time with them.
Parameters
- a, b
- Two objects, whose contents are swapped.
The type must be copy constructible and support assignment operations.
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 algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
int x=10, y=20; // x:10 y:20
swap(x,y); // x:20 y:10
vector<int> first (4,x), second (6,y); // first:4x20 second:6x10
swap(first,second); // first:6x10 second:4x20
cout << "first contains:";
for (vector<int>::iterator it=first.begin(); it!=first.end(); ++it)
cout << " " << *it;
cout << endl;
return 0;
}
|
Output:
first contains: 10 10 10 10 10 10
|
Complexity
Constant: Performs exactly one copy construction and two assignments (although notice that each of these operations works on its own complexity).
See also
| copy | Copy range of elements (function template) |
| fill | Fill range with value (function template) |
| replace | Replace value in range (function template) |
|