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

	}

	std::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_multimap  class supports forward iterators. Search, insertion,
     and removal
	have average constant-time complexity.

	Internally, the elements are not sorted in any particular order, but or-
     ganized 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),  ex-
     cept that
	every  group  of  elements  whose keys compare equivalent (compare equal
     with key_eq()
	as the comparator) forms a contiguous subrange in the  iteration  order,
     also
	accessible with equal_range().

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

Template parameters
	 This section is incomplete
	 Reason: Add descriptions of the template parameters.

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<Allocator>::const_pointer
	iterator		LegacyForwardIterator to value_type
	const_iterator		LegacyForwardIterator to const value_type
				An  iterator type whose category, value, differ-
     ence, 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,  differ-
     ence, pointer
				and
	const_local_iterator	 reference types are the same as const_iterator.
     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
			  (public member function)
	destructor	  destructs the unordered_multimap
			  (public member function)
	operator=	  assigns values to the container
			  (public member function)
	get_allocator	  returns the associated allocator
			  (public member function)

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

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

Modifiers
	clear		  clears the contents
			  (public member function)
			  inserts elements
	insert		  or nodes
			  (since C++17)
			  (public member function)
	insert_range	  inserts a range of elements
	(C++23) 	  (public member function)
	emplace 	  constructs element in-place
			  (public member function)
	emplace_hint	  constructs elements in-place using a hint
			  (public member function)
	erase		  erases elements
			  (public member function)
	swap		  swaps the contents
			  (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
			  (public member function)
	find		  finds element with specific key
			  (public member function)
	contains	  checks if the container contains element with specific
     key
	(C++20) 	  (public member function)
	equal_range	  returns range of elements matching a specific key
			  (public member function)

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

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

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

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

	  Deduction guides (since C++17)

Notes
	    Feature-test macro	     Value    Std		    Feature
	__cpp_lib_containers_ranges  202202L (C++23) Ranges construction and in-
     sertion for
						    containers

Example
	 This section is incomplete
	 Reason: no example

	Defect reports

	The following behavior-changing defect	reports  were  applied	retroac-
     tively to
	previously published C++ standards.

	   DR	  Applied to	      Behavior as published		 Correct
     behavior
			    the definitions of reference,
	LWG 2050 C++11	    const_reference,  pointer		       based  on
     value_type and
			    and  const_pointer were based on	      std::allo-
     cator_traits
			    allocator_type

Categories:
	  * Todo with reason
	  * Todo no example

http://cppreference.com 	   2024.06.10	      std::unordered_multimap(3)
home | help