Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::unordered_map::merge(3)  C++ Standard Libary std::unordered_map::merge(3)

NAME
       std::unordered_map::merge - std::unordered_map::merge

Synopsis
	  template<class H2, class P2>
	  void	merge(	std::unordered_map<Key,	 T, H2,	P2, Allocator>&	source
       (1) (since C++17)
	  );
	  template<class H2, class P2>
	  void merge( std::unordered_map<Key, T, H2, P2,  Allocator>&&	source
       (2) (since C++17)
	  );
	  template<class H2, class P2>
	  void	merge(	std::unordered_multimap<Key,  T,  H2,  P2, Allocator>&
       (3) (since C++17)
	  source );
	  template<class H2, class P2>
	  void merge( std::unordered_multimap<Key,  T,	H2,  P2,  Allocator>&&
       (4) (since C++17)
	  source );

	  Attempts  to extract ("splice") each element in source and insert it
       into *this using
	  the hash function and	key equality predicate of *this. If  there  is
       an element in
	  *this	with key equivalent to the key of an element from source, then
       that element is
	  not extracted	from source. No	elements are copied or moved, only the
       internal
	  pointers of the container nodes are repointed. All pointers and ref-
       erences to the
	  transferred  elements	 remain	 valid,	 but now refer into *this, not
       into source.
	  Iterators referring to the transferred elements  and	all  iterators
       referring to *this
	  are  invalidated.  Iterators	to elements remaining in source	remain
       valid.

	  The behavior is undefined if get_allocator()	!=  source.get_alloca-
       tor().

Parameters
	  source - compatible container	to transfer the	nodes from

Return value
	  (none)

Complexity
	  Average   case   O(N),   worst   case	  O(N*size()+N),  where	 N  is
       source.size().

Example
       // Run this code

	#include <iostream>
	#include <string>
	#include <utility>
	#include <unordered_map>

	// print out a std::pair
	template <class	Os, class U, class V>
	Os& operator<<(Os& os, const std::pair<U,V>& p)	{
	    return os << '{' <<	p.first	<< ", "	<< p.second << '}';
	}

	// print out an	associative container
	template <class	Os, class K, class V>
	Os& operator<<(Os& os, const std::unordered_map<K, V>& v) {
	    os << '[' << v.size() << "]	{ ";
	    bool o{};
	    for	(const auto& e : v)
		os << (o ? ", "	: (o = 1, "")) << e;
	    return os << " }\n";
	}

	int main()
	{
	    std::unordered_map<std::string, int>
		p{ {"C", 3}, {"B", 2}, {"A", 1}, {"A", 0} },
		q{ {"E", 6}, {"E", 7}, {"D", 5}, {"A", 4} };

	    std::cout << "p: " << p << "q: " <<	q;

	    p.merge(q);

	    std::cout << "p.merge(q);\n" << "p:	" << p << "q: "	<< q;
	}

Possible output:
	p: [3] { {A, 1}, {B, 2}, {C, 3}	}
	q: [3] { {A, 4}, {D, 5}, {E, 6}	}
	p.merge(q);
	p: [5] { {E, 6}, {D, 5}, {A, 1}, {B, 2}, {C, 3}	}
	q: [1] { {A, 4}	}

See also
	  extract extracts nodes from the container
	  (C++17) (public member function)
		  inserts elements
	  insert  or nodes
	  (C++11) (since C++17)
		  (public member function)

http://cppreference.com		  2022.07.31	  std::unordered_map::merge(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::unordered_map::merge&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help