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

// 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