public member function
<unordered_set>

std::unordered_set::operator=

copy (1)
unordered_set& operator= ( const unordered_set& ust );
move (2)
unordered_set& operator= ( unordered_set&& ust );
initializer list (3)
unordered_set& operator= ( intitializer_list<value_type> il );
Assign content
Assigns ust (or il) as the new content for the container.

The elements contained in the object before the call are destroyed, and replaced by those in unordered_set ust or initializer list il, if any.

The first version (1) performs a copy assignment, which copies all the elements of ust into the container object (with ust preserving its contents).

The second version (2) performs a move assignment, which transfer ownership of the contents of ust to the object. No copies occur: the content is lost by ust.

The third version (3) assigns the contents of the initializer list il as the elements of the container object.

Parameters

ust
An unordered_set object of the same type (i.e., with the same template parameters).
il
An initializer_list object. The compiler will automatically construct such objects from initializer list declarators.
Member type value_type is the type of the elements in the container, defined in unordered_set as an alias of its first template parameter (Key).

Return value

*this

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
// unordered_set::operator=
#include <iostream>
#include <string>
#include <unordered_set>

template<class T>
T cmerge (T a, T b) {
  T t(a); t.insert(b.begin(),b.end()); return t;
}

int main ()
{
  std::unordered_set<std::string> first, second, third;
  first = {"red","green","blue"};      // init list
  second = {"orange","pink","yellow"}; // init list
  third = cmerge (first, second);      // move
  first = third;                       // copy

  std::cout << "first contains:";
  for (const std::string& x: first) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

Possible output:
first contains: orange blue red pink yellow green


Complexity

For the copy assignment (1): Linear in sizes (destructions, copies).
For the move assignment (2): Linear in current container size (destructions).*
For the initializer list assignment (3): On average, linear in sizes (destructions, move-assignments) -- worst case: quadratic.
* Additional complexity for assignments if allocators do not propagate.

Iterator validity

All iterators, references and pointers to elements that were in the container before the call are invalidated.

See also