STD::__DEBUG::UNORDERED_SET(3)

✨ NAME ✨

okay so bestie, meet std::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc > — it's a Class std::unordered_set with safety/checking/debug instrumentation. yes literally the same set you know and love but wearing a hi-vis vest 💅

this is a Library Functions Manual page from libstdc++, so buckle up 🎀

---

🌸 SYNOPSIS 🌸

#include <unordered_set>

Inherits __gnu_debug::_Safe_container< _SafeContainer, _Alloc, _SafeBase, _IsCxx11AllocatorAware >. yes it's got a whole family tree, main character energy fr fr 👑

💖 Public Types

• typedef _Base::allocator_type allocator_type — the allocator type, straight from _Base
• typedef __gnu_debug::_Safe_iterator< _Base_const_iterator, unordered_set > const_iterator — const iterator, but make it safe (it's a _Safe_iterator bestie)
• typedef __gnu_debug::_Safe_local_iterator< _Base_const_local_iterator, unordered_set > const_local_iterator — const local iterator, also safety-instrumented, _Safe_local_iterator coded
• typedef _Base::const_pointer const_pointer — const pointer, from _Base
• typedef _Base::const_reference const_reference — const reference, from _Base
• typedef _Base::difference_type difference_type — difference type, from _Base
• typedef _Base::hasher hasher — the hasher type
• typedef __gnu_debug::_Safe_iterator< _Base_iterator, unordered_set > iterator — the iterator, and yes it's a _Safe_iterator so it's checking on you 👀
• typedef _Base::key_equal key_equal — key equality predicate type
• typedef _Base::key_type key_type — key type
• typedef __gnu_debug::_Safe_local_iterator< _Base_local_iterator, unordered_set > local_iterator — local iterator, _Safe_local_iterator flavored
• typedef _Base::pointer pointer — pointer
• typedef _Base::reference reference — reference
• typedef _Base::size_type size_type — size type
• typedef _Base::value_type value_type — value type

🦋 Public Member Functions

the constructor lineup is honestly giving runway show, there's one for every occasion:

• unordered_set (_Base_ref __x) — builds from a _Base_ref
• template<typename _InputIterator> unordered_set (_InputIterator __first, _InputIterator __last, const allocator_type &__a) — range + allocator
• template<typename _InputIterator> unordered_set (_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type &__a) — range + bucket count + allocator
• template<typename _InputIterator> unordered_set (_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a) — range + bucket count + hasher + allocator
• template<typename _InputIterator> unordered_set (_InputIterator __first, _InputIterator __last, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type()) — the full range version, all defaults baked in
• unordered_set (const allocator_type &__a) — just an allocator
• unordered_set (const unordered_set &)=default — copy ctor, defaulted, iconic
• unordered_set (const unordered_set &__uset, const allocator_type &__a) — copy + allocator
• unordered_set (initializer_list< value_type > __l, const allocator_type &__a) — init list + allocator
• unordered_set (initializer_list< value_type > __l, size_type __n, const allocator_type &__a) — init list + bucket count + allocator
• unordered_set (initializer_list< value_type > __l, size_type __n, const hasher &__hf, const allocator_type &__a) — init list + bucket count + hasher + allocator
• unordered_set (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()) — init list, everything defaulted
• unordered_set (size_type __n, const allocator_type &__a) — bucket count + allocator
• unordered_set (size_type __n, const hasher &__hf, const allocator_type &__a) — bucket count + hasher + allocator
• unordered_set (size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type()) — bucket count with the full default squad
• unordered_set (unordered_set &&)=default — move ctor, defaulted, we love a clean handoff 💅
• unordered_set (unordered_set &&__uset, const allocator_type &__a) noexcept(noexcept(_Base(std::move(__uset), __a))) — move + allocator, with that exact noexcept spec, no cap

then the actual moves:

• const _Base & _M_base () const noexcept — grab the const _Base underneath, noexcept
• _Base & _M_base () noexcept — grab the non-const _Base, also noexcept
• const_iterator begin () const noexcept — start of the const iterator run
• iterator begin () noexcept — start of the iterator run
• local_iterator begin (size_type __b) — start of bucket __b
• const_local_iterator begin (size_type __b) const — const start of bucket __b
• size_type bucket_size (size_type __b) const — how many things are chilling in bucket __b
• const_iterator cbegin () const noexcept — const begin, noexcept
• const_local_iterator cbegin (size_type __b) const — const start of bucket __b
• const_iterator cend () const noexcept — const end, noexcept
• const_local_iterator cend (size_type __b) const — const end of bucket __b
• void clear () noexcept — wipe it, noexcept
• template<typename... _Args> std::pair< iterator, bool > emplace (_Args &&... __args) — construct in place, hands back the iterator plus a bool
• template<typename... _Args> iterator emplace_hint (const_iterator __hint, _Args &&... __args) — in-place construct with a hint, returns an iterator
• const_iterator end () const noexcept — end of the const run, noexcept
• iterator end () noexcept — end of the run, noexcept
• local_iterator end (size_type __b) — end of bucket __b
• const_local_iterator end (size_type __b) const — const end of bucket __b
• std::pair< iterator, iterator > equal_range (const key_type &__key) — the range matching __key
• std::pair< const_iterator, const_iterator > equal_range (const key_type &__key) const — const version of the same
• _Base_iterator erase (_Base_const_iterator __it) — erase by _Base_const_iterator, returns a _Base_iterator
• template<__heterogeneous_hash_key< unordered_set > _Kt> size_type erase (_Kt &&__key) — heterogeneous erase, gives you a size_type
• size_type erase (const key_type &__key) — erase by key, gives you a size_type
• iterator erase (const_iterator __first, const_iterator __last) — erase a whole [__first, __last) range
• iterator erase (const_iterator __it) — erase one const iterator
• iterator erase (iterator __it) — erase one iterator
• iterator find (const key_type &__key) — go find __key
• const_iterator find (const key_type &__key) const — const find
• template<typename _InputIterator> void insert (_InputIterator __first, _InputIterator __last) — insert a range, returns void
• template<__heterogeneous_hash_key< unordered_set > _Kt> std::pair< iterator, bool > insert (_Kt &&__obj) — heterogeneous insert → std::pair< iterator, bool >
• std::pair< iterator, bool > insert (const value_type &__obj) — insert a const value → std::pair< iterator, bool >
• template<__heterogeneous_hash_key< unordered_set > _Kt> iterator insert (const_iterator __hint, _Kt &&__obj) — heterogeneous insert with a hint
• iterator insert (const_iterator __hint, const value_type &__obj) — insert with a hint, const value
• iterator insert (const_iterator __hint, value_type &&__obj) — insert with a hint, rvalue value
• void insert (std::initializer_list< value_type > __l) — dump a whole init list in, returns void
• std::pair< iterator, bool > insert (value_type &&__obj) — insert an rvalue → std::pair< iterator, bool >
• float max_load_factor () const noexcept — read the max load factor, a float, noexcept
• void max_load_factor (float __f) — set the max load factor to __f
• unordered_set & operator= (const unordered_set &)=default — copy assign, defaulted
• unordered_set & operator= (initializer_list< value_type > __l) — assign from an init list
• unordered_set & operator= (unordered_set &&)=default — move assign, defaulted
• void swap (unordered_set &__x) noexcept(noexcept(declval< _Base & >().swap(__x))) — swap with __x, with that exact noexcept spec

🌈 Protected Member Functions

• constexpr void _M_swap (const _Safe_container &__x) const noexcept — the internal swap, constexpr, const, noexcept, protected. she's shy but powerful 💜

🫶 Friends

• template<typename _ItT, typename _SeqT, typename _CatT> class ::__gnu_debug::_Safe_iterator — friend class
• template<typename _ItT, typename _SeqT> class ::__gnu_debug::_Safe_local_iterator — friend class

---

💖 Detailed Description 💖

the full tea, template signature and all:

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

and the class describes itself as:

"Class std::unordered_set with safety/checking/debug instrumentation.

so yeah — same unordered_set, extra checking, extra safety, extra debug. it's the version that actually notices when you do something unhinged 🙈

---

👑 Author

Generated automatically by Doxygen for libstdc++ from the source code. (not a human author bestie, it's a robot that read the source so you don't have to 🤖✨)

---

and that's the whole page!! this came from libstdc++, manual page for std::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc > in section 3, and it's the debug/safety-instrumented one — so if you're out here with unchecked iterators, that's giving undefined behaviour and this class is literally the vibe check for that 💀 slay responsibly, periodt 🎀💖