CARVIEW

MOTORHOMES

Select Language

HTTP/1.1 200 OK Server: nginx Date: Sat, 19 Jul 2025 14:09:12 GMT Content-Type: text/html; charset=utf-8 Transfer-Encoding: chunked Connection: keep-alive ETag: W/"bed7-qbkM4/PZCqIS18i8NKLe0XHll1M" Content-Encoding: gzip

C++

class template

<unordered_map>

std::unordered_multimap

template < class Key,                                    // unordered_multimap::key_type           class T,                                      // unordered_multimap::mapped_type           class Hash = hash<Key>,                       // unordered_multimap::hasher           class Pred = equal_to<Key>,                   // unordered_multimap::key_equal           class Alloc = allocator< pair<const Key,T> >  // unordered_multimap::allocator_type           > class unordered_multimap;

Unordered Multimap

Unordered multimaps are associative containers that store elements formed by the combination of a key value and a mapped value, much like unordered_map containers, but allowing different elements to have equivalent keys.

In an unordered_multimap, the key value is generally used to uniquely identify the element, while the mapped value is an object with the content associated to this key. Types of key and mapped value may differ.

Internally, the elements in the unordered_multimap are not sorted in any particular order with respect to either their key or mapped values, but organized into buckets depending on their hash values to allow for fast access to individual elements directly by their key values (with a constant average time complexity on average).

Elements with equivalent keys are grouped together in the same bucket and in such a way that an iterator (see equal_range) can iterate through all of them.

Iterators in the container are at least forward iterators.

Notice that this container is not defined in its own header, but shares header <unordered_map> with unordered_map.

Container properties

Associative: Elements in associative containers are referenced by their key and not by their absolute position in the container.
Unordered: Unordered containers organize their elements using hash tables that allow for fast access to elements by their key.
Map: Each element associates a key to a mapped value: Keys are meant to identify the elements whose main content is the mapped value.
Multiple equivalent keys: The container can hold multiple elements with equivalent keys.
Allocator-aware: The container uses an allocator object to dynamically handle its storage needs.

Template parameters

Key: Type of the key values. Each element in an unordered_multimap is identified by a key value.
Aliased as member type unordered_multimap::key_type.
T: Type of the mapped value. Each element in an unordered_multimap is used to store some data as its mapped value.
Aliased as member type unordered_multimap::mapped_type. Note that this is not the same as unordered_multimap::value_type (see below).
Hash: A unary function object type that takes an object of type key type as argument and returns a unique value of type size_t based on it. This can either be a class implementing a function call operator or a pointer to a function (see constructor for an example). This defaults to hash<Key>, which returns a hash value with a probability of collision approaching 1.0/std::numeric_limits<size_t>::max().
The unordered_multimap object uses the hash values returned by this function to organize its elements internally, speeding up the process of locating individual elements.
Aliased as member type unordered_multimap::hasher.
Pred: A binary predicate that takes two arguments of the key type and returns a bool. The expression pred(a,b), where pred is an object of this type and a and b are key values, shall return true if a is to be considered equivalent to b. This can either be a class implementing a function call operator or a pointer to a function (see constructor for an example). This defaults to equal_to<Key>, which returns the same as applying the equal-to operator (a==b).
The unordered_multimap object uses this expression to determine whether two element keys are equivalent. This container supports multiple elements with equivalent keys.
Aliased as member type unordered_multimap::key_equal.
Alloc: Type of the allocator object used to define the storage allocation model. By default, the allocator class template is used, which defines the simplest memory allocation model and is value-independent.
Aliased as member type unordered_multimap::allocator_type.

In the reference for the unordered_multimap member functions, these same names (Key, T, Hash, Pred and Alloc) are assumed for the template parameters.

Member types

The following aliases are member types of unordered_multimap. They are widely used as parameter and return types by member functions:

member type	definition	notes
`key_type`	the first template parameter (`Key`)
`mapped_type`	the second template parameter (`T`)
`value_type`	`pair<const key_type,mapped_type>`
`hasher`	the third template parameter (`Hash`)	defaults to: `hash<key_type>`
`key_equal`	the fourth template parameter (`Pred`)	defaults to: `equal_to<key_type>`
`allocator_type`	the fifth template parameter (`Alloc`)	defaults to: `allocator<value_type>`
`reference`	`Alloc::reference`
`const_reference`	`Alloc::const_reference`
`pointer`	`Alloc::pointer`	for the default allocator: `value_type*`
`const_pointer`	`Alloc::const_pointer`	for the default allocator: `const value_type*`
`iterator`	a forward iterator to `value_type`	convertible to `const_iterator`
`const_iterator`	a forward iterator to `const value_type`
`local_iterator`	a forward iterator to `value_type`	convertible to `const_local_iterator`
`const_local_iterator`	a forward iterator to `const value_type`
`size_type`	an unsigned integral type	usually the same as size_t
`difference_type`	a signed integral type	usually the same as ptrdiff_t

member type	definition	notes
`key_type`	the first template parameter (`Key`)
`mapped_type`	the second template parameter (`T`)
`value_type`	`pair<const key_type,mapped_type>`
`hasher`	the third template parameter (`Hash`)	defaults to: `hash<key_type>`
`key_equal`	the fourth template parameter (`Pred`)	defaults to: `equal_to<key_type>`
`allocator_type`	the fifth template parameter (`Alloc`)	defaults to: `allocator<value_type>`
`reference`	`value_type&`
`const_reference`	`const value_type&`
`pointer`	`allocator_traits<Alloc>::pointer`	for the default allocator: `value_type*`
`const_pointer`	`allocator_traits<Alloc>::const_pointer`	for the default allocator: `const value_type*`
`iterator`	a forward iterator to `value_type`	convertible to `const_iterator`
`const_iterator`	a forward iterator to `const value_type`
`local_iterator`	a forward iterator to `value_type`	convertible to `const_local_iterator`
`const_local_iterator`	a forward iterator to `const value_type`
`size_type`	an unsigned integral type	usually the same as size_t
`difference_type`	a signed integral type	usually the same as ptrdiff_t

Member functions

(constructor): Construct unordered_multimap (public member function)

(destructor): Destroy unordered multimap (public member function)

operator=: Assign content (public member function)

Capacity

empty: Test whether container is empty (public member function)

size: Return container size (public member function)

max_size: Return maximum size (public member function)

Iterators

begin: Return iterator to beginning (public member type)

end: Return iterator to end (public member type)

cbegin: Return const_iterator to beginning (public member function)

cend: Return const_iterator to end (public member function)

Element lookup

find: Get iterator to element (public member function)

count: Count elements with a specific key (public member function)

equal_range: Get range of elements with specific key (public member function)

Modifiers

emplace: Construct and insert element (public member function)

emplace_hint: Construct and insert element with hint (public member function)

insert: Insert elements (public member function)

erase: Erase elements (public member function)

clear: Clear content (public member function)

swap: Swap content (public member function)

Buckets

bucket_count: Return number of buckets (public member function)

max_bucket_count: Return maximum number of buckets (public member function)

bucket_size: Return bucket_size (public member type)

bucket: Locate element's bucket (public member function)

Hash policy

load_factor: Return load factor (public member function)

max_load_factor: Get or set maximum load factor (public member function)

rehash: Set number of buckets (public member function)

reserve: Request a capacity change (public member function)

Observers

hash_function: Get hash function (public member type)

key_eq: Get key equivalence predicate (public member type)

get_allocator: Get allocator (public member function)

Non-member function overloads

operators (unordered_multimap): Relational operators for unordered_multimap (function template)

swap (unordered_multimap): Exchanges contents of two unordered_multimap containers (function template)

Original Source | Taken Source

member functions

non-member overloads