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

FreeBSD Manual Pages

  
 
  

home | help 
std::unorde...imap::merge(3)  C++ Standard Libary std::unorde...imap::merge(3)

NAME
       std::unordered_multimap::merge -	std::unordered_multimap::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.

	  No elements are copied or moved, only	the internal pointers  of  the
       container nodes
	  are  repointed.  All pointers	and references to the transferred ele-
       ments remain valid,
	  but now refer	into *this, not	into source.  Iterators	 referring  to
       the transferred
	  elements and all iterators referring to *this	are invalidated.

	  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_multimap<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_multimap<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: [4] { {A, 1}, {A, 0}, {B, 2}, {C, 3}	}
	q: [4] { {A, 4}, {D, 5}, {E, 6}, {E, 7}	}
	p.merge(q);
	p:  [8]	 { {E, 6}, {E, 7}, {C, 3}, {A, 1}, {A, 0}, {A, 4}, {D, 5}, {B,
       2} }
	q: [0] { }

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::unorde...imap::merge(3)

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

home | help