STD::UNORDERED_MULTISET(3cxx)
💅 std::unordered_multiset< _Value, _Hash, _Pred, _Alloc > 💅
okay so this is the (3cxx) manual page for std::unordered_multiset< _Value, _Hash, _Pred, _Alloc > — yes that's a whole mouthful of template parameters, no we're not scared of it, and yes we're gonna get through all six parts together bestie 🫶
✨ NAME ✨
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc > — it's a standard container, and here's the whole vibe: it's made of equivalent keys, meaning it can literally hold multiple copies of each key value (yes, like, a whole little clique of identical keys, iconic behavior honestly 🎀).
And the twist that makes it this container specifically? The elements' keys are the elements themselves. The key isn't chilling off to the side somewhere — the value is the key. main character energy, no cap 👑
✨ SYNOPSIS ✨
ok so before literally anything else, you gotta pull the header in or nothing works:
#include <unordered_set>🦋 Public Types 🦋
these are the little name tags every type in here wears so you don't have to spell out _Hashtable every five seconds, iykyk 💅
using node_type = typename _Hashtable::node_type— the node-handle type, for all your extract-and-reinsert main character moments 👑
then the plain old public typedefs — every single one, no skipping:
typedef _Hashtable::key_type key_type— public typedef 🫶typedef _Hashtable::value_type value_type— public typedef 🫶typedef _Hashtable::hasher hasher— public typedef 🫶typedef _Hashtable::key_equal key_equal— public typedef 🫶typedef _Hashtable::allocator_type allocator_type— public typedef 🫶
and now the iterator-related typedefs, aka the whole squad 🎀:
typedef _Hashtable::pointer pointer— iterator-related typedeftypedef _Hashtable::const_pointer const_pointer— iterator-related typedeftypedef _Hashtable::reference reference— iterator-related typedeftypedef _Hashtable::const_reference const_reference— iterator-related typedeftypedef _Hashtable::iterator iterator— iterator-related typedeftypedef _Hashtable::const_iterator const_iterator— iterator-related typedeftypedef _Hashtable::local_iterator local_iterator— iterator-related typedeftypedef _Hashtable::const_local_iterator const_local_iterator— iterator-related typedeftypedef _Hashtable::size_type size_type— iterator-related typedeftypedef _Hashtable::difference_type difference_type— iterator-related typedef
💖 Public Member Functions 💖
constructor szn, let's go 🏁
unordered_multiset() = default— the default constructor, does exactly what it says on the tin ✨template<typename _InputIterator > unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type &__a)— range constructor, allocator editiontemplate<typename _InputIterator > unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const hasher &__hf, const allocator_type &__a)— range constructor but you also hand it a hashertemplate<typename _InputIterator > unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())— builds anunordered_multisetfrom a range, with all the defaults pre-loaded, slay 🫶unordered_multiset(const allocator_type &__a)— creates anunordered_multisetwith no elements, yes it's empty on purpose, that's the vibeunordered_multiset(const unordered_multiset &) = default— copy constructor, iconic copy-paste energy 🎀unordered_multiset(const unordered_multiset &__umset, const allocator_type &__a)— copy it, but with your own allocatorunordered_multiset(initializer_list<value_type> __l, size_type __n, const allocator_type &__a)— initializer_list constructor, allocator editionunordered_multiset(initializer_list<value_type> __l, size_type __n, const hasher &__hf, const allocator_type &__a)— initializer_list plus a hasher plus an allocatorunordered_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())— builds anunordered_multisetfrom aninitializer_list, defaults and all 💜unordered_multiset(size_type __n, const allocator_type &__a)— bucket-count constructor with allocatorunordered_multiset(size_type __n, const hasher &__hf, const allocator_type &__a)— bucket-count constructor with hasher and allocatorunordered_multiset(size_type __n, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())— default constructor that creates no elements, like, zero, nada, empty bestieunordered_multiset(unordered_multiset &&) = default— move constructor, zoom zoom 🦋unordered_multiset(unordered_multiset &&__umset, const allocator_type &__a) noexcept(noexcept(_Hashtable(std::move(__umset._M_h), __a)))— move constructor with an allocator, and yes that wholenoexceptsandwich is part of the deal
then the bucket-y ones 🪣
size_type bucket(const key_type &__key) const— tells you which bucket a key lands insize_type bucket_count() const noexcept— returns the number of buckets of theunordered_multisetsize_type bucket_size(size_type __n) const— how big is bucket number__n, bestie
iterators and clearing 🌈
const_iterator cbegin() const noexcept— const iterator to the startconst_iterator cend() const noexcept— const iterator to the endvoid clear() noexcept— wipes it clean 😭
inserting & friends ✨
template<typename... _Args> iterator emplace(_Args &&... __args)— builds and insert an element into theunordered_multiset, no captemplate<typename... _Args> iterator emplace_hint(const_iterator __pos, _Args &&... __args)— inserts an element into theunordered_multiset, with a hint about wherebool empty() const noexcept— returnstrueif theunordered_multisetis empty 🫥size_type erase(const key_type &__x)— erases elements according to the provided key, bye booiterator erase(const_iterator __first, const_iterator __last)— erases a[__first,__last)range of elements from anunordered_multisetnode_type extract(const key_type &__key)— extract a node 🔑node_type extract(const_iterator __pos)— extract a node, position edition 🔑allocator_type get_allocator() const noexcept— returns the allocator object used by theunordered_multisethasher hash_function() const— returns the hash functor object with which theunordered_multisetwas constructedtemplate<typename _InputIterator > void insert(_InputIterator __first, _InputIterator __last)— a template function that inserts a range of elements 💫iterator insert(const_iterator __hint, node_type &&__nh)— re-insert an extracted node, with a hintvoid insert(initializer_list<value_type> __l)— inserts a list of elements into theunordered_multisetiterator insert(node_type &&__nh)— re-insert an extracted node, no hint neededkey_equal key_eq() const— returns the key comparison object with which theunordered_multisetwas constructed
load factor & capacity stuff 🔥
float load_factor() const noexcept— returns the average number of elements per bucketsize_type max_bucket_count() const noexcept— returns the maximum number of buckets of theunordered_multisetfloat max_load_factor() const noexcept— returns a positive number that theunordered_multisettries to keep the load factor less than or equal tovoid max_load_factor(float __z)— change theunordered_multisetmaximum load factorsize_type max_size() const noexcept— returns the maximum size of theunordered_multiset
merge, and yes there's a whole set of them 👯
template<typename _H2 , typename _P2 > void merge(unordered_multiset< _Value, _H2, _P2, _Alloc > &&__source)— merge from an rvalueunordered_multisettemplate<typename _H2 , typename _P2 > void merge(unordered_multiset< _Value, _H2, _P2, _Alloc > &__source)— merge from an lvalueunordered_multisettemplate<typename _H2 , typename _P2 > void merge(unordered_set< _Value, _H2, _P2, _Alloc > &&__source)— merge from an rvalueunordered_settemplate<typename _H2 , typename _P2 > void merge(unordered_set< _Value, _H2, _P2, _Alloc > &__source)— merge from an lvalueunordered_set
assignment, rehash, reserve, size, swap 🎀
unordered_multiset & operator= (const unordered_multiset &)=default— copy assignment operatorunordered_multiset & operator= (initializer_list<value_type> __l)—unordered_multisetlist assignment operatorunordered_multiset & operator= (unordered_multiset &&)=default— move assignment operator, swoosh 🦋void rehash(size_type __n)— may rehash theunordered_multisetvoid reserve(size_type __n)— prepare theunordered_multisetfor a specified number of elementssize_type size() const noexcept— returns the size of theunordered_multisetvoid swap(unordered_multiset &__x) noexcept(noexcept(_M_h.swap(__x._M_h)))— swaps data with anotherunordered_multiset,noexceptincantation included and everything
ok and then there's this whole crew below, still under the member-function umbrella, don't skip 'em 👑
iterator begin() noexcept— begin, non-constconst_iterator begin() const noexcept— begin, constiterator end() noexcept— end, non-constconst_iterator end() const noexcept— end, const 🌸iterator insert(const value_type &__x)— inserts an element into theunordered_multisetiterator insert(value_type &&__x)— inserts an element into theunordered_multisetiterator insert(const_iterator __hint, const value_type &__x)— inserts an element into theunordered_multiset, hint firstiterator insert(const_iterator __hint, value_type &&__x)— inserts an element into theunordered_multiset, hint first, rvalue seconditerator erase(const_iterator __position)— erases an element from anunordered_multisetiterator erase(iterator __position)— erases an element from anunordered_multisetiterator find(const key_type &__x)— tries to locate an element in anunordered_multiset🔍template<typename _Kt > auto find(const _Kt &__x) -> decltype(_M_h._M_find_tr(__x))— tries to locate an element in anunordered_multiset, transparentlyconst_iterator find(const key_type &__x) const— tries to locate an element in anunordered_multiset, consttemplate<typename _Kt > auto find(const _Kt &__x) const -> decltype(_M_h._M_find_tr(__x))— tries to locate an element in anunordered_multiset, const and transparentsize_type count(const key_type &__x) const— finds the number of elements 🔢template<typename _Kt > auto count(const _Kt &__x) const -> decltype(_M_h._M_count_tr(__x))— finds the number of elements, transparentlybool contains(const key_type &__x) const— finds whether an element with the given key exists ✅template<typename _Kt > auto contains(const _Kt &__x) const -> decltype(_M_h._M_find_tr(__x), void(), true)— finds whether an element with the given key exists, transparentlystd::pair< iterator, iterator > equal_range(const key_type &__x)— finds a subsequence matching given keytemplate<typename _Kt > auto equal_range(const _Kt &__x) -> decltype(_M_h._M_equal_range_tr(__x))— finds a subsequence matching given key, transparentlystd::pair< const_iterator, const_iterator > equal_range(const key_type &__x) const— finds a subsequence matching given key, consttemplate<typename _Kt > auto equal_range(const _Kt &__x) const -> decltype(_M_h._M_equal_range_tr(__x))— finds a subsequence matching given key, const and transparentlocal_iterator begin(size_type __n)— returns a read-only (constant) iterator pointing to the first bucket element 🪣const_local_iterator begin(size_type __n) const— returns a read-only (constant) iterator pointing to the first bucket elementconst_local_iterator cbegin(size_type __n) const— returns a read-only (constant) iterator pointing to the first bucket elementlocal_iterator end(size_type __n)— returns a read-only (constant) iterator pointing to one past the last bucket elementsconst_local_iterator end(size_type __n) const— returns a read-only (constant) iterator pointing to one past the last bucket elementsconst_local_iterator cend(size_type __n) const— returns a read-only (constant) iterator pointing to one past the last bucket elements
🫶 Friends 🫶
the friends list, literally, and you're on it bestie 🎀
template<typename _Value1 , typename _Hash1 , typename _Pred1 , typename _Alloc1 > bool operator==(const unordered_multiset< _Value1, _Hash1, _Pred1, _Alloc1 > &, const unordered_multiset< _Value1, _Hash1, _Pred1, _Alloc1 > &)— the equality comparison, templated to the maxtemplate<typename , typename , typename > class std::_Hash_merge_helper— the merge helper, doing the behind-the-scenes work for all thosemergeoverloads 👑
💖 Detailed Description 💖
okay so picture this: a container that's literally just keys, and the keys are the elements. that's the whole vibe. and bestie — it's a multiset, so it's not gonna gatekeep: equivalent keys can show up more than once. no "sorry, already have that one" energy. it's giving generous. it's giving abundance mindset ✨
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
class std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Since: C++11 — yeah she's a modern girl, she did not exist in the olden times 🫶
🌸 Template Parameters 🌸
_Value— the type of the key objects. the main character, truly 👑_Hash— the hashing function object type. defaults tohash<_Value>. this is the girl who decides which bucket you end up in 💅_Pred— the predicate function object type. defaults toequal_to<_Value>. she's the one asking "are you two, like, the same?" 🎀_Alloc— the allocator type. defaults toallocator<_Key>. (yes, the page really does say_Keythere and not_Value— we're reporting, not editing 🙈)
🦋 Requirements Check 🦋
this one meets the requirements of a container, and of an unordered associative container. vibe check: passed, no notes 👑
⭐ Under The Hood ⭐
base is _Hashtable, dispatched at compile time via the template alias __umset_hashtable. that's it, that's the machinery. iykyk 🧚
🎀 Member Typedef Documentation 🎀
so every single one of these is a typedef pulled off _Hashtable, and the template header on top of all of them is always:
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>now let's go through the whole roster, no skipping, we are thorough in this house 💅
🫶 Public Typedefs 🫶
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::allocator_type— typedef of_Hashtable::allocator_typestd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::hasher— typedef of_Hashtable::hasherstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::key_equal— typedef of_Hashtable::key_equalstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::key_type— typedef of_Hashtable::key_typestd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::value_type— typedef of_Hashtable::value_type
🦋 Iterator-Related Typedefs 🦋
okay this group is long, brace yourself bestie 😭
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_iterator— typedef of_Hashtable::const_iteratorstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_local_iterator— typedef of_Hashtable::const_local_iteratorstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_pointer— typedef of_Hashtable::const_pointerstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::const_reference— typedef of_Hashtable::const_referencestd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::difference_type— typedef of_Hashtable::difference_typestd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::iterator— typedef of_Hashtable::iteratorstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::local_iterator— typedef of_Hashtable::local_iteratorstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::pointer— typedef of_Hashtable::pointerstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::reference— typedef of_Hashtable::referencestd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::size_type— typedef of_Hashtable::size_type
that's 15 typedefs total btw, five public and ten iterator-related. we counted. we do not mess around 🍓
✨ Constructor & Destructor Documentation ✨
🎀 unordered_multiset() — the default one 🎀
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::unordered_multiset () [default]Default constructor. that's the whole description, she's lowkey mysterious, we love that for her 💅
🦋 the bucket-count one 🦋
std::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()) [inline], [explicit]"Default constructor creates no elements." — yes, that's literally what the page says about this one. so: no elements, zero, empty, ghost town on purpose 👻
Parameters:
__n— minimal initial number of buckets 🪣__hf— a hash functor__eql— a key equality functor__a— an allocator object
🌈 the range one 🌈
template<typename _InputIterator >
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::unordered_multiset (_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher & __hf = hasher(), const key_equal & __eql = key_equal(), const allocator_type & __a = allocator_type()) [inline]Builds an unordered_multiset from a range. love a container that comes pre-loaded 🫶
Parameters:
__first— an input iterator__last— an input iterator__n— minimal initial number of buckets 🪣__hf— a hash functor__eql— a key equality functor__a— an allocator object
Create an unordered_multiset consisting of copies of the elements from [__first,__last). this is linear in N, where N is distance(__first,__last). iconic, efficient, no cap 🔥
💜 the copy constructor 💜
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::unordered_multiset (const unordered_multiset< _Value, _Hash, _Pred, _Alloc > &) [default]Copy constructor. twin behaviour, literally identical 💖
✨ the move constructor ✨
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::unordered_multiset (unordered_multiset< _Value, _Hash, _Pred, _Alloc > &&) [default]Move constructor. she's not copying, she's relocating. main character energy 💅
🍓 the initializer_list one 🍓
std::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()) [inline]Builds an unordered_multiset from an initializer_list. the curly-brace girlies are eating today 🎀
Parameters:
__l— aninitializer_list__n— minimal initial number of buckets 🪣__hf— a hash functor__eql— a key equality functor__a— an allocator object
Create an unordered_multiset consisting of copies of the elements in the list. this is linear in N, where N is __l.size(). slay 🌸
👑 the allocator-only one 👑
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::unordered_multiset (const allocator_type & __a) [inline], [explicit]Creates an unordered_multiset with no elements. she's empty but she's custom-allocated empty, and that's a flex 💅
Parameters:
__a— an allocator object
🔥 Member Function Documentation 🔥
🦋 begin() const — read-only era 🦋
const_iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::begin () const [inline], [noexcept]Returns a read-only (constant) iterator that points to the first element in the unordered_multiset. ✨
🎀 begin() — the non-const twin 🎀
iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::begin () [inline], [noexcept]Returns a read-only (constant) iterator that points to the first element in the unordered_multiset. and yes bestie, the page says "read-only (constant)" for the non-const overload too — we are quoting, we are not editorializing 🙈
🌸 begin(size_type __n) — bucket edition 🌸
local_iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::begin (size_type __n) [inline]Returns a read-only (constant) iterator pointing to the first bucket element.
Parameters:
__n— the bucket index 🪣
Returns: a read-only local iterator 💜
💖 begin(size_type __n) const 💖
const_local_iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::begin (size_type __n) const [inline]Returns a read-only (constant) iterator pointing to the first bucket element.
Parameters:
__n— the bucket index 🪣
Returns: a read-only local iterator 🌟
🪣 bucket_count() 🪣
size_type std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::bucket_count () const [inline], [noexcept]Returns the number of buckets of the unordered_multiset. that's it. count your buckets, know your worth 👑
⭐ cbegin() const ⭐
const_iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::cbegin () const [inline], [noexcept]Returns a read-only (constant) iterator that points to the first element in the unordered_multiset. the "c" stands for const, as always, we been knew 💅
🧚 cbegin(size_type __n) const 🧚
const_local_iterator std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::cbegin (size_type __n) const [inline]Returns a read-only (constant) iterator pointing to the first bucket element.
Parameters:
__n— the bucket index 🪣
Returns: a read-only local iterator 💫
cend — const version (whole-container vibe)
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
const_iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::cend () const[inline], [noexcept] ✨
Gives you a read-only (constant) iterator that points one past the last element in the unordered_multiset. It's the "you've reached the end, bestie, nothing more to see here" marker 💅
Fun fact: it's referenced by std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert() — the insert girlies are lowkey relying on it 👀
cend — bucket version
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
const_local_iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::cend (size_type __n) const[inline]
Returns a read-only (constant) iterator pointing to one past the last bucket elements 🪣✨
Parameters
__n— the bucket index.
Returns
A read-only local iterator.
clear
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
void std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::clear ()[inline], [noexcept] 🧹
Erases all elements in an unordered_multiset. Total clean-slate main character energy — everything gone, no notes 💀
⚠️ Okay so this is important bestie: this function only erases the elements. If the elements themselves are pointers, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility. So like… don't blame the multiset, she just did what you asked 🫶
contains — the transparent/template one
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt>
auto std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::contains (const _Kt &__x) const
-> decltype(_M_h._M_find_tr(__x), void(), true)[inline]
Finds whether an element with the given key exists. Yes queen, just a yes-or-no vibe check on your key 🔥
Parameters
__x— key of elements to be located.
Returns
true if there is any element with the specified key.
contains — the key_type one
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
bool std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::contains (const key_type &__x) const[inline]
Same deal, same energy: finds whether an element with the given key exists 💖
Parameters
__x— key of elements to be located.
Returns
true if there is any element with the specified key.
count — the transparent/template one
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt>
auto std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::count (const _Kt &__x) const
-> decltype(_M_h._M_count_tr(__x))[inline]
Finds the number of elements. Because she's a *multi*set, "how many of these do you have" is a genuinely valid question and the answer can be more than one 😌💅
Parameters
__x— element to located.
Returns
Number of elements with specified key.
count — the key_type one
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
size_type std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::count (const key_type &__x) const[inline]
Finds the number of elements. Same as above but takes the plain key_type ✨
Parameters
__x— element to located.
Returns
Number of elements with specified key.
emplace
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename... _Args>
iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::emplace (_Args &&... __args)[inline]
Builds and insert an element into the unordered_multiset — she constructs it in place, no little temporary baby needed, iconic behaviour honestly 👑
Parameters
__args— arguments used to generate an element.
Returns
An iterator that points to the inserted element.
Insertion requires amortized constant time. ⏱️ Slay.
emplace_hint
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename... _Args>
iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::emplace_hint (const_iterator __pos, _Args &&... __args)[inline]
Inserts an element into the unordered_multiset, but you get to hint at where it goes 🎀
Parameters
__pos— an iterator that serves as a hint as to where the element should be inserted.__args— arguments used to generate the element to be inserted.
Returns
An iterator that points to the inserted element.
Heads up: the first parameter is only a hint and can potentially improve the performance of the insertion process. A bad hint would cause no gains in efficiency. So like, no pressure, but also… make it a good hint bestie 😭
For more on hinting, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
Insertion requires amortized constant time. ⏱️
empty
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
bool std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::empty () const[inline], [noexcept]
Returns true if the unordered_multiset is empty. The vibe check. The "is she running on nothing rn" check 🦋 (note: noexcept, she's not gonna throw at you for asking 💅)
end — const version
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
const_iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::end () const[inline], [noexcept]
Returns a read-only (constant) iterator that points one past the last element in the unordered_multiset. The finish line, the end credits, the "go home everybody" ✨
end — non-const version
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::end ()[inline], [noexcept]
Returns a read-only (constant) iterator that points one past the last element in the unordered_multiset — yep, that's what the docs say for this non-const overload too, don't come for me, I'm just the messenger 🙈
Referenced by std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::extract() — extract girlies stay winning 👑
end — bucket version, non-const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
local_iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::end (size_type __n)[inline]
Returns a read-only (constant) iterator pointing to one past the last bucket elements 🪣
Parameters
__n— the bucket index.
Returns
A read-only local iterator.
end — bucket version, const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
const_local_iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::end (size_type __n) const[inline]
Returns a read-only (constant) iterator pointing to one past the last bucket elements. Same bucket energy, but now she's const and behaving 💖
Parameters
__n— the bucket index.
Returns
A read-only local iterator.
equal_range — transparent, non-const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt>
auto std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::equal_range (const _Kt &__x)
-> decltype(_M_h._M_equal_range_tr(__x))[inline]
Finds a subsequence matching given key. Because multiset can hold dupes, you get a whole range of them, not just one — she ate 🔥
Parameters
__x— key to be located.
Returns
Pair of iterators that possibly points to the subsequence matching given key.
equal_range — transparent, const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt>
auto std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::equal_range (const _Kt &__x) const
-> decltype(_M_h._M_equal_range_tr(__x))[inline]
Finds a subsequence matching given key. Const flavour, same range, same slay 💅
Parameters
__x— key to be located.
Returns
Pair of iterators that possibly points to the subsequence matching given key.
equal_range — key_type, non-const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
std::pair<iterator, iterator> std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::equal_range (const key_type &__x)[inline]
Finds a subsequence matching given key. Hands you back a std::pair<iterator, iterator> — begin-of-the-club and end-of-the-club 🎀
Parameters
__x— key to be located.
Returns
Pair of iterators that possibly points to the subsequence matching given key.
equal_range — key_type, const
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
std::pair<const_iterator, const_iterator> std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::equal_range (const key_type &__x) const[inline]
Finds a subsequence matching given key. Const pair version — read-only, look but don't touch 🌸
Parameters
__x— key to be located.
Returns
Pair of iterators that possibly points to the subsequence matching given key.
erase — by key
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
size_type std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::erase (const key_type &__x)[inline]
Erases elements according to the provided key. And because she's a multiset, this wipes out all the elements located by that key — every last one of them 💀✨
Parameters
__x— key of element to be erased.
Returns
The number of elements erased.
This function erases all the elements located by the given key from an unordered_multiset.
⚠️ Real talk: this function only erases the element, and if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility. She is not your memory manager, bestie 🫶
erase — range
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::erase (const_iterator __first, const_iterator __last)[inline]
Erases a [__first,__last) range of elements from an unordered_multiset. Note the square bracket on the left and the round one on the right — __first is in, __last is not 💅
Parameters
__first— iterator pointing to the start of the range to be erased.__last— iterator pointing to the end of the range to be erased.
Returns
The iterator __last.
This function erases a sequence of elements from an unordered_multiset.
⚠️ Again: this function only erases the element, and if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility. No cap 🧚
erase — single position
template<typename _Value, typename _Hash = hash<_Value>, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>>
iterator std::unordered_multiset<_Value, _Hash, _Pred, _Alloc>::erase (const_iterator __position)[inline]
Erases an element from an unordered_multiset — just the one, targeted, surgical, main character energy 🔥
Parameters
__position— an iterator pointing to the element to be erased.
Returns
An iterator pointing to the element immediately following __position prior to the element being erased. If no such element exists, end() is returned.
This function erases an element, pointed to by the given iterator, from an unordered_multiset.
⚠️ And one more time for the people in the back: this function only erases the element, and if the element is itself a pointer, the pointed-to memory is not touched in any way. Managing the pointer is the user's responsibility ⭐
🌟 erase (iterator __position)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::erase (iterator
__position) [inline]Okay so this one deletes one single element out of your unordered_multiset. Just one. Not a range, bestie, we're being surgical here 💅
Parameters
__position— the iterator pointing at the element you want gone ✨
Returns
An iterator pointing to the element that came immediately after __position before it got erased. And if there's no such element? You get end() back. That's it, that's the deal 🎀
So like — this function erases the element that the iterator you handed it points to, from the unordered_multiset. Simple as.
⚠️ Important vibe check: this only erases the element. If the element is itself a pointer, the memory it points to is not touched in any way. Managing that pointer is your responsibility, not the container's. It is not gonna clean up after you, bestie 😭
🦋 extract (const key_type & __key)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> node_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::extract (const
key_type & __key) [inline]Extract a node 🫶 — literally the whole description, that's the entire documented behaviour. Short and iconic.
🧚 extract (const_iterator __pos)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> node_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::extract
(const_iterator __pos) [inline]Extract a node ✨ same energy, different argument.
References: std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::end()
💜 find (const _Kt & __x) — the transparent one
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt > auto std::unordered_multiset< _Value, _Hash,
_Pred, _Alloc >::find (const _Kt & __x) ->
decltype(_M_h._M_find_tr(__x))
[inline]Tries to locate an element in an unordered_multiset 🔍
Parameters
__x— the element we're hunting for
Returns
Iterator pointing to the sought-after element, or end() if it's not found 😭
So the way this works: you hand it a key, and it goes and tries to locate the element that this key matches. If it succeeds — slay — you get an iterator pointing right at the thing you were looking for. If it fails? You get the past-the-end (end()) iterator. Not found, no drama, just end() 💀
🌈 find (const _Kt & __x) const — same but const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _Kt > auto std::unordered_multiset< _Value, _Hash,
_Pred, _Alloc >::find (const _Kt & __x) const ->
decltype(_M_h._M_find_tr(__x))
[inline]Tries to locate an element in an unordered_multiset 🔍 (const edition, she's not changing anything)
Parameters
__x— the element to be located
Returns
Iterator pointing to the sought-after element, or end() if not found 💅
Same whole situation as above: takes a key, tries to locate the matching element, hands you an iterator if it wins, hands you end() if it doesn't ✨
🍓 find (const key_type & __x)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::find (const
key_type & __x) [inline]Tries to locate an element in an unordered_multiset 🎀
Parameters
__x— element to be located
Returns
Iterator pointing to sought-after element, or end() if not found
Key goes in, iterator comes out (hopefully). Match found = iterator to the element. No match = past-the-end (end()) iterator. Periodt 💅
🎀 find (const key_type & __x) const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> const_iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::find (const
key_type & __x) const [inline]Tries to locate an element in an unordered_multiset 🌸
Parameters
__x— element to be located
Returns
Iterator pointing to sought-after element, or end() if not found
Const-flavoured, same behaviour, still returns that past-the-end (end()) iterator when the key simply isn't there 🙈
👑 get_allocator () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> allocator_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::get_allocator
() const [inline], [noexcept]Returns the allocator object that the unordered_multiset is using 🫶 That's it. That's the whole function. noexcept too, so she's chill about it ✨
⭐ hash_function () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> hasher
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::hash_function
() const [inline]Returns the hash functor object that the unordered_multiset was constructed with 💜 So you can see exactly which hasher is running the show.
🔥 insert (_InputIterator __first, _InputIterator __last)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
template<typename _InputIterator > void std::unordered_multiset< _Value,
_Hash, _Pred, _Alloc >::insert (_InputIterator __first, _InputIterator
__last) [inline]A template function that inserts a range of elements ✨ bulk insertion era
Parameters
__first— iterator pointing to the start of the range to be inserted__last— iterator pointing to the end of the range
Complexity: similar to that of the range constructor 🎀
💖 insert (const value_type & __x)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert (const
value_type & __x) [inline]Inserts an element into the unordered_multiset 💅
Parameters
__x— element to be inserted
Returns
An iterator that points to the inserted element 🫶
Complexity: insertion requires amortized constant time ⚡
🌸 insert (const_iterator __hint, const value_type & __x)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(const_iterator __hint, const value_type & __x) [inline]Inserts an element into the unordered_multiset 🎀
Parameters
__hint— an iterator that serves as a hint as to where the element should be inserted__x— element to be inserted
Returns
An iterator that points to the inserted element ✨
So the tea on __hint: that first parameter is only a hint — it can potentially improve the performance of the insertion process, but a bad hint causes no gains in efficiency 😭 so don't stress if yours is mid.
For more on hinting, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
Complexity: insertion requires amortized constant ⚡
🧚 insert (const_iterator __hint, node_type && __nh)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(const_iterator __hint, node_type && __nh) [inline]Re-insert an extracted node 🦋 putting the node back where it belongs
References: std::move()
💜 insert (const_iterator __hint, value_type && __x)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(const_iterator __hint, value_type && __x) [inline]Inserts an element into the unordered_multiset (move-y flavour) 💅
Parameters
__hint— an iterator that serves as a hint as to where the element should be inserted__x— element to be inserted
Returns
An iterator that points to the inserted element
Same hint situation as before, bestie: first parameter is only a hint, it can potentially improve insertion performance, and a bad hint would cause no gains in efficiency 🙈
For more on hinting, see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints
Complexity: insertion requires amortized constant ⚡
References: std::move()
🌈 insert (initializer_list<value_type> __l)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> void
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(initializer_list< value_type > __l) [inline]Inserts a list of elements into the unordered_multiset ✨ curly-brace girlies this one's for you 🎀
Parameters
__l— astd::initializer_list<value_type>of elements to be inserted
Complexity: similar to that of the range constructor 🫶
⭐ insert (node_type && __nh)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(node_type && __nh) [inline]Re-insert an extracted node 🧚 no hint this time, she just goes
References: std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::cend(), and std::move()
🍓 insert (value_type && __x)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> iterator
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert
(value_type && __x) [inline]Inserts an element into the unordered_multiset 💖
Parameters
__x— element to be inserted
Returns
An iterator that points to the inserted element
Complexity: insertion requires amortized constant time ⚡
References: std::move()
🦋 key_eq () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> key_equal
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::key_eq () const
[inline]Returns the key comparison object that the unordered_multiset was constructed with 👑 so you can peek at whichever predicate is deciding what counts as "equal" around here.
🎀 load_factor () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> float
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::load_factor ()
const [inline], [noexcept]Returns the average number of elements per bucket 📊 your buckets-to-elements ratio, basically. noexcept, so no surprises ✨
💀 max_bucket_count () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> size_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc
>::max_bucket_count () const [inline], [noexcept]Returns the maximum number of buckets of the unordered_multiset 🪣 the absolute ceiling, the bucket limit, the whole thing. noexcept too 💅
🌸 max_load_factor () const
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> float
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::max_load_factor
() const [inline], [noexcept]Returns a positive number that the unordered_multiset tries to keep the load factor less than or equal to 🎯 it's the ceiling she's aiming under, not a promise, a tries. noexcept ✨
🔥 max_load_factor (float __z)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> void
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::max_load_factor
(float __z) [inline]Change the unordered_multiset maximum load factor 🛠️ the setter version — you pass in __z and that's the new ceiling she'll try to stay under. Same name, different job, iykyk 💅
Catching the tail end of the one above — Parameters:
__z— the new maximum load factor.
💖 max_size
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> size_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::max_size ()
const [inline], [noexcept]Returns the maximum size of the unordered_multiset. That's it, that's the whole vibe — the biggest this container could ever get. noexcept too, so she's chill about it ✨
🎀 operator= (copy)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
unordered_multiset & std::unordered_multiset< _Value, _Hash, _Pred,
_Alloc >::operator= (const unordered_multiset< _Value, _Hash, _Pred,
_Alloc > &) [default]Copy assignment operator. Classic. She takes the other multiset's whole personality and becomes it 💅 Defaulted, so the compiler writes the boring parts for her.
🌸 operator= (initializer_list)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
unordered_multiset & std::unordered_multiset< _Value, _Hash, _Pred,
_Alloc >::operator= (initializer_list< value_type > __l) [inline]Unordered_multiset list assignment operator — the "here's a lil list, bestie, take it all" move 🫶
Parameters
__l— An initializer_list.
This function fills an unordered_multiset with copies of the elements in the initializer list __l.
Heads up babes: the assignment completely changes the unordered_multiset, and the resulting unordered_multiset's size is the same as the number of elements assigned. So like… nothing survives from before. Total glow-up, no leftovers ✨
🦋 operator= (move)
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>>
unordered_multiset & std::unordered_multiset< _Value, _Hash, _Pred,
_Alloc >::operator= (unordered_multiset< _Value, _Hash, _Pred, _Alloc >
&&) [default]Move assignment operator. She yoinks the other one's whole existence. Defaulted, zero notes 💀
🔥 rehash
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> void
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::rehash
(size_type __n) [inline]May rehash the unordered_multiset. Emphasis on may — she's not committing to anything, it's giving conditional queen 👑
Parameters
__n— The new number of buckets.
Rehash will occur only if the new number of buckets respect the unordered_multiset maximum load factor. No wishes, no vibes — the load factor said no, so she's not doing it.
🧚 reserve
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> void
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::reserve
(size_type __n) [inline]Prepare the unordered_multiset for a specified number of elements. Like packing your bag before the trip instead of panicking at the airport 🎀
Parameters
__n— Number of elements required.
Same as rehash(ceil(n / max_load_factor())). Literally that. Do the math, she already did 🧮
⭐ size
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> size_type
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::size () const
[inline], [noexcept]Returns the size of the unordered_multiset. How many besties are in the group chat. const and noexcept, so she won't surprise you 💜
🌈 swap
template<typename _Value , typename _Hash = hash<_Value>, typename _Pred =
equal_to<_Value>, typename _Alloc = allocator<_Value>> void
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::swap
(unordered_multiset< _Value, _Hash, _Pred, _Alloc > & __x) [inline],
[noexcept]Swaps data with another unordered_multiset. Two multisets, one trade, everyone eats 🔥
Parameters
__x— An unordered_multiset of the same element and allocator types. (Same element type, same allocator type — she's picky about her company, iykyk.)
This exchanges the elements between two sets in constant time. Obsessed. And note that the global std::swap() function is specialized such that std::swap(s1,s2) will feed to this function — so you can just call the global one and she'll handle it, no cap 🫶
👑 Author
Generated automatically by Doxygen for libstdc++ from the source code. (Not a human, not a girlie, just a doc generator doing her lil thing 💅)
and that's the whole page, bestie ✨ This little love letter lives in thelibstdc++man pages asstd::unordered_multiset<...>(3cxx)— same source, same version-and-date energy, just delivered with way more sparkle 🎀 Go forth and multiset responsibly 🦋💖
📦 where this page comes from
- ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
- 💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on : a language model's rewrite of the original, under its terms