[try Beta version]
Not logged in
public member function
<unordered_map>

std::unordered_multimap::operator=

copy (1)
unordered_multimap& operator= ( const unordered_multimap& umm );
move (2)
unordered_multimap& operator= ( unordered_multimap&& umm );
initializer list (3)
unordered_multimap& operator= ( intitializer_list<value_type> il );
Assign content
Assigns umm (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_multimap umm or initializer list il, if any.

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

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

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

Parameters

umm
An unordered_multimap 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 contained in the unordered_multimap, which is pair<const key_type,mapped_type>, where member type key_type is an alias of the first template parameter (the key type), and mapped_type is an alias of the second template parameter (the mapped type, T).

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
25
26
// unordered_multimap::operator=
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

typedef std::unordered_multimap<std::string,std::string> stringmap;

stringmap merge (stringmap a,stringmap b) {
  stringmap temp(a); temp.insert(b.begin(),b.end()); return temp;
}

int main ()
{
  stringmap first, second, third;
  first = {{"apple","red"},{"lemon","yellow"}};     // init list
  second = {{"banana","yellow"},{"apple","green"}}; // init list
  third = merge(first,second);                      // move
  first = third;                                    // copy

  std::cout << "first contains:";
  for (auto& elem: first) std::cout << " " << elem.first << ":" << elem.second;
  std::cout << std::endl;

  return 0;
}


Possible output:
first contains: lemon:yellow apple:red apple:green banana:yellow

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_multimap