absl::linked_hash_map

Synopsis

Declared in <absl/container/linked_hash_map.h>

template<
    typename Key,
    typename Value,
    typename KeyHash = absl::flat_hash_set<Key>::hasher,
    typename KeyEq = absl::flat_hash_set<Key, KeyHash>::key_equal,
    typename Alloc = std::allocator<std::pair<Key const, Value>>>
class linked_hash_map;

Description

Provides O(1) amortized insertions and lookups, as well as iteration over the map in the insertion order. This class is thread-compatible, but not exception-safe. It supports heterogeneous lookups.

Type Aliases

Name	Description
`allocator_type`	The allocator type.
`const_iterator`	The const iterator type, iterating in insertion order.
`const_pointer`	A const pointer to an element.
`const_reference`	A const reference to an element.
`const_reverse_iterator`	The const reverse iterator type.
`difference_type`	The signed integer type for iterator differences.
`hasher`	The hash function type for keys.
`insert_return_type`	The return type of node-handle insertions.
`iterator`	The iterator type, iterating in insertion order.
`key_equal`	The equality comparison type for keys.
`key_type`	The key type.
`mapped_type`	The mapped value type.
`node_type`	The node handle type used to extract and reinsert elements.
`pointer`	A pointer to an element.
`reference`	A reference to an element.
`reverse_iterator`	The reverse iterator type.
`size_type`	The unsigned integer type for sizes.
`value_type`	The stored element type, a key/value pair.

Member Functions

Name	Description
`linked_hash_map` [constructor]	Constructors
`operator=`	Assignment operators
`at`	`at` overloads
`back`	`back` overloads
`begin`	`begin` overloads
`bucket_count`	Returns the number of buckets in the underlying hash set.
`capacity`	Returns the number of elements the map can hold without rehashing.
`cbegin`	Returns a const iterator to the first element.
`cend`	Returns a const iterator past the last element.
`clear`	Removes all elements from the map.
`contains`	Returns whether the map contains an element with the given key.
`count`	Returns the number of elements with the given key.
`crbegin`	Returns a const reverse iterator to the last element.
`crend`	Returns a const reverse iterator before the first element.
`emplace`	Constructs an element in place if the key is not already present.
`emplace_hint`	Constructs an element in place if the key is not present, ignoring the position hint.
`empty`	Returns whether the map is empty.
`end`	`end` overloads
`equal_range`	Returns the range of elements matching the given key.
`erase`	`erase` overloads
`extract`	`extract` overloads
`find`	Finds the element with the given key.
`front`	`front` overloads
`get_allocator`	Returns the allocator used by the map.
`hash_function`	Returns the hash function used by the map.
`insert`	`insert` overloads
`insert_or_assign`	`insert_or_assign` overloads
`key_eq`	Returns the key equality comparison used by the map.
`load_factor`	Returns the current load factor of the underlying hash set.
`max_size`	Returns the maximum number of elements the map can hold.
`merge`	Merges the elements of another map into this one.
`operator[]`	Returns a reference to the value mapped to the given key, inserting a default-constructed value if the key is not present.
`pop_back`	Removes the last element from the map.
`pop_front`	Removes the first element from the map.
`rbegin`	`rbegin` overloads
`rehash`	Rehashes the map so it can hold at least `n` elements without rehashing.
`rend`	`rend` overloads
`reserve`	Reserves capacity for at least `n` elements.
`size`	Returns the number of elements in the map.
`splice`	Moves an element from another map into this one at the given position.
`swap`	Swaps the contents of this map with another.
`try_emplace`	`try_emplace` overloads

Friends

Name	Description
`absl::operator!=`	Returns whether two maps differ in their key/value pairs.
`absl::operator==`	Returns whether two maps contain the same key/value pairs.