STD::__PROFILE::UNORDERED_MULTISET(3cxx)

📦
version 9.5.0 · 3 versions
, in ubuntu noble

💖 std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc > — manual page (3cxx) 💖

✨ NAME ✨

okay bestie, say hi to std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc > — it's an Unordered_multiset wrapper with performance instrumentation. 💅 That's literally the whole vibe: same multiset energy, but now with receipts. 🧾✨

🌸 SYNOPSIS 🌸

First thing you gotta do, no cap:

#include <unordered_set>

Then the inheritance tea ☕: it inherits from

unordered_multiset< _Value, std::hash< _Value >, std::equal_to< _Value >, std::allocator< _Value > >

and also from

std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >

So it's giving double-inheritance main character energy. 👑

💖 Public Types 💖

These are all the type aliases, and they all come straight from _Base. 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 🔥

Okay this is the long part, but we're not skipping a single one. Not one. 🙅‍♀️

  • template<typename _InputIterator > unordered_multiset (_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_multiset (_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type &__a)
  • template<typename _InputIterator > unordered_multiset (_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multiset (const _Base &__x)
  • unordered_multiset (const allocator_type &__a)
  • unordered_multiset (const unordered_multiset &)=default
  • unordered_multiset (const unordered_multiset &__umset, const allocator_type &__a)
  • unordered_multiset (initializer_list< value_type > __l, size_type __n, const allocator_type &__a)
  • unordered_multiset (initializer_list< value_type > __l, size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multiset (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_multiset (size_type __n, const allocator_type &__a)
  • unordered_multiset (size_type __n, const hasher &__hf, const allocator_type &__a)
  • unordered_multiset (size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
  • unordered_multiset (unordered_multiset &&)=default
  • unordered_multiset (unordered_multiset &&__umset, const allocator_type &__a)
  • void clear () noexcept
  • 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)
  • iterator insert (const value_type &__obj)
  • iterator insert (const_iterator __iter, const value_type &__v)
  • iterator insert (const_iterator __iter, value_type &&__v)
  • void insert (std::initializer_list< value_type > __l)
  • iterator insert (value_type &&__obj)
  • unordered_multiset & operator= (const unordered_multiset &)=default
  • unordered_multiset & operator= (initializer_list< value_type > __l)
  • unordered_multiset & operator= (unordered_multiset &&)=default
  • void rehash (size_type __n)
  • void swap (unordered_multiset &__x) noexcept(noexcept(__x._M_base().swap(__x)))

🫶 Protected Member Functions 🫶

  • 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 👑

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

💅 Detailed Description 💅

okay so template parameters first, bestie:

template<typename _Value, typename _Hash = std::hash<_Value>, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value>>

Then the class itself:

class std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >"Unordered_multiset wrapper with performance instrumentation.
⚠️ not me copying that stray >" exactly because the original says it and we don't edit facts. 🙈

Definition at line 307 of file profile/unordered_set.

🦋 Member Typedef Documentation 🦋

For every single typedef below, the template signature is the same class template:

template<typename _Value , typename _Hash  = std::hash<_Value>, typename _Pred  = std::equal_to<_Value>, typename _Alloc  = std::allocator<_Value>>

Then each typedef has its own documentation and line number. Obsessed with the consistency. 💅

  • allocator_type — typedef _Base::allocator_type; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::allocator_type; Definition at line 325 of file profile/unordered_set.
  • const_iterator — typedef _Base::const_iterator; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_iterator; Definition at line 333 of file profile/unordered_set.
  • const_reference — typedef _Base::const_reference; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_reference; Definition at line 330 of file profile/unordered_set.
  • difference_type — typedef _Base::difference_type; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::difference_type; Definition at line 328 of file profile/unordered_set.
  • hasher — typedef _Base::hasher; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::hasher; Definition at line 323 of file profile/unordered_set.
  • iterator — typedef _Base::iterator; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::iterator; Definition at line 332 of file profile/unordered_set.
  • key_equal — typedef _Base::key_equal; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::key_equal; Definition at line 324 of file profile/unordered_set.
  • key_type — typedef _Base::key_type; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::key_type; Definition at line 326 of file profile/unordered_set.
  • reference — typedef _Base::reference; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::reference; Definition at line 329 of file profile/unordered_set.
  • size_type — typedef _Base::size_type; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::size_type; Definition at line 322 of file profile/unordered_set.
  • value_type — typedef _Base::value_type; std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::value_type; Definition at line 327 of file profile/unordered_set.

🎀 Constructor & Destructor Documentation 🎀

okay bestie, this is the part where you learn all the different ways to summon an unordered_multiset into existence 💖 every single one of these lives on std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>, and yes, every template parameter has a default: _Hash defaults to std::hash<_Value>, _Pred defaults to std::equal_to<_Value>, and _Alloc defaults to std::allocator<_Value> 🌸

🍼 the __n + hasher + key_equal + allocator one

template<typename _Value, typename _Hash = std::hash<_Value>,
         typename _Pred = std::equal_to<_Value>,
         typename _Alloc = std::allocator<_Value>>
std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(size_type __n,
                   const hasher& __hf = hasher(),
                   const key_equal& __eql = key_equal(),
                   const allocator_type& __a = allocator_type())

it's giving build me a bucket situation — you hand it __n, and if you're feeling fancy you also hand it __hf, __eql and __a, all of which have defaults. marked [inline] and [explicit] 🫶

Definition at line 338 of file profile/unordered_set.

🌈 the iterator-range one (with __n defaulting to 0)

template<typename _InputIterator>
std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(_InputIterator __f, _InputIterator __l,
                   size_type __n = 0,
                   const hasher& __hf = hasher(),
                   const key_equal& __eql = key_equal(),
                   const allocator_type& __a = allocator_type())

you've got a range __f → __l, you want it in there. __n defaults to 0, __hf, __eql and __a all default too. [inline] ✨

Definition at line 346 of file profile/unordered_set.

🦋 the _Base one

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(const _Base& __x)

takes a const _Base& named __x. [inline] 💅

Definition at line 356 of file profile/unordered_set.

🧚 the allocator-only one

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(const allocator_type& __a)

just an allocator, nothing else, she's independent like that. [inline], [explicit] 👑

Definition at line 363 of file profile/unordered_set.

💜 the copy-ish one (const ref + allocator)

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __umset,
                   const allocator_type& __a)

you pass a const reference to another unordered_multiset<_Value, _Hash, _Pred, _Alloc> called __umset, plus an allocator __a. [inline] 🌸

Definition at line 367 of file profile/unordered_set.

🔥 the move-ish one (rvalue ref + allocator)

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(unordered_multiset<_Value, _Hash, _Pred, _Alloc>&& __umset,
                   const allocator_type& __a)

same energy as the last one but she's an rvalue reference && — the __umset is getting taken. plus the allocator __a. [inline] 💖

Definition at line 372 of file profile/unordered_set.

🎀 the initializer_list one

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(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())

drop a braced list __l and go. __n defaults to 0, __hf, __eql, __a all have their defaults. [inline] ⭐

Definition at line 377 of file profile/unordered_set.

💫 __n + allocator

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(size_type __n, const allocator_type& __a)

just __n and __a. short and sweet. [inline] 🌸

Definition at line 385 of file profile/unordered_set.

🍓 __n + hasher + allocator

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)

__n, __hf, __a — no key_equal invited to this one. [inline] ✨

Definition at line 389 of file profile/unordered_set.

🌟 iterator range + __n + allocator

template<typename _InputIterator>
std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(_InputIterator __first, _InputIterator __last,
                   size_type __n, const allocator_type& __a)

range __first → __last, plus __n, plus __a. note there's no default on __n here, so you gotta pass it. [inline] 💅

Definition at line 395 of file profile/unordered_set.

🌈 iterator range + __n + hasher + allocator

template<typename _InputIterator>
std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(_InputIterator __first, _InputIterator __last,
                   size_type __n, const hasher& __hf,
                   const allocator_type& __a)

the fullest iterator-range meal deal: __first, __last, __n, __hf, __a. [inline] 🔥

Definition at line 402 of file profile/unordered_set.

🧁 initializer_list + __n + allocator

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(initializer_list<value_type> __l,
                   size_type __n, const allocator_type& __a)

__l, __n, __a. [inline] 🦋

Definition at line 408 of file profile/unordered_set.

👑 initializer_list + __n + hasher + allocator

std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
unordered_multiset(initializer_list<value_type> __l,
                   size_type __n, const hasher& __hf,
                   const allocator_type& __a)

__l, __n, __hf, __a — the whole squad. [inline] 💖

Definition at line 414 of file profile/unordered_set.

🌸 Member Function Documentation 🌸

right, now the methods — the stuff she can actually do. four of these are inherited from std::__profile::_Unordered_profile<_UnorderedCont, _Unique_keys> and live in unordered_base.h, the rest are her own, chilling in profile/unordered_set. let's go 💅

🔒 _M_profile_construct()

template<typename _UnorderedCont, bool _Unique_keys>
void std::__profile::_Unordered_profile<_UnorderedCont, _Unique_keys>::
_M_profile_construct()

[inline], [protected], [noexcept], [inherited] — she's protected so it's an internal bestie, and she literally cannot throw. 🫶

Definition at line 190 of file unordered_base.h.

🔒 _M_profile_destruct()

template<typename _UnorderedCont, bool _Unique_keys>
void std::__profile::_Unordered_profile<_UnorderedCont, _Unique_keys>::
_M_profile_destruct()

[inline], [protected], [noexcept], [inherited] — the cleanup counterpart. no exceptions, no drama. 💀

Definition at line 198 of file unordered_base.h.

🔒 _M_profile_resize(std::size_t __old_size)

template<typename _UnorderedCont, bool _Unique_keys>
void std::__profile::_Unordered_profile<_UnorderedCont, _Unique_keys>::
_M_profile_resize(std::size_t __old_size)

takes a std::size_t __old_size and does the resize bookkeeping. [inline], [protected], [inherited] — note: no noexcept on this one, unlike her siblings. 📏

Definition at line 220 of file unordered_base.h.

🔒 _M_swap(...)

template<typename _UnorderedCont, bool _Unique_keys>
void std::__profile::_Unordered_profile<_UnorderedCont, _Unique_keys>::
_M_swap(_Unordered_profile<_UnorderedCont, _Unique_keys>& __other)

swaps with __other, which is a reference to another _Unordered_profile<_UnorderedCont, _Unique_keys>. [inline], [protected], [noexcept], [inherited] ✨

Definition at line 213 of file unordered_base.h.

🧹 clear()

template<typename _Value, typename _Hash = std::hash<_Value>,
         typename _Pred = std::equal_to<_Value>,
         typename _Alloc = std::allocator<_Value>>
void std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::clear()

bye bye everything inside, [inline], [noexcept] — she will not throw while ghosting all your elements. iconic. 🫧

Definition at line 444 of file profile/unordered_set.

🌱 emplace(_Args&&... __args)

template<typename... _Args>
iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
emplace(_Args&&... __args)

perfect-forwards __args and hands you back an iterator. [inline] — no cap, this is the build-it-in-place queen. 👑

Definition at line 453 of file profile/unordered_set.

🌱 emplace_hint(const_iterator __it, _Args&&... __args)

template<typename... _Args>
iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
emplace_hint(const_iterator __it, _Args&&... __args)

same as emplace but you also pass a const_iterator __it as a hint. returns an iterator. [inline] 💅

Definition at line 463 of file profile/unordered_set.

📥 insert(_InputIter __first, _InputIter __last)

template<typename _InputIter>
void std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(_InputIter __first, _InputIter __last)

iterator-range insert, returns void (no sneaky return value here, bestie). [inline] 🌈

Definition at line 518 of file profile/unordered_set.

📥 insert(const value_type& __obj)

iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(const value_type& __obj)

copies in a const value_type& __obj, hands back an iterator. [inline] 🍓

Definition at line 481 of file profile/unordered_set.

📥 insert(const_iterator __iter, const value_type& __v)

iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(const_iterator __iter, const value_type& __v)

hint-style: const_iterator __iter plus a const value_type& __v, returns iterator. [inline] ✨

Definition at line 490 of file profile/unordered_set.

📥 insert(const_iterator __iter, value_type&& __v)

iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(const_iterator __iter, value_type&& __v)

same hint energy but __v is an rvalue reference value_type&& — she moves. returns iterator. [inline] 🔥

Definition at line 508 of file profile/unordered_set.

📥 insert(std::initializer_list<value_type> __l)

void std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(std::initializer_list<value_type> __l)

braced-list insert, returns void. [inline] 🎀

Definition at line 473 of file profile/unordered_set.

📥 insert(value_type&& __obj)

iterator std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
insert(value_type&& __obj)

the move-y single-element insert: value_type&& __obj in, iterator out. [inline] 🦋

Definition at line 499 of file profile/unordered_set.

🟰 operator=(initializer_list<value_type> __l)

unordered_multiset& std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
operator=(initializer_list<value_type> __l)

assign a whole braced list __l in one go, and she gives you back an unordered_multiset&. [inline] 💖

Definition at line 427 of file profile/unordered_set.

📐 rehash(size_type __n)

void std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
rehash(size_type __n)

takes size_type __n, returns void, rebuilds the bucket situation. [inline] 🧺

Definition at line 526 of file profile/unordered_set.

🔄 swap(unordered_multiset<...>& __x)

void std::__profile::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x)

swaps contents with __x, a reference to another unordered_multiset<_Value, _Hash, _Pred, _Alloc>. [inline], [noexcept] — she will not throw mid-swap, periodt. 👯

Definition at line 436 of file profile/unordered_set.

💖 MEMBER DATA DOCUMENTATION 💖

okay bestie, we're at the data members now — the last little bits of the class, but they're lowkey important. Both of these are protected and [inherited], so they're not for just anyone to touch. 🙈

  • _M_hashfunc_info — a protected, [inherited] data member of std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >. Its type is __gnu_profile::__hashfunc_info*. Definition is at line 228 of unordered_base.h. Here's the exact declaration, no cap:
template<typename _UnorderedCont , bool _Unique_keys>
__gnu_profile::__hashfunc_info* std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >::_M_hashfunc_info [protected], [inherited]
  • _M_size_info — also protected and [inherited], also in std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >. Its type is __gnu_profile::__container_size_info*. Definition is at line 227 of unordered_base.h. Here's the exact declaration:
template<typename _UnorderedCont , bool _Unique_keys>
__gnu_profile::__container_size_info* std::__profile::_Unordered_profile< _UnorderedCont, _Unique_keys >::_M_size_info [protected], [inherited]

That's literally it for the data. ✨

👑 AUTHOR 👑

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

so yeah, no human wrote this, it's a robot. but the robot ate. 💅

and that's the whole page, bestie! this was auto-generated by Doxygen for libstdc++, and the date is just whatever Doxygen stamped on it when it ran. no cap, you're now fully caught up on std::__profile::_Unordered_profile. slay. 💖✨🦋

📦 where this page comes from