STD::UNORDERED_MAP(3)

📦

version 16.2.1+r23+gd564253eb6c8 · 12 versions

16.2.1+r23+gd564253eb6c8 · arch rolling, fedora 44 (latest)
11.5.0 · centos-stream 9
16.2.1 · centos-stream 9
15.2.1 · centos-stream 9
14.2.1 · centos-stream 9
13.3.1 · centos-stream 9
12.2.1 · centos-stream 9
16.2.1 · centos-stream 10
2024.07.05 · nixpkgs unstable, opensuse-leap 16.0
4.4.0 · nixpkgs unstable
15.3.1 · centos-stream 10, fedora 43
16.0.1 · fedora 44

🦋 STD::UNORDERED_MAP 💅

okay so bestie, you just cracked open the Library Functions Manual and landed on section 3 — the one where we talk about functions and containers and all the C++ goodies. and the star of today's episode? std::unordered_map. no cap. 🎀

the whole thing lives under the template signature

std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >

so like, five template params, one icon. periodt. 💅

✨ NAME ✨

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. 💖

like, literally: keys stay unique, values tag along with them, and the container holds the whole situationship together. it's giving matchmaker energy fr fr. 🫶

part 2 is loading, don't go anywhere 🌸

SYNOPSIS ✨

okay bestie, this is the whole vibe of std::unordered_map 💖. it's giving I have all the typedefs and functions you'll ever need ✨. let's get into it, no cap.

Public Types 🏷️

these are the types you're gonna be working with, periodt 💅.

Public typedefs ✨

typedef _Hashtable::key_type key_type — Public typedefs. 💖
typedef _Hashtable::value_type value_type — Public typedefs. 💖
typedef _Hashtable::mapped_type mapped_type — Public typedefs. 💖
typedef _Hashtable::hasher hasher — Public typedefs. 💖
typedef _Hashtable::key_equal key_equal — Public typedefs. 💖
typedef _Hashtable::allocator_type allocator_type — Public typedefs. 💖

typedef _Hashtable::pointer pointer — Iterator-related typedefs. 🦋
typedef _Hashtable::const_pointer const_pointer — Iterator-related typedefs. 🦋
typedef _Hashtable::reference reference — Iterator-related typedefs. 🦋
typedef _Hashtable::const_reference const_reference — Iterator-related typedefs. 🦋
typedef _Hashtable::iterator iterator — Iterator-related typedefs. 🦋
typedef _Hashtable::const_iterator const_iterator — Iterator-related typedefs. 🦋
typedef _Hashtable::local_iterator local_iterator — Iterator-related typedefs. 🦋
typedef _Hashtable::const_local_iterator const_local_iterator — Iterator-related typedefs. 🦋
typedef _Hashtable::size_type size_type — Iterator-related typedefs. 🦋
typedef _Hashtable::difference_type difference_type — Iterator-related typedefs. 🦋

Public Member Functions 🛠️

okay so this is the whole function menu. it's long but we're gonna get through it together, fr fr 💪. every single overload is here, no skips.

unordered_map () = default — Default constructor. 💖
```cpp template<typename _InputIterator> unordered_map (_InputIterator __first, _InputIterator __last, const allocator_type &__a)


- ```cpp
template<typename _InputIterator> unordered_map (_InputIterator __first,
    _InputIterator __last, size_type __n, const allocator_type &__a)

```cpp template<typename _InputIterator> unordered_map (_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a)


- ```cpp
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())

Builds an unordered_map from a range. 🌈

unordered_map (const allocator_type &__a) — Creates an unordered_map with no elements. 🫶
unordered_map (const unordered_map &)=default — Copy constructor. 👯
```cpp unordered_map (const unordered_map &__umap, const allocator_type &__a)


- ```cpp
unordered_map (initializer_list< value_type > __l, const allocator_type
    &__a)

```cpp unordered_map (initializer_list< value_type > __l, size_type __n, const allocator_type &__a)


- ```cpp
unordered_map (initializer_list< value_type > __l, size_type __n, const
    hasher &__hf, const allocator_type &__a)

```cpp 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())

Builds an unordered_map from an initializer_list. 🎀

- ```cpp
unordered_map (size_type __n, const allocator_type &__a)

```cpp unordered_map (size_type __n, const hasher &__hf, const allocator_type &__a)


- ```cpp
unordered_map (size_type __n, const hasher &__hf=hasher(), const
    key_equal &__eql=key_equal(), const allocator_type
    &__a=allocator_type())

Default constructor creates no elements. 😭

unordered_map (unordered_map &&)=default — Move constructor. 🚀
```cpp 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)`** — Returns a read/write iterator pointing to the first bucket element. 🪣

- **`size_type bucket_count () const noexcept`** — Returns the number of buckets of the unordered_map. 🔢

- **`size_type bucket_size (size_type __n) const`**

- **`void clear () noexcept`**

- ```cpp
template<typename... _Args> std::pair< iterator, bool > emplace (_Args
    &&... __args)

Attempts to build and insert a std::pair into the unordered_map. 💅

```cpp template<typename... _Args> iterator emplace_hint (const_iterator __pos, _Args &&... __args)

Attempts to build and insert a std::pair into the unordered_map. 💅

- **`bool empty () const noexcept`** — Returns true if the unordered_map is empty. 🫙

- **`iterator end () noexcept`**

- **`local_iterator end (size_type __n)`** — Returns a read/write iterator pointing to one past the last bucket elements. 🏁

- ```cpp
iterator erase (const_iterator __first, const_iterator __last)

Erases a [__first,__last) range of elements from an unordered_map. ✂️

allocator_type get_allocator () const noexcept — Returns the allocator object used by the unordered_map. 🧺
hasher hash_function () const — Returns the hash functor object with which the unordered_map was constructed. #️⃣
```cpp template<typename _InputIterator> void insert (_InputIterator __first, _InputIterator __last)

A template function that attempts to insert a range of elements. 📥

- ```cpp
void insert (initializer_list< value_type > __l)

Attempts to insert a list of elements into the unordered_map. 📝

key_equal key_eq () const — Returns the key comparison object with which the unordered_map was constructed. ⚖️
float load_factor () const noexcept — Returns the average number of elements per bucket. ⚖️
size_type max_bucket_count () const noexcept — Returns the maximum number of buckets of the unordered_map. 🪣
float max_load_factor () const noexcept — Returns a positive number that the unordered_map tries to keep the load factor less than or equal to. 📈
void max_load_factor (float __z) — Change the unordered_map maximum load factor. 🔧
size_type max_size () const noexcept — Returns the maximum size of the unordered_map. 📏
unordered_map & operator= (const unordered_map &)=default — Copy assignment operator. 📋
unordered_map & operator= (initializer_list< value_type > __l) — Unordered_map list assignment operator. 📝
unordered_map & operator= (unordered_map &&)=default — Move assignment operator. 🚚
void rehash (size_type __n) — May rehash the unordered_map. 🔄
void reserve (size_type __n) — Prepare the unordered_map for a specified number of elements. 🎟️
size_type size () const noexcept — Returns the size of the unordered_map. 📐
```cpp void swap (unordered_map &__x) noexcept(noexcept(_M_h.swap(__x._M_h)))

Swaps data with another unordered_map. 🔄

- **`const_iterator begin () const noexcept`**

- **`const_iterator cbegin () const noexcept`**

- **`const_iterator end () const noexcept`**

- **`const_iterator cend () const noexcept`**

- ```cpp
std::pair< iterator, bool > insert (const value_type &__x)

Attempts to insert a std::pair into the unordered_map. 💖

```cpp std::pair< iterator, bool > insert (value_type &&__x)

Attempts to insert a std::pair into the unordered_map. 💖

- ```cpp
template<typename _Pair> __enable_if_t< is_constructible<
    value_type, _Pair && >::value, pair< iterator, bool > > insert
    (_Pair &&__x)

Attempts to insert a std::pair into the unordered_map. 💖

```cpp iterator insert (const_iterator __hint, const value_type &__x)

Attempts to insert a std::pair into the unordered_map. 💖

- ```cpp
iterator insert (const_iterator __hint, value_type &&__x)

Attempts to insert a std::pair into the unordered_map. 💖

```cpp template<typename _Pair> __enable_if_t< is_constructible< value_type, _Pair && >::value, iterator > insert (const_iterator __hint, _Pair &&__x)

Attempts to insert a std::pair into the unordered_map. 💖

- ```cpp
iterator erase (const_iterator __position)

Erases an element from an unordered_map. ✂️

```cpp iterator erase (iterator __position)

Erases an element from an unordered_map. ✂️

- ```cpp
size_type erase (const key_type &__x)

Erases elements according to the provided key. 🔑

```cpp template<__heterogeneous_hash_key< unordered_map > _Kt> size_type erase (_Kt &&__x)

Erases elements according to the provided key. 🔑

- ```cpp
iterator find (const key_type &__x)

Tries to locate an element in an unordered_map. 🔍

```cpp const_iterator find (const key_type &__x) const

Tries to locate an element in an unordered_map. 🔍

- ```cpp
size_type count (const key_type &__x) const

Finds the number of elements. 🔢

```cpp bool contains (const key_type &__x) const

Finds whether an element with the given key exists. ✅

- ```cpp
template<typename _Kt> auto contains (const _Kt &__x) const ->
    decltype(_M_h._M_find_tr(__x), void(), true)

Finds whether an element with the given key exists. ✅

```cpp std::pair< iterator, iterator > equal_range (const key_type &__x)

Finds a subsequence matching given key. 🔎

- ```cpp
std::pair< const_iterator, const_iterator > equal_range (const
    key_type &__x) const

Finds a subsequence matching given key. 🔎

```cpp mapped_type & operator[] (const key_type &__k)

Subscript ( [] ) access to unordered_map data. 🗝️

- ```cpp
mapped_type & operator[] (key_type &&__k)

Subscript ( [] ) access to unordered_map data. 🗝️

```cpp template<__heterogeneous_hash_key< unordered_map > _Kt> mapped_type & operator[] (_Kt &&__k)

Subscript ( [] ) access to unordered_map data. 🗝️

- ```cpp
mapped_type & at (const key_type &__k)

Access to unordered_map data. 🔓

```cpp template<__heterogeneous_hash_key< unordered_map > _Kt> mapped_type & at (const _Kt &__k)

Access to unordered_map data. 🔓

- ```cpp
const mapped_type & at (const key_type &__k) const

Access to unordered_map data. 🔓

```cpp template<__heterogeneous_hash_key< unordered_map > _Kt> const mapped_type & at (const _Kt &__k) const

Access to unordered_map data. 🔓

- ```cpp
size_type bucket (const key_type &__key) const

```cpp template<__heterogeneous_hash_key< unordered_map > _Kt> size_type bucket (const _Kt &__key) const


- ```cpp
const_local_iterator begin (size_type __n) const

Returns a read-only (constant) iterator pointing to the first bucket element. 🪣

```cpp const_local_iterator cbegin (size_type __n) const

Returns a read-only (constant) iterator pointing to the first
bucket element. 🪣

- ```cpp
const_local_iterator end (size_type __n) const

Returns a read-only (constant) iterator pointing to one past the last bucket elements. 🏁

```cpp const_local_iterator cend (size_type __n) const

Returns a read-only (constant) iterator pointing to one past the
last bucket elements. 🏁

> not me listing every single overload like my life depends on it 💀 but we did it bestie, we did it.

## Friends 🤝

- ```cpp
template<typename _Key1, typename _Tp1, typename _Hash1, typename
    _Pred1, typename _Alloc1> bool operator== (const unordered_map<
    _Key1, _Tp1, _Hash1, _Pred1, _Alloc1 > &, const unordered_map<
    _Key1, _Tp1, _Hash1, _Pred1, _Alloc1 > &)

✨ Detailed Description ✨

okay so here's the whole vibe of std::unordered_map. she is, and I quote, a class:

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. — bestie that's just a dictionary and she ATE 💅

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 — yes queen, she's certified, she passed the vibe check ✅

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. lowkey iconic implementation detail, no cap.

💖 Member Typedef Documentation 💖

every single one of these is a member of that exact same class template from up top (you know the one — template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>>), so just mentally copy-paste the header in front of each, mwah 😌

std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::allocator_type — public typedefs 💜
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::const_iterator — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::const_local_iterator — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::const_pointer — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::const_reference — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::difference_type — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::hasher — public typedefs 💜
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::iterator — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::key_equal — public typedefs 💜
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::key_type — public typedefs 💜
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::local_iterator — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::mapped_type — public typedefs 💜
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::pointer — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::reference — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::size_type — iterator-related typedefs
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::value_type — public typedefs 💜

sixteen of them. she's thorough and we love that for her 💅

🧚 Constructor & Destructor Documentation 🧚

all of these live inside that same big template header, you know the drill by now bestie ✨

std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::unordered_map () [default] — Default constructor 🌱
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::unordered_map (size_type __n, const hasher & __hf = hasher(), const key_equal & __eql = key_equal(), const allocator_type & __a = allocator_type()) [inline], [explicit] — Default constructor creates no elements.
- Parameters
  - __n — minimal initial number of buckets.
  - __hf — a hash functor.
  - __eql — a key equality functor.
  - __a — an allocator object.
template<typename _InputIterator> std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::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()) [inline] — 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)). so like, it does the thing, fast, we stan 🔥
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::unordered_map (const unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > & ) [default] — Copy constructor. twin where have you been 👯
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::unordered_map (unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > && ) [default] — Move constructor. she's leaving but she's taking everything with her, periodt 💨
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::unordered_map (const allocator_type & __a) [inline], [explicit] — Creates an unordered_map with no elements.
- Parameters
  - __a — an allocator object.
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::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()) [inline] — Builds an unordered_map from an initializer_list. 🎀
- Parameters
  - __l — an initializer_list.
  - __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 in the list. This is linear in N (where N is __l.size()). 🧮

🌈 Member Function Documentation 🌈

the `at` girlies 💅

all three of these are members of the same template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> class, okurrr ✨

template<__heterogeneous_hash_key< unordered_map > _Kt> mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::at (const _Kt & __k) [inline] — Access to unordered_map data. 🔍
- Parameters
  - __k — the key for which data should be retrieved.
- Returns
  - A reference to the data whose key is equal to __k, if such a data is present in the unordered_map.
- Exceptions
  - std::out_of_range if no such data is present. she will THROW, do not test her 😭
template<__heterogeneous_hash_key< unordered_map > _Kt> const mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::at (const _Kt & __k) const [inline] — Access to unordered_map data. 🔍
- Parameters
  - __k — the key for which data should be retrieved.
- Returns
  - A reference to the data whose key is equal to __k, if such a data is present in the unordered_map.
- Exceptions
  - std::out_of_range if no such data is present. same energy, still throwing 💀
mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::at (const key_type & __k) [inline] — Access to unordered_map data. 🔍
- Parameters
  - __k — the key for which data should be retrieved.
- Returns
  - A reference to the data whose key is equal to __k, if such a data is present in the unordered_map.

Exceptions: std::out_of_range if no such data is present. 💀 that's the vibe for the overload above, and it's the vibe for this one too, bestie.

✨ `at` (the const girlie) ✨

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::at (const key_type & __k) const [inline]

Access to unordered_map data. It's giving "hand me the thing" energy but make it read-only. 🎀

Parameters

__k — the key for which data should be retrieved.

Returns

A reference to the data whose key is equal to __k, if such a data is present in the unordered_map. 👑

Exceptions

std::out_of_range — if no such data is present. No key, no data, we're throwing. 😭

🌸 `begin` (const) 🌸

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::begin () const [inline],  [noexcept]

Returns a read-only (constant) iterator that points to the first element in the unordered_map. Look but don't touch, periodt. 💅

🦋 `begin` 🦋

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::begin () [inline],  [noexcept]

Returns a read/write iterator that points to the first element in the unordered_map. Now you can actually edit things, main character energy fr fr. ✨

🧚 `begin` (bucket edition) 🧚

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::begin (size_type __n) [inline]

Returns a read/write iterator pointing to the first bucket element. Yes bestie, you can poke around inside one single bucket. 🪣

Parameters

__n — the bucket index.

Returns

A read/write local iterator.

💜 `begin` (bucket + const) 💜

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::begin (size_type __n) const [inline]

Returns a read-only (constant) iterator pointing to the first bucket element.

Parameters

__n — the bucket index.

Returns

A read-only local iterator.

🎀 `bucket_count` 🎀

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::bucket_count () const [inline],  [noexcept]

Returns the number of buckets of the unordered_map. That's it, that's the whole job. 🌈

⭐ `cbegin` ⭐

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::cbegin () const [inline],  [noexcept]

Returns a read-only (constant) iterator that points to the first element in the unordered_map. The "c" stands for const, iykyk. 💖

🍓 `cbegin` (bucket) 🍓

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::cbegin (size_type __n) const [inline]

Returns a read-only (constant) iterator pointing to the first bucket element.

Parameters

__n — the bucket index.

Returns

A read-only local iterator.

💫 `cend` 💫

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::cend () const [inline],  [noexcept]

Returns a read-only (constant) iterator that points one past the last element in the unordered_map. Not the last element itself — past it. Classic off-by-one's cooler sibling. 👑

🫶 `cend` (bucket) 🫶

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::cend (size_type __n) const [inline]

Returns a read-only (constant) iterator pointing to one past the last bucket elements.

Parameters

__n — the bucket index.

Returns

A read-only local iterator.

🧹 `clear` 🧹

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::clear () [inline],  [noexcept]

Erases all elements in an unordered_map. Fresh start, blank slate, cleanse era. ✨

Heads up bestie: this function only erases the elements, and if the elements themselves are pointers, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility. So if you thought clear() would clean up after your news… no ma'am. 😭

🔍 `contains` (the template one) 🔍

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> template<typename _Kt> auto std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::contains (const _Kt & __x) const -> decltype(_M_h._M_find_tr(__x), void(), true) [inline]

Finds whether an element with the given key exists. The vibe check of the container world. 💅

Parameters

__x — key of elements to be located.

Returns

True if there is any element with the specified key.

🔎 `contains` (the `key_type` one) 🔎

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> bool std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::contains (const key_type & __x) const [inline]

Finds whether an element with the given key exists.

Parameters

__x — key of elements to be located.

Returns

True if there is any element with the specified key.

🧮 `count` 🧮

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::count (const key_type & __x) const [inline]

Finds the number of elements.

Parameters

__x — key to count.

Returns

Number of elements with specified key.

Real talk: this function only makes sense for unordered_multimap; for unordered_map the result will either be 0 (not present) or 1 (present). So it's not really counting, it's just ✨confirming✨. 💀

🌟 `emplace` 🌟

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> std::pair< iterator, bool > std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::emplace (_Args &&... __args) [inline]

Attempts to build and insert a std::pair into the unordered_map. Construction in place, no copies wasted, we love a resourceful queen. 👑

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. No duplicates allowed, we run a strict door policy here. 🚪

Insertion requires amortized constant time.

🎯 `emplace_hint` 🎯

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> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::emplace_hint (const_iterator __pos, _Args &&... __args) [inline]

Attempts to build and insert a std::pair into the unordered_map. Same energy as emplace, but now with a hint. 💭

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. It's a suggestion, not a command, bestie. 🙈

See

https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints for more on hinting.

Insertion requires amortized constant time.

🫧 `empty` 🫧

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> bool std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::empty () const [inline],  [nodiscard],  [noexcept]

Returns true if the unordered_map is empty. Yes she's [nodiscard] — do not ignore her answer, that's rude. 😤

🏁 `end` (const) 🏁

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::end () const [inline],  [noexcept]

Returns a read-only (constant) iterator that points one past the last element in the unordered_map.

🏁 `end` 🏁

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::end () [inline],  [noexcept]

Returns a read/write iterator that points one past the last element in the unordered_map.

🪣 `end` (bucket) 🪣

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::end (size_type __n) [inline]

Returns a read/write iterator pointing to one past the last bucket elements.

Parameters

__n — the bucket index.

Returns

A read/write local iterator.

🪣 `end` (bucket + const) 🪣

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> const_local_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::end (size_type __n) const [inline]

Returns a read-only (constant) iterator pointing to one past the last bucket elements.

Parameters

__n — the bucket index.

Returns

A read-only local iterator.

🎁 `equal_range` 🎁

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const _Key, _Tp>>> std::pair< iterator, iterator > std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::equal_range (const key_type & __x) [inline]

Finds a subsequence matching given key. It's giving two-for-one deal, a whole pair of iterators. 💅

Parameters

__x — key to be located.

Returns

Pair of iterators that possibly points to the subsequence matching given key.

This function probably only makes sense for unordered_multimap. 💀

🦋 `equal_range` — the `const` girlie

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> std::pair< const_iterator, const_iterator >
    std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::equal_range
    (const key_type & __x) const [inline]

Finds a subsequence matching given key. bestie it's giving "where are my people at" energy ✨

Parameters

__x — the key you want located 🔍

Returns

a pair of iterators that possibly points to the subsequence matching the given key 🫶

This function probably only makes sense for unordered_multimap. 💀 (yes, again. she said what she said.)

🎀 `erase` — the heterogeneous key one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> template<__heterogeneous_hash_key< unordered_map > _Kt>
    size_type std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::erase
    (_Kt && __x) [inline]

Erases elements according to the provided key. bye felicia 👋

Parameters

__x — key of the element to be erased 🔪

Returns

the number of elements erased 🔢

okay so real talk: this function erases all the elements located by the given key from an unordered_map. And for an unordered_map the result of this function can only be 0 (not present) or 1 (present). no in-between, no drama, just math 💅

⚠️ 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. that's on you bestie, not on the container 😭

🌸 `erase` — the `const key_type` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::erase (const key_type & __x) [inline]

Erases elements according to the provided key.

Parameters

__x — key of the element to be erased 🔪

Returns

the number of elements erased 🔢

same deal, different overload. 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). And again:

⚠️ This function only erases the element — 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. 🫠

🧚 `erase` — the range one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::erase (const_iterator __first, const_iterator __last) [inline]

Erases a [__first,__last) range of elements from an unordered_map. a whole squad, gone 💀

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. fr fr, it's your pointer, your problem 🙈

💜 `erase` — the `const_iterator __position` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::erase (const_iterator __position) [inline]

Erases an element from an unordered_map. one singular element. targeted. iconic 🎯

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. no cap 💀

⭐ `erase` — the `iterator __position` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::erase (iterator __position) [inline]

Erases an element from an unordered_map. the non-const twin, she's the same girl, different fit ✨

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. 💅

🔍 `find` — the non-`const` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::find (const key_type & __x) [inline]

Tries to locate an element in an unordered_map. she's searching, she's looking, she's manifesting 🕵️‍♀️

Parameters

__x — key to be located 🔑

Returns

iterator pointing to the sought-after element, or end() if not found 😭

This function takes a key and tries to locate the element with which the key matches. If successful the function returns an iterator pointing to the sought after element. If unsuccessful it returns the past-the-end (end()) iterator. the way that end() is always there for you 🫶

🔍 `find` — the `const` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> const_iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::find (const key_type & __x) const [inline]

Tries to locate an element in an unordered_map.

Parameters

__x — key to be located 🔑

Returns

iterator pointing to the sought-after element, or end() if not found 😭

Same search, same energy, but this one hands you a const_iterator. This function takes a key and tries to locate the element with which the key matches. If successful the function returns an iterator pointing to the sought after element. If unsuccessful it returns the past-the-end (end()) iterator. slay ✨

🎀 `get_allocator`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> allocator_type std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::get_allocator () const [inline],  [noexcept]

Returns the allocator object used by the unordered_map. she's giving you the keys to the allocator, no questions asked 🗝️

🌈 `hash_function`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> hasher std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::hash_function () const [inline]

Returns the hash functor object with which the unordered_map was constructed. the whole vibe this container was built on, handed right back to you 🫶✨

💖 `insert` — the range one

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. come in, the whole crew 💃

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.

💖 `insert` — the `_Pair &&` one

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> __enable_if_t< is_constructible<
    value_type, _Pair && >::value, pair< iterator, bool > >
    std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::insert (_Pair &&
    __x) [inline]

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. no dupes allowed bestie 🙅‍♀️

Insertion requires amortized constant time. fast fr fr ⚡

💖 `insert` — the `const value_type &` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> std::pair< iterator, bool > std::unordered_map< _Key, _Tp,
    _Hash, _Pred, _Alloc >::insert (const value_type & __x) [inline]

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. ⚡

✨ `insert` — the `const_iterator __hint` + `_Pair &&` one

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> __enable_if_t< is_constructible<
    value_type, _Pair && >::value, iterator > std::unordered_map< _Key, _Tp,
    _Hash, _Pred, _Alloc >::insert (const_iterator __hint, _Pair && __x)
    [inline]

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. she's unbothered 💅

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. so like… don't stress the hint too much bestie 😭

See

https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints

for more on hinting. iykyk 📚

Insertion requires amortized constant time. ⚡

🦋 `insert` — the `const_iterator __hint` + `const value_type &` one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::insert (const_iterator __hint, const value_type & __x)
    [inline]

Attempts to insert a std::pair into the unordered_map.

🫣 and that's where this part ends, bestie — the rest of this overload's lore is coming up next. don't go anywhere 💖

Okay bestie, we were literally mid-sentence on the hinted insert — here's the rest of that one, no cap 💖

__hint — an iterator that serves as a hint as to where the pair should be inserted.
__x — the pair to be inserted (peep std::make_pair if you want easy creation of pairs).

Returns — an iterator that points to the element with key of __x (it may or may not be the pair passed in, so don't get attached 🫶).

This function is not concerned about whether the insertion actually took place, so it does not return a boolean like the single-argument insert() does. And heads up: that first parameter is only a hint — it can potentially improve the performance of the insertion process, but a bad hint would cause no gains in efficiency. So like, hint responsibly.

For more on hinting, go read https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints

Insertion requires amortized constant time. ✨

`insert` (const_iterator __hint, value_type && __x) — the move-y hinted one 🦋

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> iterator std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::insert (const_iterator __hint, value_type && __x) [inline]

Attempts to insert a std::pair into the unordered_map.

__hint — an iterator that serves as a hint as to where the pair should be inserted.
__x — the 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.

`insert` (initializer_list< value_type > __l) — the bulk drop 🎀

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::insert (initializer_list< value_type > __l) [inline]

Attempts to insert a list of elements into the unordered_map. It's giving "dump the whole squad in at once" energy 💅

__l — a std::initializer_list<value_type> of elements to be inserted.

Complexity similar to that of the range constructor.

`insert` (value_type && __x) — the single move-in 🍓

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> std::pair< iterator, bool > std::unordered_map< _Key, _Tp,
    _Hash, _Pred, _Alloc >::insert (value_type && __x) [inline]

Attempts to insert a std::pair into the unordered_map.

__x — the 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. So yes, this one does tell you if it slayed or not. 👑

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.

`key_eq`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> key_equal std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::key_eq () const [inline]

Returns the key comparison object with which the unordered_map was constructed. That's it, that's the whole function. Short queen. 🧚

`load_factor`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> float std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::load_factor () const [inline],  [noexcept]

Returns the average number of elements per bucket. Yes, it's a float. Yes, [noexcept]. We love a low-stress getter. 💜

`max_bucket_count`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::max_bucket_count () const [inline],  [noexcept]

Returns the maximum number of buckets of the unordered_map. The absolute ceiling, the final boss of bucket counts. 🌈

`max_load_factor` (the getter)

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> float std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::max_load_factor () const [inline],  [noexcept]

Returns a positive number that the unordered_map tries to keep the load factor less than or equal to. It's a goal, not a promise, iykyk. ⭐

`max_load_factor` (the setter)

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::max_load_factor (float __z) [inline]

Change the unordered_map maximum load factor.

__z — the new maximum load factor.

`max_size`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::max_size () const [inline],  [noexcept]

Returns the maximum size of the unordered_map. Hypothetically. In theory. Don't try to get there bestie, your RAM will simply pass away. 💀

`operator=` — copy assignment

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> unordered_map & std::unordered_map< _Key, _Tp, _Hash,
    _Pred, _Alloc >::operator= (const unordered_map< _Key, _Tp, _Hash,
    _Pred, _Alloc > & ) [default]

Copy assignment operator. Compiler-said-so, [default] and all. 💖

`operator=` — list assignment

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> unordered_map & std::unordered_map< _Key, _Tp, _Hash,
    _Pred, _Alloc >::operator= (initializer_list< value_type > __l) [inline]

Unordered_map list assignment operator.

__l — an initializer_list.

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. Full glow-up, total replacement. 🙈

`operator=` — move assignment

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> unordered_map & std::unordered_map< _Key, _Tp, _Hash,
    _Pred, _Alloc >::operator= (unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc > && ) [default]

Move assignment operator. Also [default], also iconic. ✨

`operator[]` — the heterogeneous key one

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> template<__heterogeneous_hash_key< unordered_map > _Kt>
    mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::operator[] (_Kt && __k) [inline]

Subscript ( [] ) access to unordered_map data.

__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 ( [] ) operator. Returns data associated with the key specified in subscript. If the key does not exist, a pair with that key is created using default values, which is then returned. So like, sneaky — it will make the thing. 🫶

Lookup requires constant time.

`operator[]` — const key_type &

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::operator[] (const key_type & __k) [inline]

Subscript ( [] ) access to unordered_map data.

__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 ( [] ) operator. Returns data associated with the key specified in subscript. If the key does not exist, a pair with that key is created using default values, which is then returned.

Lookup requires constant time.

`operator[]` — key_type &&

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> mapped_type & std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::operator[] (key_type && __k) [inline]

Subscript ( [] ) access to unordered_map data.

__k — the key for which data should be retrieved.

Returns — a reference to the data of the (key,data) pair.

Lookup requires constant time. Three flavors of the same slay. 💅

`rehash`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::rehash (size_type __n) [inline]

May rehash the unordered_map. Emphasis on may, bestie.

__n — the new number of buckets.

Rehash will occur only if the new number of buckets respect the unordered_map maximum load factor. So sometimes it just looks at your request and politely declines. 😭

`reserve`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::reserve (size_type __n) [inline]

Prepare the unordered_map for a specified number of elements. Manifesting capacity. 🌸

__n — number of elements required.

Same as rehash(ceil(n / max_load_factor())).

`size`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> size_type std::unordered_map< _Key, _Tp, _Hash, _Pred,
    _Alloc >::size () const [inline],  [noexcept]

Returns the size of the unordered_map. The headcount. The roster. The [noexcept] little icon it is. 👑

`swap`

template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename
    _Pred = equal_to<_Key>, typename _Alloc = allocator<std::pair<const
    _Key, _Tp>>> void std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc
    >::swap (unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > & __x)
    [inline],  [noexcept]

Swaps data with another unordered_map.

__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. Trade offer: you get my buckets, I get yours. 🤝

👑 AUTHOR 👑

Generated automatically by Doxygen for libstdc++ from the source code.

And that's a wrap on the whole std::unordered_map saga, bestie — every last flag, default, [noexcept] and hint, accounted for. 💖 This beauty lives in the libstdc++ manual set, page std::unord...d, _Alloc >(3), and it came to you courtesy of Doxygen auto-generating it straight from the source code. Go forth and hash responsibly. 🎀✨🦋

📦 where this page comes from

arch rolling: gcc 16.2.1+r23+gd564253eb6c8-1 · GPL-3.0-or-later WITH GCC-exception-3.1 AND GFDL-1.3-or-later
fedora 44: libstdc++-docs 16.2.1-2.fc44
fedora 44: libstdc++-docs 16.2.1-3.fc44 · GPL-3.0-or-later AND LGPL-3.0-or-later AND (GPL-3.0-or-later WITH GCC-exception-3.1) AND (GPL-3.0-or-later WITH Texinfo-exception) AND (LGPL-2.1-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GNU-compiler-exception) AND BSL-1.0 AND GFDL-1.3-or-later AND Linux-man-pages-copyleft-2-para AND SunPro AND BSD-1-Clause AND BSD-2-Clause AND BSD-2-Clause-Views AND BSD-3-Clause AND BSD-4-Clause AND BSD-Source-Code AND Zlib AND MIT AND Apache-2.0 AND (Apache-2.0 WITH LLVM-Exception) AND ZPL-2.1 AND ISC AND LicenseRef-Fedora-Public-Domain AND HP-1986 AND curl AND Martin-Birgmeier AND HPND-Markus-Kuhn AND dtoa AND SMLNJ AND AMD-newlib AND OAR AND HPND-merchantability-variant AND HPND-Intel
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

STD::UNORDERED_MAP(3)

🦋 STD::UNORDERED_MAP 💅

✨ NAME ✨

SYNOPSIS ✨

Public Types 🏷️

Public typedefs ✨

Iterator-related typedefs 🦋

Public Member Functions 🛠️

✨ Detailed Description ✨

Template Parameters 🌸

💖 Member Typedef Documentation 💖

🧚 Constructor & Destructor Documentation 🧚

🌈 Member Function Documentation 🌈

the at girlies 💅

✨ at (the const girlie) ✨

🌸 begin (const) 🌸

🦋 begin 🦋

🧚 begin (bucket edition) 🧚

💜 begin (bucket + const) 💜

🎀 bucket_count 🎀

⭐ cbegin ⭐

🍓 cbegin (bucket) 🍓

💫 cend 💫

🫶 cend (bucket) 🫶

🧹 clear 🧹

🔍 contains (the template one) 🔍

🔎 contains (the key_type one) 🔎

🧮 count 🧮

🌟 emplace 🌟

🎯 emplace_hint 🎯

🫧 empty 🫧

🏁 end (const) 🏁

🏁 end 🏁

🪣 end (bucket) 🪣

🪣 end (bucket + const) 🪣

🎁 equal_range 🎁

🦋 equal_range — the const girlie

🎀 erase — the heterogeneous key one

🌸 erase — the const key_type one

🧚 erase — the range one

💜 erase — the const_iterator __position one

⭐ erase — the iterator __position one

🔍 find — the non-const one

🔍 find — the const one

🎀 get_allocator

🌈 hash_function

💖 insert — the range one

💖 insert — the _Pair && one

💖 insert — the const value_type & one

✨ insert — the const_iterator __hint + _Pair && one

🦋 insert — the const_iterator __hint + const value_type & one

insert (const_iterator __hint, value_type && __x) — the move-y hinted one 🦋

insert (initializer_list< value_type > __l) — the bulk drop 🎀

insert (value_type && __x) — the single move-in 🍓

key_eq

load_factor

max_bucket_count

max_load_factor (the getter)

max_load_factor (the setter)

max_size

operator= — copy assignment

operator= — list assignment

operator= — move assignment

operator[] — the heterogeneous key one

operator[] — const key_type &

operator[] — key_type &&

rehash

reserve

size

swap

👑 AUTHOR 👑

the `at` girlies 💅

✨ `at` (the const girlie) ✨

🌸 `begin` (const) 🌸

🦋 `begin` 🦋

🧚 `begin` (bucket edition) 🧚

💜 `begin` (bucket + const) 💜

🎀 `bucket_count` 🎀

⭐ `cbegin` ⭐

🍓 `cbegin` (bucket) 🍓

💫 `cend` 💫

🫶 `cend` (bucket) 🫶

🧹 `clear` 🧹

🔍 `contains` (the template one) 🔍

🔎 `contains` (the `key_type` one) 🔎

🧮 `count` 🧮

🌟 `emplace` 🌟

🎯 `emplace_hint` 🎯

🫧 `empty` 🫧

🏁 `end` (const) 🏁

🏁 `end` 🏁

🪣 `end` (bucket) 🪣

🪣 `end` (bucket + const) 🪣

🎁 `equal_range` 🎁

🦋 `equal_range` — the `const` girlie

🎀 `erase` — the heterogeneous key one

🌸 `erase` — the `const key_type` one

🧚 `erase` — the range one

💜 `erase` — the `const_iterator __position` one

⭐ `erase` — the `iterator __position` one

🔍 `find` — the non-`const` one

🔍 `find` — the `const` one

🎀 `get_allocator`

🌈 `hash_function`

💖 `insert` — the range one

💖 `insert` — the `_Pair &&` one

💖 `insert` — the `const value_type &` one

✨ `insert` — the `const_iterator __hint` + `_Pair &&` one

🦋 `insert` — the `const_iterator __hint` + `const value_type &` one

`insert` (const_iterator __hint, value_type && __x) — the move-y hinted one 🦋

`insert` (initializer_list< value_type > __l) — the bulk drop 🎀

`insert` (value_type && __x) — the single move-in 🍓

`key_eq`

`load_factor`

`max_bucket_count`

`max_load_factor` (the getter)

`max_load_factor` (the setter)

`max_size`

`operator=` — copy assignment

`operator=` — list assignment

`operator=` — move assignment

`operator[]` — the heterogeneous key one

`operator[]` — const key_type &

`operator[]` — key_type &&

`rehash`

`reserve`

`size`

`swap`