swap
The assignment-related operators, listed in Table 9.4 (overleaf) act on the entire container. The assignment operator replaces the entire range of elements in the left-hand container with copies of the elements from the right-hand operand:
c1 = c2; // replace the contents of c1 with a copy of the elements in c2
c1 = {a,b,c}; // after the assignment c1 has size 3
After the first assignment, the left- and right-hand containers are equal. If the containers had been of unequal size, after the assignment both containers would have the size of the right-hand operand. After the second assignment, the size
of c1
is 3, which is the number of values provided in the braced list.
Unlike built-in arrays, the library array
type does allow assignment. The left-and right-hand operands must have the same type:
array<int, 10> a1 = {0,1,2,3,4,5,6,7,8,9};
array<int, 10> a2 = {0}; // elements all have value 0
a1 = a2; // replaces elements in a1
a2 = {0}; // error: cannot assign to an array from a braced list
Because the size of the right-hand operand might differ from the size of the left-hand operand, the array
type does not support assign
and it does not allow assignment from a braced list of values.
assign
(Sequential Containers Only)The assignment operator requires that the left-hand and right-hand operands have the same type. It copies all the elements from the right-hand operand into the left-hand operand. The sequential containers (except array
) also define a member named assign
that lets us assign from a different but compatible type, or assign from a subsequence of a container. The assign
operation replaces all the elements in the left-hand container with (copies of) the elements specified by its arguments. For example, we can use assign
to assign a range of char*
values from a vector
into a list
of string
:
list<string> names;
vector<const char*> oldstyle;
names = oldstyle; // error: container types don't match
// ok: can convert from const char*to string
names.assign(oldstyle.cbegin(), oldstyle.cend());
The call to assign
replaces the elements in names
with copies of the elements in the range denoted by the iterators. The arguments to assign
determine how many elements and what values the container will have.
Because the existing elements are replaced, the iterators passed to assign
must not refer to the container on which assign
is called.
A second version of assign
takes an integral value and an element value. It replaces the elements in the container with the specified number of elements, each of which has the specified element value:
// equivalent to slist1.clear();
// followed by slist1.insert(slist1.begin(), 10, "Hiya!");
list<string> slist1(1); // one element, which is the empty string
slist1.assign(10, "Hiya!"); // ten elements; each one is Hiya !
swap
The swap
operation exchanges the contents of two containers of the same type. After the call to swap
, the elements in the two containers are interchanged:
vector<string> svec1(10); // vector with ten elements
vector<string> svec2(24); // vector with 24 elements
swap(svec1, svec2);
After the swap, svec1
contains 24 string
elements and svec2
contains ten. With the exception of array
s, swapping two containers is guaranteed to be fast—the elements themselves are not swapped; internal data structures are swapped.
Excepting array, swap
does not copy, delete, or insert any elements and is guaranteed to run in constant time.
The fact that elements are not moved means that, with the exception of string
, iterators, references, and pointers into the containers are not invalidated. They refer to the same elements as they did before the swap. However, after the swap
, those elements are in a different container. For example, had iter
denoted the string
at position svec1 [3]
before the swap
, it will denote the element at position svec2[3]
after the swap
. Differently from the containers, a call to swap
on a string
may invalidate iterators, references and pointers.
Unlike how swap
behaves for the other containers, swapping two array
s does exchange the elements. As a result, swapping two array
s requires time proportional to the number of elements in the array
.
After the swap
, pointers, references, and iterators remain bound to the same element they denoted before the swap
. Of course, the value of that element has been swapped with the corresponding element in the other array
.
In the new library, the containers offer both a member and nonmember version of swap
. Earlier versions of the library defined only the member version of swap
. The nonmember swap
is of most importance in generic programs. As a matter of habit, it is best to use the nonmember version of swap
.