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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::unordered_multimap - std::unordered_multimap

Synopsis
	  Defined in header <unordered_map>
	  template<

	  class	Key,
	  class	T,
	  class		      Hash		=	       std::hash<Key>,
       (1) (since C++11)
	  class	KeyEqual = std::equal_to<Key>,
	  class	Allocator = std::allocator< std::pair<const Key, T> >

	  > class unordered_multimap;
	  namespace pmr	{

	  template <class Key, class T,
	  class	Hash = std::hash<Key>,
	  class		    Pred	     =		   std::equal_to<Key>>
       (2) (since C++17)
	  using	unordered_multimap = std::unordered_multimap<Key, T, Hash,
	  Pred,
	  std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;

	  }

	  Unordered  multimap  is an unordered associative container that sup-
       ports equivalent
	  keys (an unordered_multimap may contain multiple copies of each  key
       value) and that
	  associates  values of	another	type with the keys. The	unordered_mul-
       timap class
	  supports forward iterators. Search, insertion, and removal have  av-
       erage
	  constant-time	complexity.

	  Internally, the elements are not sorted in any particular order, but
       organized into
	  buckets.  Which bucket an element is placed into depends entirely on
       the hash	of its
	  key. This allows fast	access to individual elements, since once  the
       hash is
	  computed, it refers to the exact bucket the element is placed	into.

	  The  iteration  order	of this	container is not required to be	stable
       (so, for	example,
	  std::equal cannot be used to compare two  std::unordered_multimaps),
       except that
	  every	group of elements whose	keys compare equivalent	(compare equal
       with key_eq()
	  as  the comparator) forms a contiguous subrange in the iteration or-
       der, also
	  accessible with equal_range().

	  std::unordered_multimap meets	the requirements of Container,
	  AllocatorAwareContainer, UnorderedAssociativeContainer.

Member types
	  Member type		  Definition
	  key_type		  Key
	  mapped_type		  T
	  value_type		  std::pair<const Key, T>
	  size_type		  Unsigned integer type	(usually std::size_t)
	  difference_type	  Signed integer type (usually std::ptrdiff_t)
	  hasher		  Hash
	  key_equal		  KeyEqual
	  allocator_type	  Allocator
	  reference		  value_type&
	  const_reference	  const	value_type&
	  pointer		  std::allocator_traits<Allocator>::pointer
	  const_pointer				 std::allocator_traits<Alloca-
       tor>::const_pointer
	  iterator		  LegacyForwardIterator	to value_type
	  const_iterator	  LegacyForwardIterator	to const value_type
				  An iterator type whose category, value, dif-
       ference,	pointer
				  and
	  local_iterator	   reference  types  are the same as iterator.
       This iterator
				  can be used  to  iterate  through  a	single
       bucket but not
				  across buckets
				  An iterator type whose category, value, dif-
       ference,	pointer
				  and
	  const_local_iterator	  reference types are the same as const_itera-
       tor. This
				  iterator
				  can  be  used	 to  iterate  through a	single
       bucket but not
				  across buckets
	  node_type (since C++17) a specialization of node handle representing
       a container
				  node

Member functions
	  constructor	    constructs the unordered_multimap
	  (C++11)	    (public member function)
	  destructor	    destructs the unordered_multimap
	  (C++11)	    (public member function)
	  operator=	    assigns values to the container
	  (C++11)	    (public member function)
	  get_allocator	    returns the	associated allocator
	  (C++11)	    (public member function)

Iterators
	  begin		    returns an iterator	to the beginning
	  cbegin	    (public member function)
	  (C++11)
	  end		    returns an iterator	to the end
	  cend		    (public member function)
	  (C++11)

Capacity
	  empty		    checks whether the container is empty
	  (C++11)	    (public member function)
	  size		    returns the	number of elements
	  (C++11)	    (public member function)
	  max_size	    returns the	maximum	possible number	of elements
	  (C++11)	    (public member function)

Modifiers
	  clear		    clears the contents
	  (C++11)	    (public member function)
			    inserts elements
	  insert	    or nodes
	  (C++11)	    (since C++17)
			    (public member function)
	  emplace	    constructs element in-place
	  (C++11)	    (public member function)
	  emplace_hint	    constructs elements	in-place using a hint
	  (C++11)	    (public member function)
	  erase		    erases elements
	  (C++11)	    (public member function)
	  swap		    swaps the contents
	  (C++11)	    (public member function)
	  extract	    extracts nodes from	the container
	  (C++17)	    (public member function)
	  merge		    splices nodes from another container
	  (C++17)	    (public member function)

Lookup
	  count		    returns the	number of elements  matching  specific
       key
	  (C++11)	    (public member function)
	  find		    finds element with specific	key
	  (C++11)	    (public member function)
	  contains	    checks if the container contains element with spe-
       cific key
	  (C++20)	    (public member function)
	  equal_range	    returns range of elements matching a specific key
	  (C++11)	    (public member function)

Bucket interface
	  begin(size_type)  returns an iterator	to the beginning of the	speci-
       fied bucket
	  cbegin(size_type) (public member function)
	  (C++11)
	  end(size_type)     returns  an  iterator to the end of the specified
       bucket
	  cend(size_type)   (public member function)
	  (C++11)
	  bucket_count	    returns the	number of buckets
	  (C++11)	    (public member function)
	  max_bucket_count  returns the	maximum	number of buckets
	  (C++11)	    (public member function)
	  bucket_size	    returns the	number of elements in specific bucket
	  (C++11)	    (public member function)
	  bucket	    returns the	bucket for specific key
	  (C++11)	    (public member function)

Hash policy
	  load_factor	    returns average number of elements per bucket
	  (C++11)	    (public member function)
	  max_load_factor   manages maximum average  number  of	 elements  per
       bucket
	  (C++11)	    (public member function)
	  rehash	     reserves at least the specified number of buckets
       and regenerates
	  (C++11)	    the	hash table
			    (public member function)
	  reserve	    reserves space for at least	the  specified	number
       of elements and
	  (C++11)	    regenerates	the hash table
			    (public member function)

Observers
	  hash_function	    returns function used to hash the keys
	  (C++11)	    (public member function)
	  key_eq	     returns  the  function  used  to compare keys for
       equality
	  (C++11)	    (public member function)

Non-member functions
	  operator==			     compares the values  in  the  un-
       ordered_multimap
	  operator!=			     (function template)
	  (removed in C++20)
	  std::swap(std::unordered_multimap)  specializes  the std::swap algo-
       rithm
	  (C++11)			     (function template)
	  erase_if(std::unordered_multimap)  Erases  all  elements  satisfying
       specific	criteria
	  (C++20)			     (function template)

	 Deduction guides(since	C++17)

http://cppreference.com		  2022.07.31	    std::unordered_multimap(3)

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

home | help