STD::_DEQUE_BASE(3)

🦋 NAME 🦋

okay bestie, gather round, it's a section 3 Library Functions Manual situation and the star of the show is std::_Deque_base< _Tp, _Alloc > 💖

---

✨ SYNOPSIS ✨

#include <deque>

Inherited by std::deque< _Tp, polymorphic_allocator< _Tp > > [protected], and std::deque< _Tp, _Alloc > [protected].

So yeah, it's the momager of deque — the deque classes inherit from it, but only on the protected side, iykyk 🔥

🎀 Protected Types 🎀

• enum { _S_initial_map_size } — a lil anonymous enum, it's giving "starting map size" energy ✨
• typedef __gnu_cxx::__alloc_traits< _Tp_alloc_type > _Alloc_traits — traits for the element allocator, iconic
• typedef __gnu_cxx::__alloc_traits< _Map_alloc_type > _Map_alloc_traits — same deal but for the map allocator 🗺️
• typedef _Alloc_traits::template rebind< _Ptr >::other _Map_alloc_type — rebinding _Alloc_traits to _Ptr so we get the map allocator type 💅
• typedef iterator::_Map_pointer _Map_pointer — literally just borrowing the pointer type off iterator
• typedef _Alloc_traits::pointer _Ptr — the pointer type, no notes
• typedef _Alloc_traits::const_pointer _Ptr_const — the const pointer type, the responsible sibling 🫶
• typedef __gnu_cxx::__alloc_traits< _Alloc >::template rebind< _Tp >::other _Tp_alloc_type — rebinding your _Alloc to _Tp, so the base can talk about elements ✨
• typedef _Alloc allocator_type — the allocator, but make it official
• typedef _Deque_iterator< _Tp, const _Tp &, _Ptr_const > const_iterator — a const iterator, slay
• typedef _Deque_iterator< _Tp, _Tp &, _Ptr > iterator — a regular iterator, also slay

🧚 Protected Member Functions 🧚

• _Deque_base (_Deque_base &&__x) — move constructor, taking __x 💫
• _Deque_base (_Deque_base &&__x, const allocator_type &__a) — move constructor, but you also hand over an allocator __a
• _Deque_base (_Deque_base &&__x, const allocator_type &__a, size_t __n) — move constructor with an allocator __a and a size __n, main character behavior fr
• _Deque_base (const allocator_type &__a) — constructor from just an allocator __a
• _Deque_base (const allocator_type &__a, size_t __num_elements) — allocator __a plus __num_elements ✨
• _Deque_base (size_t __num_elements) — just a count of elements, that's it, that's the whole vibe
• _Map_pointer _M_allocate_map (size_t __n) — allocates the map, __n of it 🗺️
• _Ptr _M_allocate_node () — allocates a single node, no args, no drama 💅
• void _M_create_nodes (_Map_pointer __nstart, _Map_pointer __nfinish) — builds nodes from __nstart to __nfinish 🔥
• void _M_deallocate_map (_Map_pointer __p, size_t __n) noexcept — frees the map at __p, __n big, and it's noexcept so it will not throw at you 🫶
• void _M_deallocate_node (_Ptr __p) noexcept — frees one node at __p, also noexcept, also unbothered
• void _M_destroy_nodes (_Map_pointer __nstart, _Map_pointer __nfinish) noexcept — destroys nodes __nstart → __nfinish, noexcept ofc 💀
• _Map_alloc_type _M_get_map_allocator () const noexcept — hands you the map allocator, const, noexcept, perfect
• const _Tp_alloc_type & _M_get_Tp_allocator () const noexcept — the const ref flavor of the element allocator getter
• _Tp_alloc_type & _M_get_Tp_allocator () noexcept — the non-const flavor, for when you need to actually touch it 👑
• void _M_initialize_map (size_t) — Layout storage. (more on this queen below ⬇️)
• allocator_type get_allocator () const noexcept — gives you back the allocator, const and noexcept because of course 🌈

🫶 Protected Attributes 🫶

• _Deque_impl _M_impl — the one and only member, the whole implementation living in one lil field 💜

---

👑 Detailed Description 👑

template<typename _Tp, typename _Alloc>
    class std::_Deque_base< _Tp, _Alloc >

okay so this is the Deque base class 🎀

It's the unified face for deque's allocation — like, deque's whole memory situation gets one consistent front-end and this is it.

Its constructor and destructor allocate and deallocate storage, but they do not initialize it. And the reason is honestly so valid: it makes exception safety easier ✨

Now listen, because this part is important: nothing in this class ever constructs or destroys an actual Tp element. Not once. Deque handles that itself, bestie. This class is purely the memory-management department — only/all memory management is performed here. That's the job. That's the whole job 💅

---

💜 Member Function Documentation 💜

_M_initialize_map

template<typename _Tp, typename _Alloc> void std::_Deque_base< _Tp, _Alloc
    >::_M_initialize_map (size_t __num_elements) [protected]

Layout storage. ✨

Parameters

• __num_elements — the count of T's for which to allocate space at first.

The initial underlying memory layout is a bit complicated...

(that's a direct quote, and honestly? it's giving "don't worry about it" 😭)

References std::max().

---

🌸 Author 🌸

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

---

and that's the whole page bestie, no cap — this was std::_Deque_base< _Tp, _Alloc > from the libstdc++ Library Functions Manual (section 3), auto-generated by Doxygen straight from the source code. go forth and manage your memory responsibly, mwah 💋💖🎀