STD::__PROFILE::UNORDERED_MULTIMAP(3cxx)

📦
version 9.5.0 · 3 versions
, in ubuntu noble

💖 std::__profile::unordered_multimap 💖

okay bestie, gather round, because this one is a whole vibe and also it's from the (3cxx) manual section, so you know it's the C++ headers crowd. no cap. 🫶

✨ NAME ✨

std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > — it's a Class std::unordered_multimap wrapper with performance instrumentation. literally what it says on the tin, and the tin is iconic. 💅

🌸 SYNOPSIS 🌸

#include <unordered_map>

so like. this class inherits from:

  • unordered_multimap< _Key, _Tp, std::hash< _Key >, std::equal_to< _Key >, std::allocator< std::pair< const _Key, _Tp > > >
  • and std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >

two parents, main character energy fr fr. 💖

👑 Public Types 👑

these are all just lil aliases pointing back at _Base, and honestly? slay.

  • allocator_type — typedef _Base::allocator_type allocator_type
  • const_iterator — typedef _Base::const_iterator const_iterator
  • const_reference — typedef _Base::const_reference const_reference
  • difference_type — typedef _Base::difference_type difference_type
  • hasher — typedef _Base::hasher hasher
  • iterator — typedef _Base::iterator iterator
  • key_equal — typedef _Base::key_equal key_equal
  • key_type — typedef _Base::key_type key_type
  • reference — typedef _Base::reference reference
  • size_type — typedef _Base::size_type size_type
  • value_type — typedef _Base::value_type value_type

🫶 Public Member Functions 🫶

bestie there are SO many constructors, like this class said "I will have one of everything." obsessed. 😭

  • template<typename _InputIterator > unordered_multimap (_InputIterator __f, _InputIterator __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
  • template<typename _InputIterator > unordered_multimap (_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type &__a)
  • template<typename _InputIterator > unordered_multimap (_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multimap (const _Base &__x)
  • unordered_multimap (const allocator_type &__a)
  • unordered_multimap (const unordered_multimap &)=default
  • unordered_multimap (const unordered_multimap &__ummap, const allocator_type &__a)
  • unordered_multimap (initializer_list< value_type > __l, size_type __n, const allocator_type &__a)
  • unordered_multimap (initializer_list< value_type > __l, size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multimap (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_multimap (size_type __n, const allocator_type &__a)
  • unordered_multimap (size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multimap (size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
  • unordered_multimap (unordered_multimap &&)=default
  • unordered_multimap (unordered_multimap &&__ummap, const allocator_type &__a)
  • void clear () noexcept — just clears it, no cap
  • template<typename... _Args> iterator emplace (_Args &&... __args)
  • template<typename... _Args> iterator emplace_hint (const_iterator __it, _Args &&... __args)
  • template<typename _InputIter > void insert (_InputIter __first, _InputIter __last)
  • template<typename _Pair , typename = typename std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type> iterator insert (_Pair &&__obj)
  • iterator insert (const value_type &__obj)
  • template<typename _Pair , typename = typename std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type> iterator insert (const_iterator __iter, _Pair &&__v)
  • iterator insert (const_iterator __iter, const value_type &__v)
  • void insert (std::initializer_list< value_type > __l)
  • unordered_multimap & operator= (const unordered_multimap &)=default
  • unordered_multimap & operator= (initializer_list< value_type > __l)
  • unordered_multimap & operator= (unordered_multimap &&)=default
  • void rehash (size_type __n)
  • void swap (unordered_multimap &__x) noexcept(noexcept(__x._M_base().swap(__x)))

🧚 Protected Member Functions 🧚

the backstage crew, the ones doing the profiling work behind the scenes. not me knowing all the gossip. 🙈

  • void _M_profile_construct () noexcept
  • void _M_profile_destruct () noexcept
  • void _M_profile_resize (std::size_t __old_size)
  • void _M_swap (_Unordered_profile &__other) noexcept

🎀 Protected Attributes 🎀

two lil pointers, living their best life, holding all the instrumentation tea:

  • __gnu_profile::__hashfunc_info * _M_hashfunc_info
  • __gnu_profile::__container_size_info * _M_size_info

💜 Detailed Description 💜

here's the actual signature bestie:

template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
    typename _Pred = std::equal_to<_Key>, typename _Alloc =
    std::allocator<std::pair<const _Key, _Tp> >>
    class std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred,
    _Alloc >

and the description, word for word: "Class std::unordered_multimap wrapper with performance instrumentation."

Definition at line 329 of file profile/unordered_map. 📍

⭐ Member Typedef Documentation ⭐

okay so this section is just the receipts for every typedef above — same template signature, same alias, plus the exact line it lives on. it's giving meticulous. 🎀

  • allocator_type
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef
    _Base::allocator_type std::__profile::unordered_multimap< _Key, _Tp,
    _Hash, _Pred, _Alloc >::allocator_type
Definition at line 347 of file profile/unordered_map.
  • const_iterator
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef
    _Base::const_iterator std::__profile::unordered_multimap< _Key, _Tp,
    _Hash, _Pred, _Alloc >::const_iterator
Definition at line 355 of file profile/unordered_map.
  • const_reference
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef
    _Base::const_reference std::__profile::unordered_multimap< _Key, _Tp,
    _Hash, _Pred, _Alloc >::const_reference
Definition at line 352 of file profile/unordered_map.
  • difference_type
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef
    _Base::difference_type std::__profile::unordered_multimap< _Key, _Tp,
    _Hash, _Pred, _Alloc >::difference_type
Definition at line 350 of file profile/unordered_map.
  • hasher
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::hasher
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::hasher
Definition at line 345 of file profile/unordered_map.
  • iterator
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::iterator
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::iterator
Definition at line 354 of file profile/unordered_map.
  • key_equal
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::key_equal
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::key_equal
Definition at line 346 of file profile/unordered_map.
  • key_type
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::key_type
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::key_type
Definition at line 348 of file profile/unordered_map.
  • reference
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::reference
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::reference
Definition at line 351 of file profile/unordered_map.
  • size_type
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::size_type
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::size_type
Definition at line 344 of file profile/unordered_map.
  • value_type
template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> typedef _Base::value_type
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::value_type
Definition at line 349 of file profile/unordered_map.

okay bestie we are NOT done yet, there is more of this page coming and you're gonna want to stay for it 💖✨

🎀 Constructor & Destructor Documentation 🎀

okay bestie, gather round 🫶 this is the constructor lineup — and it is thirteen constructors deep, no cap. Every single one is marked [inline], and every single one lives in the exact same spot: profile/unordered_map.

Also, tiny tea ☕: the heading promises "Constructor & Destructor Documentation" but… no destructor pulled up 💀 only constructors here. Which, honestly? Very demure, very mindful of her.

One more heads-up so nothing feels weird: each signature below re-prints the whole template preamble —

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>

— because that's literally how the page lists them, and we do not skip the "boring" bits around here 💅

💖 #1 — the "here's a count" one, and she's [explicit]

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (size_type __n, const hasher & __hf = hasher(),
    const key_equal & __eql = key_equal(), const allocator_type & __a =
    allocator_type()) [inline],  [explicit]

She takes a size_type __n (that one's required, no default, she said what she said), then const hasher & __hf = hasher(), const key_equal & __eql = key_equal(), and const allocator_type & __a = allocator_type() — all three optional, all three with their defaults already filled in. And she's tagged [inline], [explicit] ✨

Definition at line 360 of file profile/unordered_map.

🦋 #2 — the iterator-range one (with a template twist)

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename
    _InputIterator > std::__profile::unordered_multimap< _Key, _Tp, _Hash,
    _Pred, _Alloc >::unordered_multimap (_InputIterator __f, _InputIterator
    __l, size_type __n = 0, const hasher & __hf = hasher(), const key_equal
    & __eql = key_equal(), const allocator_type & __a = allocator_type())
    [inline]

Note the extra template<typename _InputIterator > on top of the usual preamble 👑 She's templated, she's got _InputIterator __f and _InputIterator __l, then size_type __n = 0, const hasher & __hf = hasher(), const key_equal & __eql = key_equal(), const allocator_type & __a = allocator_type(). [inline] only — no [explicit] here.

Definition at line 367 of file profile/unordered_map.

🌸 #3 — the "copy me from a _Base" one

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (const _Base & __x) [inline]

Just one lil param, bestie: const _Base & __x. That's it, that's the whole vibe. [inline] and nothing else.

Definition at line 376 of file profile/unordered_map.

🎀 #4 — the "allocator only" one, also [explicit]

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (const allocator_type & __a) [inline],  [explicit]

One param: const allocator_type & __a. No default this time, she wants you to hand it over. And yes, she's [inline], [explicit] 🫶

Definition at line 382 of file profile/unordered_map.

✨ #5 — copy-construct from another unordered_multimap, plus an allocator

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (const unordered_multimap< _Key, _Tp, _Hash,
    _Pred, _Alloc > & __ummap, const allocator_type & __a) [inline]

She takes a const unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > & __ummap and a const allocator_type & __a. Both required, no defaults. [inline].

Definition at line 385 of file profile/unordered_map.

💜 #6 — move-construct from another unordered_multimap, plus an allocator

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (unordered_multimap< _Key, _Tp, _Hash, _Pred,
    _Alloc > && __ummap, const allocator_type & __a) [inline]

Same energy as #5 but she's got the && on unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > && __ummap 👀 — plus the const allocator_type & __a. [inline].

Definition at line 389 of file profile/unordered_map.

🌈 #7 — the initializer_list one with everything on the side

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (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]

She's got initializer_list< value_type > __l, then size_type __n = 0, const hasher & __hf = hasher(), const key_equal & __eql = key_equal(), const allocator_type & __a = allocator_type(). Full glam, all defaults intact 💅

Definition at line 393 of file profile/unordered_map.

🧚 #8 — count + allocator

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (size_type __n, const allocator_type & __a)
    [inline]

Two params, both required: size_type __n and const allocator_type & __a. No [explicit] on this one, just [inline].

Definition at line 400 of file profile/unordered_map.

🍓 #9 — count + hasher + allocator

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (size_type __n, const hasher & __hf, const
    allocator_type & __a) [inline]

size_type __n, const hasher & __hf, const allocator_type & __a — all three, all with no defaults, all yours to fill in. [inline] only.

Definition at line 404 of file profile/unordered_map.

⭐ #10 — iterator range + count + allocator (templated)

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename
    _InputIterator > std::__profile::unordered_multimap< _Key, _Tp, _Hash,
    _Pred, _Alloc >::unordered_multimap (_InputIterator __first,
    _InputIterator __last, size_type __n, const allocator_type & __a)
    [inline]

Extra template<typename _InputIterator > again, then _InputIterator __first, _InputIterator __last, size_type __n, const allocator_type & __a. No defaults anywhere in sight, so bring all four 🌸

Definition at line 410 of file profile/unordered_map.

🔥 #11 — iterator range + count + hasher + allocator (templated)

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename
    _InputIterator > std::__profile::unordered_multimap< _Key, _Tp, _Hash,
    _Pred, _Alloc >::unordered_multimap (_InputIterator __first,
    _InputIterator __last, size_type __n, const hasher & __hf, const
    allocator_type & __a) [inline]

_InputIterator __first, _InputIterator __last, size_type __n, const hasher & __hf, const allocator_type & __a. Five params, zero defaults, maximum commitment, and I respect it 🫶

Definition at line 417 of file profile/unordered_map.

🎀 #12 — initializer_list + count + allocator

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (initializer_list< value_type > __l, size_type
    __n, const allocator_type & __a) [inline]

initializer_list< value_type > __l, size_type __n, const allocator_type & __a. Three params, none of them get a default. [inline].

Definition at line 423 of file profile/unordered_map.

💖 #13 — initializer_list + count + hasher + allocator (the finale)

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >>
    std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc
    >::unordered_multimap (initializer_list< value_type > __l, size_type
    __n, const hasher & __hf, const allocator_type & __a) [inline]

The last one, bestie, and she's stacked: initializer_list< value_type > __l, size_type __n, const hasher & __hf, const allocator_type & __a. No defaults, all [inline], and that's the whole constructor family tree 🌳✨

Definition at line 429 of file profile/unordered_map.

_M_profile_construct ()</p> ✨

template<typename _UnorderedCont , bool _Unique_keys> void
    std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys
    >::_M_profile_construct () [inline],  [protected],  [noexcept],
    [inherited]

bestie this one is a protected lil helper that's inline, noexcept, and inherited from up the class tree 💅. Definition at line 190 of file unordered_base.h. She's the setup girlie for the profile info 🎀

_M_profile_destruct ()</p> 🌸

template<typename _UnorderedCont , bool _Unique_keys> void
    std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys
    >::_M_profile_destruct () [inline],  [protected],  [noexcept],
    [inherited]

the teardown counterpart, also [inline], [protected], [noexcept], [inherited]. Definition at line 198 of file unordered_base.h. she closes the door behind u, no cap 🫶

_M_profile_resize (std::size_t __old_size)</p> 🦋

template<typename _UnorderedCont , bool _Unique_keys> void
    std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys
    >::_M_profile_resize (std::size_t __old_size) [inline],  [protected],
    [inherited]

takes one arg, __old_size (a std::size_t, the size u used to be 👀). Flags: [inline], [protected], [inherited] — notice there's no [noexcept] on this one, she's got opinions. Definition at line 220 of file unordered_base.h.

_M_swap (_Unordered_profile< _UnorderedCont, _Unique_keys > & __other)</p> 💫

template<typename _UnorderedCont , bool _Unique_keys> void
    std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys
    >::_M_swap (_Unordered_profile< _UnorderedCont, _Unique_keys > &
    __other) [inline],  [protected],  [noexcept],  [inherited]

takes a reference to another _Unordered_profile< _UnorderedCont, _Unique_keys > called __other, and swaps the vibes between them 🔄 [inline], [protected], [noexcept], [inherited]. Definition at line 213 of file unordered_base.h.

clear ()</p> 🧹

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

empties the whole thing out, no args, [inline], [noexcept]. Definition at line 451 of file profile/unordered_map. she's giving clean-girl reset energy ✨

emplace (_Args &&... __args)</p> 💖

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename... _Args>
    iterator std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred,
    _Alloc >::emplace (_Args &&... __args) [inline]

variadic queen 👑 takes a whole pack of _Args &&... __args and hands u back an iterator. [inline]. Definition at line 460 of file profile/unordered_map.

emplace_hint (const_iterator __it, _Args &&... __args)</p> 🎀

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename... _Args>
    iterator std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred,
    _Alloc >::emplace_hint (const_iterator __it, _Args &&... __args)
    [inline]

same emplace energy but u hand her a const_iterator __it as a lil hint first, plus the _Args &&... __args pack. returns an iterator, [inline]. Definition at line 471 of file profile/unordered_map.

insert (_InputIter __first, _InputIter __last)</p> 🌈

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename
    _InputIter > void std::__profile::unordered_multimap< _Key, _Tp, _Hash,
    _Pred, _Alloc >::insert (_InputIter __first, _InputIter __last) [inline]

range insert!! from __first to __last, both _InputIter, returns void. [inline]. Definition at line 532 of file profile/unordered_map.

insert (_Pair && __obj)</p> 🍓

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename _Pair ,
    typename  = typename
    std::enable_if<std::is_constructible<value_type,
    _Pair&&>::value>::type> iterator std::__profile::unordered_multimap<
    _Key, _Tp, _Hash, _Pred, _Alloc >::insert (_Pair && __obj) [inline]

the rvalue-flavored one 🫶 note the sneaky SFINAE guard: typename = typename std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type — she only shows up if _Pair&& can actually build a value_type, iconic gatekeeping tbh. takes _Pair && __obj, returns iterator, [inline]. Definition at line 510 of file profile/unordered_map.

insert (const value_type & __obj)</p> 💜

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

the classic: hand her a const value_type & __obj, get an iterator back. [inline]. Definition at line 489 of file profile/unordered_map. this is the insert u know and love 💅

insert (const_iterator __iter, _Pair && __v)</p> 🧚

template<typename _Key , typename _Tp , typename _Hash  = std::hash<_Key>,
    typename _Pred  = std::equal_to<_Key>, typename _Alloc  =
    std::allocator<std::pair<const _Key, _Tp> >> template<typename _Pair ,
    typename  = typename
    std::enable_if<std::is_constructible<value_type,
    _Pair&&>::value>::type> iterator std::__profile::unordered_multimap<
    _Key, _Tp, _Hash, _Pred, _Alloc >::insert (const_iterator __iter, _Pair
    && __v) [inline]

position + rvalue combo: u give her const_iterator __iter and _Pair && __v, she gives u an iterator. same std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type guard as her sister. [inline]. Definition at line 522 of file profile/unordered_map.

insert (const_iterator __iter, const value_type & __v)</p> ⭐

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

position + const value: const_iterator __iter and const value_type & __v in, iterator out. [inline]. Definition at line 498 of file profile/unordered_map.

insert (std::initializer_list< value_type > __l)</p> 🌸

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

brace-init insert!!! 🎀 takes std::initializer_list< value_type > __l and returns void. [inline]. Definition at line 481 of file profile/unordered_map. put ur { ... } in the chat bestie, she'll take it from there.

operator= (initializer_list< value_type > __l)</p> 👑

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

assignment from a brace list: initializer_list< value_type > __l goes in, and she returns a reference to unordered_multimap & (herself, obvi). [inline]. Definition at line 442 of file profile/unordered_map.

rehash (size_type __n)</p> 🔥

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

takes a size_type __n and returns void. [inline]. Definition at line 548 of file profile/unordered_map. bucket glow-up time ✨

swap (unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > & __x)</p> 💫

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

swaps contents with another unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > & __x, returns void, [inline], [noexcept]. Definition at line 540 of file profile/unordered_map.

🦋 MEMBER DATA DOCUMENTATION 🦋

_M_hashfunc_info</p> 💜

template<typename _UnorderedCont , bool _Unique_keys>
    __gnu_profile::__hashfunc_info* std::__profile::_Unordered_profile<
    _UnorderedCont, _Unique_keys >::_M_hashfunc_info [protected],
    [inherited]

a protected, inherited pointer of type __gnu_profile::__hashfunc_info*. Definition at line 228 of file unordered_base.h.

_M_size_info</p> 🌈

template<typename _UnorderedCont , bool _Unique_keys>
    __gnu_profile::__container_size_info*
    std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys
    >::_M_size_info [protected],  [inherited]

a protected, inherited pointer of type __gnu_profile::__container_size_info*. Definition at line 227 of file unordered_base.h.

🌟 AUTHOR 🌟

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

that's literally the whole author credit bestie, the robots did this one 🤖💅

okay and for the goodbye part 🫶 the footer at the very bottom is the source/version + date line, and it rendered as libstdstd::__profile..._Pred, _Alloc >(3cxx) — yeah the man-page footer got a lil squished, it's giving typo era 😭 but that's the libstdc++ manual (section 3cxx) talking about std::__profile and that _Pred, _Alloc > template crowd. so this page = libstdc++ source, version stamped in that footer, dated whenever Doxygen spat it out. obsessed with her honestly 🎀💖 no cap, go forth and profile ur unordered_multimaps ✨👑

📦 where this page comes from