[try Beta version]
Not logged in
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

Reference

unordered_set