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

NAME
     std::unordered_multiset - std::unordered_multiset

Synopsis
	Defined in header <unordered_set>
	template<

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

	> class unordered_multiset;
	namespace pmr {

	    template<
		class Key,
		class Hash = std::hash<Key>,
		class Pred =  std::equal_to<Key>			     (2)
     (since C++17)
	    > using unordered_multiset = std::unordered_multiset<Key,
	Hash, Pred,

	 std::pmr::polymorphic_allocator<Key>>;

	}

	std::unordered_multiset is an associative container that contains set of
     possibly
	non-unique  objects of type Key. Search, insertion, and removal have av-
     erage
	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
	value.	This  allows fast access to individual elements, since once 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_multisets), 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_multiset 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
	value_type		Key
	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		Constant 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_multiset
			  (public member function)
	destructor	  destructs the unordered_multiset
			  (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_multiset
	(C++11) 			   (function template)
	(C++11)(removed in C++20)
	std::swap(std::unordered_multiset) specializes the std::swap algorithm
	(C++11) 			   (function template)
	erase_if(std::unordered_multiset)   erases  all elements satisfying spe-
     cific criteria
	(C++20) 			   (function template)

	  Deduction guides (since C++17)

Notes
	The member types iterator and const_iterator may be aliases to the  same
     type. This
	means defining a pair of function overloads using the two types as para-
     meter types
	may violate the One Definition Rule. Since iterator is convertible to
	const_iterator,  a  single  function  with a const_iterator as parameter
     type will work
	instead.

	    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_multiset(3)
home | help