|
| | unordered_map ()=default |
| template<typename _InputIterator> |
| | unordered_map (_InputIterator __first, _InputIterator __last, const allocator_type &__a) |
| template<typename _InputIterator> |
| | unordered_map (_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type &__a) |
| template<typename _InputIterator> |
| | unordered_map (_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a) |
| template<typename _InputIterator> |
| | unordered_map (_InputIterator __first, _InputIterator __last, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type()) |
| | unordered_map (const allocator_type &__a) |
| | unordered_map (const unordered_map &)=default |
| | unordered_map (const unordered_map &__umap, const allocator_type &__a) |
| | unordered_map (initializer_list< value_type > __l, const allocator_type &__a) |
| | unordered_map (initializer_list< value_type > __l, size_type __n, const allocator_type &__a) |
| | unordered_map (initializer_list< value_type > __l, size_type __n, const hasher &__hf, const allocator_type &__a) |
| | unordered_map (initializer_list< value_type > __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type()) |
| | unordered_map (size_type __n, const allocator_type &__a) |
| | unordered_map (size_type __n, const hasher &__hf, const allocator_type &__a) |
| | unordered_map (size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type()) |
| | unordered_map (unordered_map &&)=default |
| | unordered_map (unordered_map &&__umap, const allocator_type &__a) noexcept(noexcept(_Hashtable(std::move(__umap._M_h), __a))) |
| iterator | begin () noexcept |
| local_iterator | begin (size_type __n) |
| size_type | bucket_count () const noexcept |
| size_type | bucket_size (size_type __n) const |
| void | clear () noexcept |
| template<typename... _Args> |
| std::pair< iterator, bool > | emplace (_Args &&... __args) |
| template<typename... _Args> |
| iterator | emplace_hint (const_iterator __pos, _Args &&... __args) |
| bool | empty () const noexcept |
| iterator | end () noexcept |
| local_iterator | end (size_type __n) |
| iterator | erase (const_iterator __first, const_iterator __last) |
| allocator_type | get_allocator () const noexcept |
| hasher | hash_function () const |
| template<typename _InputIterator> |
| void | insert (_InputIterator __first, _InputIterator __last) |
| void | insert (initializer_list< value_type > __l) |
| key_equal | key_eq () const |
| float | load_factor () const noexcept |
| size_type | max_bucket_count () const noexcept |
| float | max_load_factor () const noexcept |
| void | max_load_factor (float __z) |
| size_type | max_size () const noexcept |
| unordered_map & | operator= (const unordered_map &)=default |
| unordered_map & | operator= (initializer_list< value_type > __l) |
| unordered_map & | operator= (unordered_map &&)=default |
| void | rehash (size_type __n) |
| void | reserve (size_type __n) |
| size_type | size () const noexcept |
| void | swap (unordered_map &__x) noexcept(noexcept(_M_h.swap(__x._M_h))) |
| const_iterator | begin () const noexcept |
| const_iterator | cbegin () const noexcept |
| const_iterator | end () const noexcept |
| const_iterator | cend () const noexcept |
| std::pair< iterator, bool > | insert (const value_type &__x) |
| std::pair< iterator, bool > | insert (value_type &&__x) |
| template<typename _Pair> |
| __enable_if_t< is_constructible< value_type, _Pair && >::value, pair< iterator, bool > > | insert (_Pair &&__x) |
| iterator | insert (const_iterator __hint, const value_type &__x) |
| iterator | insert (const_iterator __hint, value_type &&__x) |
| template<typename _Pair> |
| __enable_if_t< is_constructible< value_type, _Pair && >::value, iterator > | insert (const_iterator __hint, _Pair &&__x) |
| iterator | erase (const_iterator __position) |
| iterator | erase (iterator __position) |
| size_type | erase (const key_type &__x) |
| template<__heterogeneous_hash_key< unordered_map > _Kt> |
| size_type | erase (_Kt &&__x) |
| iterator | find (const key_type &__x) |
| const_iterator | find (const key_type &__x) const |
| size_type | count (const key_type &__x) const |
| bool | contains (const key_type &__x) const |
| template<typename _Kt> |
| auto | contains (const _Kt &__x) const -> decltype(_M_h._M_find_tr(__x), void(), true) |
| std::pair< iterator, iterator > | equal_range (const key_type &__x) |
| std::pair< const_iterator, const_iterator > | equal_range (const key_type &__x) const |
| mapped_type & | operator[] (const key_type &__k) |
| mapped_type & | operator[] (key_type &&__k) |
| template<__heterogeneous_hash_key< unordered_map > _Kt> |
| mapped_type & | operator[] (_Kt &&__k) |
| mapped_type & | at (const key_type &__k) |
| template<__heterogeneous_hash_key< unordered_map > _Kt> |
| mapped_type & | at (const _Kt &__k) |
| const mapped_type & | at (const key_type &__k) const |
| template<__heterogeneous_hash_key< unordered_map > _Kt> |
| const mapped_type & | at (const _Kt &__k) const |
| size_type | bucket (const key_type &__key) const |
| template<__heterogeneous_hash_key< unordered_map > _Kt> |
| size_type | bucket (const _Kt &__key) const |
| const_local_iterator | begin (size_type __n) const |
| const_local_iterator | cbegin (size_type __n) const |
| const_local_iterator | end (size_type __n) const |
| const_local_iterator | cend (size_type __n) const |
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
class std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >
A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys.
- Since
- C++11
- Template Parameters
-
| _Key | Type of key objects. |
| _Tp | Type of mapped objects. |
| _Hash | Hashing function object type, defaults to hash<_Key>. |
| _Pred | Predicate function object type, defaults to equal_to<_Key>. |
| _Alloc | Allocator type, defaults to std::allocator<std::pair<const _Key, _Tp>>. |
Meets the requirements of a container, and unordered associative container
The resulting value type of the container is std::pair<const _Key, _Tp>.
Base is _Hashtable, dispatched at compile time via template alias __umap_hashtable.
Definition at line 112 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename _InputIterator>
Builds an unordered_map from a range.
- Parameters
-
| __first | An input iterator. |
| __last | An input iterator. |
| __n | Minimal initial number of buckets. |
| __hf | A hash functor. |
| __eql | A key equality functor. |
| __a | An allocator object. |
Create an unordered_map consisting of copies of the elements from [__first,__last). This is linear in N (where N is distance(__first,__last)).
Definition at line 182 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename... _Args>
Attempts to build and insert a std::pair into the unordered_map.
- Parameters
-
| __args | Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to build and insert a (key, value) pair into the unordered_map. An unordered_map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the unordered_map.
Insertion requires amortized constant time.
Definition at line 456 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename... _Args>
Attempts to build and insert a std::pair into the unordered_map.
- Parameters
-
| __pos | An iterator that serves as a hint as to where the pair should be inserted. |
| __args | Arguments used to generate a new pair instance (see std::piecewise_contruct for passing arguments to each part of the pair constructor). |
- Returns
- An iterator that points to the element with key of the std::pair built from __args (may or may not be that std::pair).
This function is not concerned about whether the insertion took place, and thus does not return a boolean like the single-argument emplace() does. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency.
See https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.
Insertion requires amortized constant time.
Definition at line 487 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Erases elements according to the provided key.
- Parameters
-
| __x | Key of element to be erased. |
- Returns
- The number of elements erased.
This function erases all the elements located by the given key from an unordered_map. For an unordered_map the result of this function can only be 0 (not present) or 1 (present). Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility.
Definition at line 916 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Erases elements according to the provided key.
- Parameters
-
| __x | Key of element to be erased. |
- Returns
- The number of elements erased.
This function erases all the elements located by the given key from an unordered_map. For an unordered_map the result of this function can only be 0 (not present) or 1 (present). Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility.
Definition at line 910 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Erases a [__first,__last) range of elements from an unordered_map.
- Parameters
-
| __first | Iterator pointing to the start of the range to be erased. |
| __last | Iterator pointing to the end of the range to be erased. |
- Returns
- The iterator __last.
This function erases a sequence of elements from an unordered_map. Note that this function only erases the elements, and that if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility.
Definition at line 936 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Erases an element from an unordered_map.
- Parameters
-
| __position | An iterator pointing to the element to be erased. |
- Returns
- An iterator pointing to the element immediately following __position prior to the element being erased. If no such element exists, end() is returned.
This function erases an element, pointed to by the given iterator, from an unordered_map. Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility.
Definition at line 887 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Erases an element from an unordered_map.
- Parameters
-
| __position | An iterator pointing to the element to be erased. |
- Returns
- An iterator pointing to the element immediately following __position prior to the element being erased. If no such element exists, end() is returned.
This function erases an element, pointed to by the given iterator, from an unordered_map. Note that this function only erases the element, and that if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility.
Definition at line 892 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename _InputIterator>
| void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::insert |
( |
_InputIterator | __first, |
|
|
_InputIterator | __last ) |
|
inline |
A template function that attempts to insert a range of elements.
- Parameters
-
| __first | Iterator pointing to the start of the range to be inserted. |
| __last | Iterator pointing to the end of the range. |
Complexity similar to that of the range constructor.
Definition at line 716 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename _Pair>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to insert a (key, value) pair into the unordered_map. An unordered_map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the unordered_map.
Insertion requires amortized constant time.
Definition at line 663 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to insert a (key, value) pair into the unordered_map. An unordered_map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the unordered_map.
Insertion requires amortized constant time.
Definition at line 651 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
template<typename _Pair>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __hint | An iterator that serves as a hint as to where the pair should be inserted. |
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- An iterator that points to the element with key of __x (may or may not be the pair passed in).
This function is not concerned about whether the insertion took place, and thus does not return a boolean like the single-argument insert() does. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency.
See https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.
Insertion requires amortized constant time.
Definition at line 701 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __hint | An iterator that serves as a hint as to where the pair should be inserted. |
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- An iterator that points to the element with key of __x (may or may not be the pair passed in).
This function is not concerned about whether the insertion took place, and thus does not return a boolean like the single-argument insert() does. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency.
See https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.
Insertion requires amortized constant time.
Definition at line 690 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __hint | An iterator that serves as a hint as to where the pair should be inserted. |
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- An iterator that points to the element with key of __x (may or may not be the pair passed in).
This function is not concerned about whether the insertion took place, and thus does not return a boolean like the single-argument insert() does. Note that the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency.
See https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.
Insertion requires amortized constant time.
Definition at line 696 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Attempts to insert a std::pair into the unordered_map.
- Parameters
-
| __x | Pair to be inserted (see std::make_pair for easy creation of pairs). |
- Returns
- A pair, of which the first element is an iterator that points to the possibly inserted pair, and the second is a bool that is true if the pair was actually inserted.
This function attempts to insert a (key, value) pair into the unordered_map. An unordered_map relies on unique keys and thus a pair is only inserted if its first element (the key) is not already present in the unordered_map.
Insertion requires amortized constant time.
Definition at line 657 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Unordered_map list assignment operator.
- Parameters
-
This function fills an unordered_map with copies of the elements in the initializer list __l.
Note that the assignment completely changes the unordered_map and that the resulting unordered_map's size is the same as the number of elements assigned.
Definition at line 358 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Subscript (
- Parameters
-
| __k | The key for which data should be retrieved. |
- Returns
- A reference to the data of the (key,data) pair.
Allows for easy lookup with the subscript (
Lookup requires constant time.
Definition at line 1152 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Subscript (
- Parameters
-
| __k | The key for which data should be retrieved. |
- Returns
- A reference to the data of the (key,data) pair.
Allows for easy lookup with the subscript (
Lookup requires constant time.
Definition at line 1142 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Subscript (
- Parameters
-
| __k | The key for which data should be retrieved. |
- Returns
- A reference to the data of the (key,data) pair.
Allows for easy lookup with the subscript (
Lookup requires constant time.
Definition at line 1146 of file unordered_map.h.
template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
Swaps data with another unordered_map.
- Parameters
-
| __x | An unordered_map of the same element and allocator types. |
This exchanges the elements between two unordered_map in constant time. Note that the global std::swap() function is specialized such that std::swap(m1,m2) will feed to this function.
Definition at line 960 of file unordered_map.h.
1.14.0