function template
<set>
std::swap (multiset)
template <class T, class Compare, class Alloc> void swap (multiset<T,Compare,Alloc>& x, multiset<T,Compare,Alloc>& y);
Exchanges the contents of two multisets
The contents of container x are exchanged with those of y. Both container objects must be of the same type (same template parameters), although sizes may differ.
After the call to this member function, the elements in x are those which were in y before the call, and the elements of y are those which were in x. All iterators, references and pointers remain valid for the swapped objects.
This is an overload of the generic algorithm swap that improves its performance by mutually transferring ownership over their assets to the other container (i.e., the containers exchange references to their data, without actually performing any element copy or movement): It behaves as if x.swap(y) was called.
Parameters
- x,y
- multiset containers of the same type (i.e., having both the same template parameters, T, Compare and Alloc).
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
// swap (multiset overload)
#include <iostream>
#include <set>
main ()
{
int myints[]={12,75,12,35,20,35};
std::multiset<int> first (myints,myints+3); // 12,12,75
std::multiset<int> second (myints+3,myints+6); // 20,35,35
swap(first,second);
std::cout << "first contains:";
for (std::multiset<int>::iterator it=first.begin(); it!=first.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
std::cout << "second contains:";
for (std::multiset<int>::iterator it=second.begin(); it!=second.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
|
Output:
first contains: 20 35 35
second contains: 12 12 75
|
Iterator validity
All iterators, pointers and references referring to elements in both containers remain valid, and are now referring to the same elements they referred to before the call, but in the other container, where they now iterate.
Note that the end iterators do not refer to elements and may be invalidated.
Data races
Both containers, x and y, are modified.
No contained elements are accessed by the call (although see iterator validity above).
Exception safety
If the allocators in both multisets 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.
See also
- vector::swap
- Swap content (public member function)
- swap
- Exchange values of two objects (function template)
- swap_ranges
- Exchange values of two ranges (function template)