STD::__DEBUG::MULTIMAP(3)

🌸 std::__debug::multimap< _Key, _Tp, _Compare, _Allocator > 🌸

okay bestie, welcome to the debug version of std::multimap 💖 this is a 3 manual page, straight out of the libstdc++ Library Functions Manual, so grab a boba and let's get into it ✨

---

✨ NAME ✨

std::__debug::multimap< _Key, _Tp, _Compare, _Allocator > — it's a Class, and it's literally std::multimap but with safety/checking/debug instrumentation. like, the same multimap but it's wearing a little reflective vest and checking everything 🦋

---

🎀 SYNOPSIS 🎀

#include <map>

Inherits __gnu_debug::_Safe_container< _SafeContainer, _Alloc, _SafeBase, _IsCxx11AllocatorAware >. yep, it's giving "I inherited my whole personality from my safe container parent" 💅

👑 Public Types 👑

• allocator_type — typedef _Allocator allocator_type, the allocator, periodt.
• const_iterator — typedef __gnu_debug::_Safe_iterator< _Base_const_iterator, multimap > const_iterator, a safe const iterator, no cap.
• const_pointer — typedef _Base::const_pointer const_pointer
• const_reference — typedef _Base::const_reference const_reference
• const_reverse_iterator — typedef std::reverse_iterator< const_iterator > const_reverse_iterator
• difference_type — typedef _Base::difference_type difference_type
• iterator — typedef __gnu_debug::_Safe_iterator< _Base_iterator, multimap > iterator, the safe iterator bestie 🫶
• key_compare — typedef _Compare key_compare
• key_type — typedef _Key key_type
• mapped_type — typedef _Tp mapped_type
• pointer — typedef _Base::pointer pointer
• reference — typedef _Base::reference reference
• reverse_iterator — typedef std::reverse_iterator< iterator > reverse_iterator
• size_type — typedef _Base::size_type size_type
• value_type — typedef std::pair< const _Key, _Tp > value_type

---

💜 Public Member Functions 💜

the way there are SO many of these and every single one is iconic, let's go 🌈

• multimap (_Base_ref __x) — constructs from a base reference.
• template<typename _InputIterator> multimap (_InputIterator __first, _InputIterator __last, const _Compare &__comp=_Compare(), const _Allocator &__a=_Allocator()) — builds from the range __first to __last, with optional comparator __comp and allocator __a.
• template<typename _InputIterator> multimap (_InputIterator __first, _InputIterator __last, const allocator_type &__a) — range constructor, but with just the allocator __a.
• multimap (const _Compare &__comp, const _Allocator &__a=_Allocator()) — takes a comparator __comp and optionally an allocator __a.
• multimap (const allocator_type &__a) — just an allocator, that's it, slay.
• multimap (const multimap &)=default — copy constructor, defaulted, lowkey perfect.
• multimap (const multimap &__m, const __type_identity_t< allocator_type > &__a) — copy __m but rebuild it with allocator __a.
• multimap (initializer_list< value_type > __l, const _Compare &__c=_Compare(), const allocator_type &__a=allocator_type()) — from an initializer_list __l, optional comparator __c and allocator __a.
• multimap (initializer_list< value_type > __l, const allocator_type &__a) — initializer list __l plus allocator __a.
• multimap (multimap &&)=default — move constructor, defaulted.
• multimap (multimap &&__m, const __type_identity_t< allocator_type > &__a) noexcept(noexcept(_Base(std::move(__m), __a))) — move __m into a new allocator __a, with that whole conditional noexcept situation.
• const _Base & _M_base () const noexcept — hands you the underlying base, const edition.
• _Base & _M_base () noexcept — same but non-const, get in.
• const_iterator begin () const noexcept — start of the const range.
• iterator begin () noexcept — start of the range.
• const_iterator cbegin () const noexcept — const begin, the c stands for cute 💖
• const_iterator cend () const noexcept — const end.
• void clear () noexcept — yeets everything out of the container.
• const_reverse_iterator crbegin () const noexcept — const reverse begin.
• const_reverse_iterator crend () const noexcept — const reverse end.
• template<typename... _Args> iterator emplace (_Args &&... __args) — constructs in place from __args, no copies.
• template<typename... _Args> iterator emplace_hint (const_iterator __pos, _Args &&... __args) — same but with a hint __pos about where it should go.
• const_iterator end () const noexcept — end of the const range.
• iterator end () noexcept — end of the range.
• std::pair< iterator, iterator > equal_range (const key_type &__x) — the pair of iterators covering every element with key __x.
• std::pair< const_iterator, const_iterator > equal_range (const key_type &__x) const — same but const, same key __x.
• _Base_iterator erase (_Base_const_iterator __position) — erases at __position, gives back a _Base_iterator.
• template<__heterogeneous_tree_key< multimap > _Kt> size_type erase (_Kt &&__x) — heterogeneous erase by key __x, returns how many went bye-bye.
• size_type erase (const key_type &__x) — erase by key __x, returns the count removed.
• iterator erase (const_iterator __first, const_iterator __last) — erases the whole range from __first to __last.
• iterator erase (const_iterator __position) — erases the const iterator at __position.
• iterator erase (iterator __position) — erases the iterator at __position.
• iterator find (const key_type &__x) — finds key __x.
• const_iterator find (const key_type &__x) const — const find for key __x.
• template<typename _InputIterator> void insert (_InputIterator __first, _InputIterator __last) — inserts the range __first to __last.
• template<typename _Pair, typename = typename std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type> iterator insert (_Pair &&__x) — inserts __x, but only if _Pair is actually constructible into a value_type, tyvm SFINAE 💅
• iterator insert (const value_type &__x) — inserts __x by const reference.
• template<typename _Pair, typename = typename std::enable_if<std::is_constructible<value_type, _Pair&&>::value>::type> iterator insert (const_iterator __position, _Pair &&__x) — hinted insert of __x at __position, same enable_if gate.
• iterator insert (const_iterator __position, const value_type &__x) — hinted insert of __x at __position.
• iterator insert (const_iterator __position, value_type &&__x) — hinted insert, but __x gets moved.
• void insert (std::initializer_list< value_type > __list) — inserts everything in __list.
• iterator insert (value_type &&__x) — move-inserts __x.
• iterator lower_bound (const key_type &__x) — first element not less than __x.
• const_iterator lower_bound (const key_type &__x) const — const lower bound for __x.
• multimap & operator= (const multimap &)=default — copy assignment, defaulted.
• multimap & operator= (initializer_list< value_type > __l) — assigns from initializer_list __l.
• multimap & operator= (multimap &&)=default — move assignment, defaulted.
• const_reverse_iterator rbegin () const noexcept — reverse begin, const.
• reverse_iterator rbegin () noexcept — reverse begin.
• const_reverse_iterator rend () const noexcept — reverse end, const.
• reverse_iterator rend () noexcept — reverse end.
• void swap (multimap &__x) noexcept(/*conditional */) — swaps with __x, and the noexcept is, and I quote, /*conditional */ 😭
• iterator upper_bound (const key_type &__x) — first element greater than __x.
• const_iterator upper_bound (const key_type &__x) const — const upper bound for __x.

---

🧚 Protected Member Functions 🧚

• constexpr void _M_swap (const _Safe_container &__x) const noexcept — protected, constexpr, noexcept, swaps with the _Safe_container __x. it's giving "for my eyes only" 🙈

---

🦋 Friends 🦋

• template<typename _ItT, typename _SeqT, typename _CatT> class ::__gnu_debug::_Safe_iterator — yes, _Safe_iterator is a friend, iykyk 🤝

---

⭐ Detailed Description ⭐

template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
    typename _Allocator = std::allocator<std::pair<const _Key, _Tp> >>
class std::__debug::multimap< _Key, _Tp, _Compare, _Allocator >"Class
std::multimap with safety/checking/debug instrumentation.

that's the whole template signature, exactly as it is — four template params, _Compare defaults to std::less<_Key>, _Allocator defaults to std::allocator<std::pair<const _Key, _Tp> >. and the description is literally "Class std::multimap with safety/checking/debug instrumentation." short, sweet, did not need to do all that but it did 💀

ngl there's a stray quote mark in that description in the original and I am simply preserving it, bestie. character for character. we do not "fix" things here ✨

---

💌 Author 💌

Generated automatically by Doxygen for libstdc++ from the source code. not a human author, just Doxygen doing its little thing 🤖

---

and that's the whole page, bestie 🫶 this was std::__debug::multimap< _Key, _Tp, _Compare, _Allocator >(3), from the libstdc++ Library Functions Manual. go forth and debug safely, mwah 💅✨