__gnu_cxx(3)

📦

version 16.2.1+r23+gd564253eb6c8 · 11 versions

16.2.1+r23+gd564253eb6c8 · arch rolling, fedora 44 (latest)
11.5.0 · centos-stream 9
16.2.1 · centos-stream 9
15.2.1 · centos-stream 9
14.2.1 · centos-stream 9
12.2.1 · centos-stream 9
13.3.1 · centos-stream 9
16.2.1 · centos-stream 10
4.4.0 · nixpkgs unstable
15.3.1 · centos-stream 10, fedora 43
16.0.1 · fedora 44

omg bestie 💖 welcome to __gnu_cxx(3) from the Library Functions Manual — it's giving GNU extensions for public use, and we're doing this in eight parts because the lore is deep. This is part 1, and we're keeping every single detail, no cap. 🫶

✨ NAME ✨

__gnu_cxx — GNU extensions for public use. that's it, that's the name, periodt. 💅

🦋 SYNOPSIS 🦋

okay so here's the whole map. namespaces, classes, typedefs, enumerations — all of it. buckle up. 🎀

🌸 Namespaces 🌸

namespace __detail — implementation details that are not part of the __gnu_cxx namespace interface, so like, backstage only. 🙈
namespace typelist — GNU typelist extensions for public compile-time use, slay. ✨

👑 Classes 👑

struct __alloc_traits — a uniform interface to C++98 and C++11 allocators, iconic.
struct __common_pool_policy — policy for shared __pool objects.
class __mt_alloc — this is a fixed size (power of 2) allocator which — when compiled with thread support — will maintain one freelist per size per thread plus a global one. steps are taken to limit the per thread freelist sizes (by returning excess back to the global list).
class __mt_alloc_base — base class for _Tp dependent member functions.
struct __per_type_pool_policy — policy for individual __pool objects.
class __pool — data describing the underlying memory pool, parameterized on threading support.
class __pool< false > — specialization for single thread.
class __pool< true > — specialization for thread enabled, via gthreads.h.
class __pool_alloc — allocator using a memory pool with a single lock.
class __pool_alloc_base — base class for __pool_alloc.
struct __pool_base — base class for pool object.
class __rc_string_base
class __scoped_lock — scoped lock idiom.
class __versa_string — template class __versa_string.
struct _Caster
struct _Char_types — mapping from character type to associated types.
class _ExtPtr_allocator — an example allocator which uses a non-standard pointer type.
struct _Invalid_type
class _Pointer_adapter
class _Relative_pointer_impl — a storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset value which is relative to its own address.
class _Relative_pointer_impl< const _Tp >
class _Std_pointer_impl — a storage policy for use with _Pointer_adapter<> which yields a standard pointer.
class _Temporary_buffer
struct _Unqualified_type
class allocator — the standard allocator, as per C++03 [20.4.1].
struct annotate_base — base class for checking address and label information about allocations. create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size.
class binary_compose — An SGI extension.
class bitmap_allocator — Bitmap Allocator, primary template.
struct char_traits — base class used to implement std::char_traits.
struct character — a POD class that serves as a character abstraction class.
struct condition_base — base struct for condition policy.
struct constant_binary_fun — An SGI extension.
struct constant_unary_fun — An SGI extension.
struct constant_void_fun — An SGI extension.
class debug_allocator — a meta-allocator with debugging bits.
class enc_filebuf — it's the enc_filebuf class, bestie.
struct encoding_char_traits — encoding_char_traits, periodt.
class encoding_state — extension to use iconv for dealing with character encodings.
struct equal_to — one of the comparison functors.
struct forced_error — thrown by utilities for testing exception safety.
class free_list — the free list class for managing chunks of memory to be given to and returned by the bitmap_allocator.
class hash_map
class hash_multimap
class hash_multiset
class hash_set
struct limit_condition — base class for incremental control and throw.
class malloc_allocator — an allocator that uses malloc.
class new_allocator — an allocator that uses global new, as per C++03 [20.4.1].
struct pair — struct holding two objects (or references) of arbitrary type.
struct project1st — An SGI extension.
struct project2nd — An SGI extension.
struct random_condition — base class for random probability control and throw.
struct rb_tree
class recursive_init_error — exception thrown by __cxa_guard_acquire.
class rope
struct select1st — An SGI extension.
struct select2nd — An SGI extension.
class slist
class stdio_filebuf — provides a layer of compatibility for C/POSIX.
class stdio_sync_filebuf — provides a layer of compatibility for C.
class subtractive_rng
struct temporary_buffer
class throw_allocator_base — allocator class with logging and exception generation control. intended to be used as an allocator_type in templatized code.
struct throw_allocator_limit — allocator throwing via limit condition.
struct throw_allocator_random — allocator throwing via random condition.
struct throw_value_base — class with exception generation control. intended to be used as a value_type in templatized code.
struct throw_value_limit — type throwing via limit condition.
struct throw_value_random — type throwing via random condition.
class unary_compose — An SGI extension.

🎀 Typedefs 🎀

typedef void(* __destroy_handler) (void *)
template<typename _Tp> using __int_traits — convenience alias for __numeric_traits<integer-type>.
typedef __versa_string< char, std::char_traits< char >, std::allocator< char >, __rc_string_base > __rc_string
typedef __vstring __sso_string
typedef __versa_string< char16_t, std::char_traits< char16_t >, std::allocator< char16_t >, __rc_string_base > __u16rc_string
typedef __u16vstring __u16sso_string
typedef __versa_string< char16_t > __u16vstring
typedef __versa_string< char32_t, std::char_traits< char32_t >, std::allocator< char32_t >, __rc_string_base > __u32rc_string
typedef __u32vstring __u32sso_string
typedef __versa_string< char32_t > __u32vstring
typedef __versa_string< char > __vstring
typedef __versa_string< wchar_t, std::char_traits< wchar_t >, std::allocator< wchar_t >, __rc_string_base > __wrc_string
typedef __wvstring __wsso_string
typedef __versa_string< wchar_t > __wvstring
typedef rope< char > crope
typedef __SIZE_TYPE__ size_t
typedef rope< wchar_t > wrope

💜 Enumerations 💜

enum { _S_num_primes }
enum _Lock_policy { _S_single, _S_mutex, _S_atomic }

Functions ✨💅

okay bestie, deep breath — this list is long, but it's literally just every free function hanging out in the __gnu_cxx namespace, listed with its exact signature so you can find your fave. no skimming, no skipping, we're doing all of them. 🫶

__atomic_add — void __atomic_add (volatile _Atomic_word *__mem, int __val)
__atomic_add_dispatch — void __atomic_add_dispatch (_Atomic_word *__mem, int __val)
__atomic_add_single — void __atomic_add_single (_Atomic_word *__mem, int __val)
__aux_require_boolean_expr — template<class _Tp> void __aux_require_boolean_expr (const _Tp &__t)
__const_pointer_cast — template<typename _ToType, typename _FromType> _ToType __const_pointer_cast (_FromType *__arg)
__const_pointer_cast — template<typename _ToType, typename _FromType> _ToType __const_pointer_cast (const _FromType &__arg)
__copy_n — template<typename _InputIterator, typename _Size, typename _OutputIterator> std::pair< _InputIterator, _OutputIterator > __copy_n (_InputIterator __first, _Size __count, _OutputIterator __result, std::input_iterator_tag)
__copy_n — template<typename _RAIterator, typename _Size, typename _OutputIterator> std::pair< _RAIterator, _OutputIterator > __copy_n (_RAIterator __first, _Size __count, _OutputIterator __result, std::random_access_iterator_tag)
__distance — template<typename _InputIterator, typename _Distance> void __distance (_InputIterator __first, _InputIterator __last, _Distance &__n, std::input_iterator_tag)
__distance — template<typename _RandomAccessIterator, typename _Distance> void __distance (_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance &__n, std::random_access_iterator_tag)
__dynamic_pointer_cast — template<typename _ToType, typename _FromType> _ToType __dynamic_pointer_cast (_FromType *__arg)
__dynamic_pointer_cast — template<typename _ToType, typename _FromType> _ToType __dynamic_pointer_cast (const _FromType &__arg)
__error_type_must_be_a_signed_integer_type — void __error_type_must_be_a_signed_integer_type ()
__error_type_must_be_an_integer_type — void __error_type_must_be_an_integer_type ()
__error_type_must_be_an_unsigned_integer_type — void __error_type_must_be_an_unsigned_integer_type ()
__exchange_and_add — _Atomic_word __exchange_and_add (volatile _Atomic_word *__mem, int __val)
__exchange_and_add_dispatch — _Atomic_word __exchange_and_add_dispatch (_Atomic_word *__mem, int __val)
__exchange_and_add_single — _Atomic_word __exchange_and_add_single (_Atomic_word *__mem, int __val)
__function_requires — template<class _Concept> constexpr void __function_requires ()
__is_null_pointer — template<typename _Type> constexpr bool __is_null_pointer (_Type *__ptr)
__is_null_pointer — template<typename _Type> constexpr bool __is_null_pointer (_Type)
__is_null_pointer — constexpr bool __is_null_pointer (std::nullptr_t)
__is_single_threaded — bool __is_single_threaded () noexcept
__lexicographical_compare_3way — template<typename _InputIterator1, typename _InputIterator2> int __lexicographical_compare_3way (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
__lexicographical_compare_3way — int __lexicographical_compare_3way (const char *__first1, const char *__last1, const char *__first2, const char *__last2)
__lexicographical_compare_3way — int __lexicographical_compare_3way (const unsigned char *__first1, const unsigned char *__last1, const unsigned char *__first2, const unsigned char *__last2)
__median — template<typename _Tp> const _Tp & __median (const _Tp &__a, const _Tp &__b, const _Tp &__c) — Find the median of three values. 💖
__median — template<typename _Tp, typename _Compare> const _Tp & __median (const _Tp &__a, const _Tp &__b, const _Tp &__c, _Compare __comp) — Find the median of three values using a predicate for comparison. 🎀
__mutable_reference_at — crope::reference __mutable_reference_at (crope &__c, std::size_t __i)
__power — template<typename _Tp, typename _Integer> _Tp __power (_Tp __x, _Integer __n)
__power — template<typename _Tp, typename _Integer, typename _MonoidOperation> _Tp __power (_Tp __x, _Integer __n, _MonoidOperation __monoid_op)
__random_sample — template<typename _InputIterator, typename _RandomAccessIterator, typename _RandomNumberGenerator, typename _Distance> _RandomAccessIterator __random_sample (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __out, _RandomNumberGenerator &__rand, const _Distance __n)
__random_sample — template<typename _InputIterator, typename _RandomAccessIterator, typename _Distance> _RandomAccessIterator __random_sample (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __out, const _Distance __n)
__reinterpret_pointer_cast — template<typename _ToType, typename _FromType> _ToType __reinterpret_pointer_cast (_FromType *__arg)
__reinterpret_pointer_cast — template<typename _ToType, typename _FromType> _ToType __reinterpret_pointer_cast (const _FromType &__arg)
__slist_make_link — _Slist_node_base * __slist_make_link (_Slist_node_base *__prev_node, _Slist_node_base *__new_node)
__slist_previous — _Slist_node_base * __slist_previous (_Slist_node_base *__head, const _Slist_node_base *__node)
__slist_previous — const _Slist_node_base * __slist_previous (const _Slist_node_base *__head, const _Slist_node_base *__node)
__slist_reverse — _Slist_node_base * __slist_reverse (_Slist_node_base *__node)
__slist_size — std::size_t __slist_size (_Slist_node_base *__node)
__slist_splice_after — void __slist_splice_after (_Slist_node_base *__pos, _Slist_node_base *__before_first, _Slist_node_base *__before_last)
__slist_splice_after — void __slist_splice_after (_Slist_node_base *__pos, _Slist_node_base *__head)
__static_pointer_cast — template<typename _ToType, typename _FromType> _ToType __static_pointer_cast (_FromType *__arg)
__static_pointer_cast — template<typename _ToType, typename _FromType> _ToType __static_pointer_cast (const _FromType &__arg)
__stl_hash_string — size_t __stl_hash_string (const char *__s)
__stl_next_prime — unsigned long __stl_next_prime (unsigned long __n)
__stoa — template<typename _TRet, typename _Ret = _TRet, typename _CharT, typename... _Base> _Ret __stoa (_TRet(*__convf)(const _CharT *, _CharT **, _Base...), const char *__name, const _CharT *__str, std::size_t *__idx, _Base... __base)
__throw_concurrence_lock_error — void __throw_concurrence_lock_error ()
__throw_concurrence_unlock_error — void __throw_concurrence_unlock_error ()
__throw_forced_error — void __throw_forced_error ()
__to_xstring — template<typename _String, typename _CharT = typename _String::value_type> _String __to_xstring (int(*__convf)(_CharT *, std::size_t, const _CharT *, __builtin_va_list), std::size_t __n, const _CharT *__fmt,...)
__uninitialized_copy_n — template<typename _InputIter, typename _Size, typename _ForwardIter> std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n (_InputIter __first, _Size __count, _ForwardIter __result)
__uninitialized_copy_n — template<typename _InputIter, typename _Size, typename _ForwardIter> std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n (_InputIter __first, _Size __count, _ForwardIter __result, std::input_iterator_tag)
__uninitialized_copy_n — template<typename _RandomAccessIter, typename _Size, typename _ForwardIter> std::pair< _RandomAccessIter, _ForwardIter > __uninitialized_copy_n (_RandomAccessIter __first, _Size __count, _ForwardIter __result, std::random_access_iterator_tag)
__uninitialized_copy_n_a — template<typename _InputIter, typename _Size, typename _ForwardIter, typename _Allocator> std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n_a (_InputIter __first, _Size __count, _ForwardIter __result, _Allocator __alloc)
__uninitialized_copy_n_a — template<typename _InputIter, typename _Size, typename _ForwardIter, typename _Tp> std::pair< _InputIter, _ForwardIter > __uninitialized_copy_n_a (_InputIter __first, _Size __count, _ForwardIter __result, std::allocator< _Tp >)
__verbose_terminate_handler — void __verbose_terminate_handler () — bestie this one is literally the replacement for the standard terminate_handler, and it prints more information about the terminating exception (if any) on stderr. so when everything's on fire 🔥, at least you get receipts.
_Bit_scan_forward — std::size_t _Bit_scan_forward (std::size_t __num) — the generic version of the bsf instruction. iconic lowkey. ⭐

_Destroy_const — template<typename _ForwardIterator, typename _Allocator> void _Destroy_const (_ForwardIterator __first, _ForwardIterator __last, _Allocator __alloc)
_Destroy_const — template<typename _ForwardIterator, typename _Tp> void _Destroy_const (_ForwardIterator __first, _ForwardIterator __last, std::allocator< _Tp >)
_Rope_fill — template<class _CharT, class _Traits> void _Rope_fill (std::basic_ostream< _CharT, _Traits > &__o, std::size_t __n)
_Rope_is_simple — template<class _CharT> bool _Rope_is_simple (_CharT *)
_Rope_is_simple — bool _Rope_is_simple (char *)
_Rope_is_simple — bool _Rope_is_simple (wchar_t *)
_Rope_rotate — template<class _Rope_iterator> void _Rope_rotate (_Rope_iterator __first, _Rope_iterator __middle, _Rope_iterator __last)
_S_cond_store_eos — template<class _CharT> void _S_cond_store_eos (_CharT &)
_S_cond_store_eos — void _S_cond_store_eos (char &__c)
_S_cond_store_eos — void _S_cond_store_eos (wchar_t &__c)
_S_eos — template<class _CharT> _CharT _S_eos (_CharT *)
_S_is_basic_char_type — template<class _CharT> bool _S_is_basic_char_type (_CharT *)
_S_is_basic_char_type — bool _S_is_basic_char_type (char *)
_S_is_basic_char_type — bool _S_is_basic_char_type (wchar_t *)
_S_is_one_byte_char_type — template<class _CharT> bool _S_is_one_byte_char_type (_CharT *)
_S_is_one_byte_char_type — bool _S_is_one_byte_char_type (char *)

airy_ai — template<typename _Tp> __gnu_cxx::__promote< _Tp >::__type airy_ai (_Tp __x)
airy_aif — float airy_aif (float __x)
airy_ail — long double airy_ail (long double __x)
airy_bi — template<typename _Tp> __gnu_cxx::__promote< _Tp >::__type airy_bi (_Tp __x)
airy_bif — float airy_bif (float __x)
airy_bil — long double airy_bil (long double __x)
compose1 — template<class _Operation1, class _Operation2> unary_compose< _Operation1, _Operation2 > compose1 (const _Operation1 &__fn1, const _Operation2 &__fn2) — an SGI extension ✨
compose2 — template<class _Operation1, class _Operation2, class _Operation3> binary_compose< _Operation1, _Operation2, _Operation3 > compose2 (const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3) — an SGI extension ✨
conf_hyperg — template<typename _Tpa, typename _Tpc, typename _Tp> __gnu_cxx::__promote_3< _Tpa, _Tpc, _Tp >::__type conf_hyperg (_Tpa __a, _Tpc __c, _Tp __x)
conf_hypergf — float conf_hypergf (float __a, float __c, float __x)
conf_hypergl — long double conf_hypergl (long double __a, long double __c, long double __x)
constant0 — template<class _Result> constant_void_fun< _Result > constant0 (const _Result &__val) — an SGI extension ✨
constant1 — template<class _Result> constant_unary_fun< _Result, _Result > constant1 (const _Result &__val) — an SGI extension ✨
constant2 — template<class _Result> constant_binary_fun< _Result, _Result, _Result > constant2 (const _Result &__val) — an SGI extension ✨
copy_n — template<typename _InputIterator, typename _Size, typename _OutputIterator> std::pair< _InputIterator, _OutputIterator > copy_n (_InputIterator __first, _Size __count, _OutputIterator __result) — copies the range [first,first+count) into [result,result+count). no cap, that's the whole job. 🦋
count — template<typename _InputIterator, typename _Tp, typename _Size> void count (_InputIterator __first, _InputIterator __last, const _Tp &__value, _Size &__n)
count_if — template<typename _InputIterator, typename _Predicate, typename _Size> void count_if (_InputIterator __first, _InputIterator __last, _Predicate __pred, _Size &__n)
distance — template<typename _InputIterator, typename _Distance> void distance (_InputIterator __first, _InputIterator __last, _Distance &__n)
hyperg — template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp> __gnu_cxx::__promote_4< _Tpa, _Tpb, _Tpc, _Tp >::__type hyperg (_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
hypergf — float hypergf (float __a, float __b, float __c, float __x)
hypergl — long double hypergl (long double __a, long double __b, long double __c, long double __x)
identity_element — template<class _Tp> _Tp identity_element (std::multiplies< _Tp >)

and that's the whole Functions list, every single overload, nothing skipped, we ate and left zero crumbs 💅 keep scrolling bestie, there's more where this came from 🌸

(quick heads-up bestie: the entry from the last chunk wraps up with An SGI extension . — and now we're right back in the alphabetical grind 🫶)

✨ `identity_element` ✨

template<class _Tp> _Tp identity_element (std::plus< _Tp >)

An SGI extension . That's the whole blurb. Short queen, says what it needs to say. 💅

🌀 `iota`

template<typename _ForwardIterator, typename _Tp> constexpr void iota (_ForwardIterator __first, _ForwardIterator __last, _Tp __value)

Create a range of sequentially increasing values. So you hand it __first, __last and a starting __value, and it just keeps the numbers going up one after another through the whole range. Little range-glow-up moment, honestly. ✨

🌸 `is_heap`

template<typename _RAIter> constexpr bool is_heap (_RAIter, _RAIter)

🌸 `is_sorted`

template<typename _FIter> constexpr bool is_sorted (_FIter, _FIter)

No blurb for these two, so no invented blurb from me — signatures only, bestie. I refuse to make stuff up about a manpage. 🫶

🔥 `lexicographical_compare_3way`

template<typename _InputIterator1, typename _InputIterator2> int lexicographical_compare_3way (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)

memcmp on steroids. Periodt. That's genuinely the description, and honestly? Iconic. 💀

🎀 `mem_fun1`

template<class _Ret, class _Tp, class _Arg> std::const_mem_fun1_t< _Ret, _Tp, _Arg > mem_fun1 (_Ret(_Tp::*__f)(_Arg) const)

template<class _Ret, class _Tp, class _Arg> std::mem_fun1_t< _Ret, _Tp, _Arg > mem_fun1 (_Ret(_Tp::*__f)(_Arg))

🎀 `mem_fun1_ref`

template<class _Ret, class _Tp, class _Arg> std::const_mem_fun1_ref_t< _Ret, _Tp, _Arg > mem_fun1_ref (_Ret(_Tp::*__f)(_Arg) const)

template<class _Ret, class _Tp, class _Arg> std::mem_fun1_ref_t< _Ret, _Tp, _Arg > mem_fun1_ref (_Ret(_Tp::*__f)(_Arg))

The const twins and the non-const twins, side by side, matching outfits. Very demure, very mindful. 😌

🚫 `operator!=` — the "not equal" committee 🚫

Okay so this is the big one. Nineteen overloads of "are these two things NOT the same." Buckle up. 🌈

_Tp1 on the left, _Pointer_adapter< _Tp2 > on the right:

template<typename _Tp1, typename _Tp2> bool operator!= (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)

versa_string vs versa_string — Test difference of two strings. 🦋

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator!= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

versa_string vs C string — Test difference of string and C string. ✨

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator!= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs)

C string vs versa_string — Test difference of C string and string. ✨

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator!= (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

_Pointer_adapter vs _Pointer_adapter, same _Tp:

template<typename _Tp> bool operator!= (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)

_Pointer_adapter vs a plain int:

template<typename _Tp> bool operator!= (const _Pointer_adapter< _Tp > &__lhs, int __rhs)

_Pointer_adapter< _Tp1 > vs any _Tp2:

template<typename _Tp1, typename _Tp2> bool operator!= (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)

_Pointer_adapter< _Tp1 > vs _Pointer_adapter< _Tp2 >:

template<typename _Tp1, typename _Tp2> bool operator!= (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)

rope char proxy vs rope char proxy:

template<class _CharT, class _Alloc> bool operator!= (const _Rope_char_ptr_proxy< _CharT, _Alloc > &__x, const _Rope_char_ptr_proxy< _CharT, _Alloc > &__y)

rope const iterator vs rope const iterator:

template<class _CharT, class _Alloc> bool operator!= (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)

rope iterator vs rope iterator:

template<class _CharT, class _Alloc> bool operator!= (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)

hash_map vs hash_map:

template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc> bool operator!= (const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)

hash_multimap vs hash_multimap:

template<class _Key, class _Tp, class _HF, class _EqKey, class _Alloc> bool operator!= (const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm2)

hash_multiset vs hash_multiset:

template<class _Val, class _HashFcn, class _EqualKey, class _Alloc> bool operator!= (const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)

hash_set vs hash_set:

template<class _Value, class _HashFcn, class _EqualKey, class _Alloc> bool operator!= (const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs2)

hashtable vs hashtable:

template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> bool operator!= (const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht2)

rope vs rope:

template<class _CharT, class _Alloc> bool operator!= (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y)

slist vs slist:

template<class _Tp, class _Alloc> bool operator!= (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

a plain int on the left, _Pointer_adapter< _Tp > on the right:

template<typename _Tp> bool operator!= (int __lhs, const _Pointer_adapter< _Tp > &__rhs)

Nineteen. Counted them. Not one skipped, bestie — that's the whole roster. 👑

✖️ `operator*` (for `throw_value_base`)

template<typename _Cond> throw_value_base< _Cond > operator* (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b)

No description on this one, so I'm not inventing a personality for it beyond "here it is." 🫡

➕ `operator+` — the concatenation cinematic universe 🌈

Buckle in, this is the longest set on the whole page. Twenty overloads. Twenty. 💀

versa_string `operator+`

rvalue versa_string + rvalue versa_string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

rvalue versa_string + a single character:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, _CharT __rhs)

rvalue versa_string + const versa_string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

rvalue versa_string + C string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (__versa_string< _CharT, _Traits, _Alloc, _Base > &&__lhs, const _CharT *__rhs)

single character + rvalue versa_string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (_CharT __lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

single character + const versa_string — Concatenate character and string. 🎀

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (_CharT __lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

const versa_string + rvalue versa_string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

const versa_string + a single character — Concatenate string and character. 🎀

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, _CharT __rhs)

const versa_string + const versa_string — Concatenate two strings. 💖

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

const versa_string + C string — Concatenate string and C string. 💖

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs)

C string + rvalue versa_string:

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const _CharT *__lhs, __versa_string< _CharT, _Traits, _Alloc, _Base > &&__rhs)

C string + const versa_string — Concatenate C string and string. 💖

template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> __versa_string< _CharT, _Traits, _Alloc, _Base > operator+ (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)

rope / iterator `operator+`

rope const iterator + std::ptrdiff_t:

template<class _CharT, class _Alloc> _Rope_const_iterator< _CharT, _Alloc > operator+ (const _Rope_const_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n)

rope iterator + std::ptrdiff_t:

template<class _CharT, class _Alloc> _Rope_iterator< _CharT, _Alloc > operator+ (const _Rope_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n)

rope + a character:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > operator+ (const rope< _CharT, _Alloc > &__left, _CharT __right)

rope + C string:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > operator+ (const rope< _CharT, _Alloc > &__left, const _CharT *__right)

rope + rope:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > operator+ (const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right)

throw_value_base `operator+`

template<typename _Cond> throw_value_base< _Cond > operator+ (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b)

`std::ptrdiff_t` on the left `operator+`

std::ptrdiff_t + rope const iterator:

template<class _CharT, class _Alloc> _Rope_const_iterator< _CharT, _Alloc > operator+ (std::ptrdiff_t __n, const _Rope_const_iterator< _CharT, _Alloc > &__x)

std::ptrdiff_t + rope iterator:

template<class _CharT, class _Alloc> _Rope_iterator< _CharT, _Alloc > operator+ (std::ptrdiff_t __n, const _Rope_iterator< _CharT, _Alloc > &__x)

Twenty overloads. Twenty. And you thought your group chat had a lot of plus-ones. 👑

➕= `operator+=` (rope only, but make it count) 🧵

rope += a character:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > & operator+= (rope< _CharT, _Alloc > &__left, _CharT __right)

rope += a C string:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > & operator+= (rope< _CharT, _Alloc > &__left, const _CharT *__right)

rope += another rope:

template<class _CharT, class _Alloc> rope< _CharT, _Alloc > & operator+= (rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right)

➖ `operator-`

rope const iterator minus rope const iterator → std::ptrdiff_t:

template<class _CharT, class _Alloc> std::ptrdiff_t operator- (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)

rope const iterator minus std::ptrdiff_t:

template<class _CharT, class _Alloc> _Rope_const_iterator< _CharT, _Alloc > operator- (const _Rope_const_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n)

rope iterator minus rope iterator → std::ptrdiff_t:

template<class _CharT, class _Alloc> std::ptrdiff_t operator- (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)

rope iterator minus std::ptrdiff_t:

template<class _CharT, class _Alloc> _Rope_iterator< _CharT, _Alloc > operator- (const _Rope_iterator< _CharT, _Alloc > &__x, std::ptrdiff_t __n)

throw_value_base minus throw_value_base:

template<typename _Cond> throw_value_base< _Cond > operator- (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b)

and that's where this chunk cuts off, bestie — the alphabet keeps going and so do we, no wrap-up, no goodbye. 💖

okay bestie we're deep in the operator zone now 💅 this is the part of the page where literally every comparison and print operator that lives in this namespace comes out to say hi. the whole operator<, operator<<, operator<= and operator== girl gang, one by one, no skips, no shortcuts. grab a snack, we're doing all of them 🍓

🌸 `operator<` — the "who comes first" committee 🌸

template<typename _Tp1, typename _Tp2> bool operator< (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks if one string precedes another string 💖
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator< (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — checks if a string precedes a C string ✨
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator< (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks if a C string precedes a string 🎀
template<typename _Tp1, typename _Tp2> bool operator< (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)
template<typename _Tp1, typename _Tp2> bool operator< (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)
template<class _CharT, class _Alloc> bool operator< (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)
template<class _CharT, class _Alloc> bool operator< (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)
template<typename _Value, typename _Int, typename _St> bool operator< (const character< _Value, _Int, _St > &lhs, const character< _Value, _Int, _St > &rhs)
template<class _CharT, class _Alloc> bool operator< (const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right)
template<class _Tp, class _Alloc> bool operator< (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)
template<typename _Cond> bool operator< (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b)

🦋 `operator<<` — the print-it-out besties 🦋

these ones take a stream and a thing and send that thing straight into the stream. it's giving "tell the terminal everything" energy, and honestly? iconic.

template<class _CharT, class _Traits, class _Alloc> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__o, const rope< _CharT, _Alloc > &__r)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::beta_distribution< _RealType > &__x)
template<typename _UIntType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::hypergeometric_distribution< _UIntType > &__x)
template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__x)
template<typename _UIntType, size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::triangular_distribution< _RealType > &__x)
template<std::size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::uniform_inside_sphere_distribution< _Dimen, _RealType > &__x)
template<std::size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::uniform_on_sphere_distribution< _Dimen, _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::von_mises_distribution< _RealType > &__x)
template<typename _CharT, typename _Traits, typename _StoreT> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const _Pointer_adapter< _StoreT > &__p)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const arcsine_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const hoyt_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const k_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const logistic_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const nakagami_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const pareto_distribution< _RealType > &__x)
template<typename _RealType, typename _CharT, typename _Traits> std::basic_ostream< _CharT, _Traits > & operator<< (std::basic_ostream< _CharT, _Traits > &__os, const rice_distribution< _RealType > &__x)
std::ostream & operator<< (std::ostream &os, const annotate_base &__b)

💜 `operator<=` — "doesn't follow", very demure 💜

template<typename _Tp1, typename _Tp2> bool operator<= (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks if a string doesn't follow another string 💅
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator<= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — checks if a string doesn't follow a C string 🌈
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator<= (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks if a C string doesn't follow a string ⭐
template<typename _Tp> bool operator<= (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)
template<typename _Tp1, typename _Tp2> bool operator<= (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs)
template<typename _Tp1, typename _Tp2> bool operator<= (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs)
template<class _CharT, class _Alloc> bool operator<= (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y)
template<class _CharT, class _Alloc> bool operator<= (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y)
template<class _CharT, class _Alloc> bool operator<= (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y)
template<class _Tp, class _Alloc> bool operator<= (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)

✨ `operator==` — the equivalence girlies, they ate ✨

template<typename _Tp1, typename _Tp2> bool operator== (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs)
template<size_t _Dimen, typename _RealType> bool operator== (const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__d1, const __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__d2)
template<typename _UIntType, size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4> bool operator== (const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__lhs, const __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__rhs)
template<typename _Tp, typename _Poolp> bool operator== (const __mt_alloc< _Tp, _Poolp > &, const __mt_alloc< _Tp, _Poolp > &)
template<typename _Tp> bool operator== (const __pool_alloc< _Tp > &, const __pool_alloc< _Tp > &)
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks whether two strings are equivalent 💖
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator== (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — checks whether a string and a C string are equivalent 🎀
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator== (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — checks whether a C string and a string are equivalent 🫶
template<typename _Tp> bool operator== (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs)
template<typename _Tp> bool operator== (const _Pointer_adapter< _Tp > &__lhs, int __rhs)
template<typename _Tp1, typename _Tp2> bool operator== (const

okay bestie, picking right back up mid-list, the comparison operators are NOT done with us yet 💅

_Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs) — this is just the tail end of an operator== that kicked off back in the last part, so nothing new to spill, carry on 🫶
template<typename _Tp1, typename _Tp2> bool operator== (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs) — two _Pointer_adapters, one equality check, does left equal right ✨
template<class _CharT, class _Alloc> bool operator== (const _Rope_char_ptr_proxy< _CharT, _Alloc > &__x, const _Rope_char_ptr_proxy< _CharT, _Alloc > &__y) — same vibe but for _Rope_char_ptr_proxy, checking if __x and __y are equal 💖
template<class _CharT, class _Alloc> bool operator== (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — equality for _Rope_const_iterators, so you can ask if two const rope iterators are pointing at the same spot 👑
template<class _CharT, class _Alloc> bool operator== (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — and the non-const _Rope_iterator gets the same treatment, iconic 🌸
template<typename _Tp1, typename _Tp2> bool operator== (const bitmap_allocator< _Tp1 > &, const bitmap_allocator< _Tp2 > &) throw () — comparing two bitmap_allocators. yes it's throw (), so no exceptions are getting thrown here, periodt 💀
template<typename _Value, typename _Int, typename _St> bool operator== (const character< _Value, _Int, _St > &lhs, const character< _Value, _Int, _St > &rhs) — equality for two character objects, lhs vs rhs, that's the whole assignment 🎀
template<class _Key, class _Tp, class _HashFn, class _EqlKey, class _Alloc> bool operator== (const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2) — two hash_maps, __hm1 and __hm2, do they match? this is the whole function 🔥
template<class _Key, class _Tp, class _HF, class _EqKey, class _Alloc> bool operator== (const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HF, _EqKey, _Alloc > &__hm2) — same energy for hash_multimap, __hm1 vs __hm2 🦋
template<class _Val, class _HashFcn, class _EqualKey, class _Alloc> bool operator== (const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2) — hash_multiset equality, __hs1 and __hs2, go off ⭐
template<class _Value, class _HashFcn, class _EqualKey, class _Alloc> bool operator== (const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &__hs2) — yep, hash_set version too, same template parameter names and everything 🌈
template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> bool operator== (const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht1, const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &__ht2) — the underlying hashtable itself gets an equality check, __ht1 vs __ht2, main character energy fr fr 👑
template<class _CharT, class _Alloc> bool operator== (const rope< _CharT, _Alloc > &__left, const rope< _CharT, _Alloc > &__right) — two ropes, __left and __right, are they the same? obsessed 🧚
template<class _Tp, class _Alloc> bool operator== (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2) — slist equality, _SL1 and _SL2, no cap 💜
template<typename _Tp, typename _Cond> bool operator== (const throw_allocator_base< _Tp, _Cond > &, const throw_allocator_base< _Tp, _Cond > &) — two throw_allocator_bases, both unnamed args, checking equality 🙈
template<typename _Cond> bool operator== (const throw_value_base< _Cond > &__a, const throw_value_base< _Cond > &__b) — and throw_value_base equality, __a vs __b, cute 🍓
template<typename _Tp> bool operator== (int __lhs, const _Pointer_adapter< _Tp > &__rhs) — a raw int on the left, a _Pointer_adapter on the right, and yeah this checks if they're equal 😭
template<typename _Tp1, typename _Tp2> bool operator> (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs) — and now we're in the greater-than era, some _Tp1 __lhs versus a _Pointer_adapter< _Tp2 > 💅
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — the docs say it best: "Test if string follows string." 🌸
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator> (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — "Test if string follows C string." iconic ✨
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator> (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — "Test if C string follows string." and that's the trio, slay 🎀
template<typename _Tp> bool operator> (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs) — back to _Pointer_adapter vs _Pointer_adapter, greater-than edition 💖
template<typename _Tp1, typename _Tp2> bool operator> (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs) — and the mixed _Tp2 __rhs flavor, keep up bestie 🦋
template<typename _Tp1, typename _Tp2> bool operator> (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs) — and the two-_Pointer_adapter one with different _Tp1 / _Tp2, the range is giving ⭐
template<class _CharT, class _Alloc> bool operator> (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — greater-than for _Rope_const_iterators, __x vs __y 🔥
template<class _CharT, class _Alloc> bool operator> (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — and the mutable _Rope_iterator version, obviously 🌈
template<class _CharT, class _Alloc> bool operator> (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y) — rope vs rope, which one's bigger, we love to see it 👑
template<class _Tp, class _Alloc> bool operator> (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2) — slist greater-than, _SL1 and _SL2, periodt 💜
template<typename _Tp1, typename _Tp2> bool operator>= (_Tp1 __lhs, const _Pointer_adapter< _Tp2 > &__rhs) — and now operator>= season opens with _Tp1 __lhs vs _Pointer_adapter< _Tp2 > 🙈
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — docs say: "Test if string doesn't precede string." 🍓
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator>= (const __versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs, const _CharT *__rhs) — "Test if string doesn't precede C string." 🧚
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> bool operator>= (const _CharT *__lhs, const __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs) — "Test if C string doesn't precede string." and the versa_string trio is complete 💖
template<typename _Tp> bool operator>= (const _Pointer_adapter< _Tp > &__lhs, const _Pointer_adapter< _Tp > &__rhs) — _Pointer_adapter >= _Pointer_adapter, same _Tp on both sides ✨
template<typename _Tp1, typename _Tp2> bool operator>= (const _Pointer_adapter< _Tp1 > &__lhs, _Tp2 __rhs) — and the mixed-type one with _Tp2 __rhs 🌸
template<typename _Tp1, typename _Tp2> bool operator>= (const _Pointer_adapter< _Tp1 > &__lhs, const _Pointer_adapter< _Tp2 > &__rhs) — and the different-_Tp two-adapter version, that's three in a row, ate 🎀
template<class _CharT, class _Alloc> bool operator>= (const _Rope_const_iterator< _CharT, _Alloc > &__x, const _Rope_const_iterator< _CharT, _Alloc > &__y) — _Rope_const_iterator greater-or-equal, __x and __y 💅
template<class _CharT, class _Alloc> bool operator>= (const _Rope_iterator< _CharT, _Alloc > &__x, const _Rope_iterator< _CharT, _Alloc > &__y) — mutable _Rope_iterator version, same deal 🔥
template<class _CharT, class _Alloc> bool operator>= (const rope< _CharT, _Alloc > &__x, const rope< _CharT, _Alloc > &__y) — rope >= rope, comparison arc fully slaying 🌈
template<class _Tp, class _Alloc> bool operator>= (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2) — and slist >= slist closes out the comparison saga, we made it 💜

okay and NOW we switch gears into the stream-extraction corner of the library, because the operator>> squad has entered the chat 😭

template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::beta_distribution< _RealType > &__x) — pulls a __gnu_cxx::beta_distribution< _RealType > out of the input stream __is 🍓
template<typename _UIntType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::hypergeometric_distribution< _UIntType > &__x) — same energy, but for __gnu_cxx::hypergeometric_distribution< _UIntType >, straight outta __is 🧚
template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > &__x) — yep, __gnu_cxx::normal_mv_distribution< _Dimen, _RealType > extraction, note the size_t _Dimen up front 💖
template<typename _UIntType, size_t __m, size_t __pos1, size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4, uint32_t __parity1, uint32_t __parity2, uint32_t __parity3, uint32_t __parity4, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::simd_fast_mersenne_twister_engine< _UIntType, __m, __pos1, __sl1, __sl2, __sr1, __sr2, __msk1, __msk2, __msk3, __msk4, __parity1, __parity2, __parity3, __parity4 > &__x) — okay this one is a MOUTHFUL, all those size_t and uint32_t template params are just for the __gnu_cxx::simd_fast_mersenne_twister_engine, and yes we stream it out of __is, lowkey iconic 😭
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::triangular_distribution< _RealType > &__x) — __gnu_cxx::triangular_distribution< _RealType > from __is, easy ✨
template<std::size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::uniform_inside_sphere_distribution< _Dimen, _RealType > &__x) — __gnu_cxx::uniform_inside_sphere_distribution< _Dimen, _RealType >, and note this one spells it std::size_t 🎀
template<std::size_t _Dimen, typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::uniform_on_sphere_distribution< _Dimen, _RealType > &__x) — the on-sphere sibling, __gnu_cxx::uniform_on_sphere_distribution< _Dimen, _RealType >, std::size_t again 🌸
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, __gnu_cxx::von_mises_distribution< _RealType > &__x) — __gnu_cxx::von_mises_distribution< _RealType > out of __is, fancy name, cute function 💅
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, arcsine_distribution< _RealType > &__x) — now we're in the ones that DON'T write the __gnu_cxx:: prefix, starting with arcsine_distribution< _RealType > 🦋
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, hoyt_distribution< _RealType > &__x) — hoyt_distribution< _RealType >, no prefix, still from __is 🔥
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, k_distribution< _RealType > &__x) — k_distribution< _RealType >, short name, big stream energy ⭐
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, logistic_distribution< _RealType > &__x) — logistic_distribution< _RealType >, yep 🌈
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, nakagami_distribution< _RealType > &__x) — nakagami_distribution< _RealType >, say it five times fast 💜
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, pareto_distribution< _RealType > &__x) — pareto_distribution< _RealType >, the 80/20 one, obsessed 🍓
template<typename _RealType, typename _CharT, typename _Traits> std::basic_istream< _CharT, _Traits > & operator>> (std::basic_istream< _CharT, _Traits > &__is, rice_distribution< _RealType > &__x) — and rice_distribution< _RealType > wraps up the no-prefix distribution crew 🧚
template<typename _Tp, typename _Integer> _Tp power (_Tp __x, _Integer __n) — returns _Tp, takes __x and an _Integer __n, classic power move (literally) 👑
template<typename _Tp, typename _Integer, typename _MonoidOperation> _Tp power (_Tp __x, _Integer __n, _MonoidOperation __monoid_op) — same but with a _MonoidOperation __monoid_op in the mix, fancy ✨
template<typename _InputIterator, typename _RandomAccessIterator> _RandomAccessIterator random_sample (_InputIterator __first, — and this one's getting cut off right here mid-signature, bestie, the rest of random_sample is waiting for us in the next part so don't go anywhere 💖

okay bestie we're back and the function list is STILL going — nobody said this page was short, and I refuse to skip a single one 💅 so here's the rest of the SYNOPSIS function crew, and yeah the first one is literally the tail end of an overload that started in the last part, mid-signature, no context, iconic of it honestly 😭

        _InputIterator __last, _RandomAccessIterator __out_first,
        _RandomAccessIterator __out_last)
template<typename _InputIterator, typename _RandomAccessIterator,
    typename _RandomNumberGenerator> _RandomAccessIterator random_sample
    (_InputIterator __first, _InputIterator __last,
    _RandomAccessIterator __out_first, _RandomAccessIterator __out_last,
    _RandomNumberGenerator &__rand)
template<typename _ForwardIterator, typename _OutputIterator, typename
    _Distance> _OutputIterator random_sample_n (_ForwardIterator
    __first, _ForwardIterator __last, _OutputIterator __out, const
    _Distance __n)
template<typename _ForwardIterator, typename _OutputIterator, typename
    _Distance, typename _RandomNumberGenerator> _OutputIterator
    random_sample_n (_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __out, const _Distance __n, _RandomNumberGenerator
    &__rand)
void rotate (_Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
    __first, _Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
    __middle, _Rope_iterator< char, __STL_DEFAULT_ALLOCATOR(char)>
    __last)
double stod (const __vstring &__str, std::size_t *__idx=0)
double stod (const __wvstring &__str, std::size_t *__idx=0)
float stof (const __vstring &__str, std::size_t *__idx=0)
float stof (const __wvstring &__str, std::size_t *__idx=0)
int stoi (const __vstring &__str, std::size_t *__idx=0, int __base=10)
int stoi (const __wvstring &__str, std::size_t *__idx=0, int __base=10)
long stol (const __vstring &__str, std::size_t *__idx=0, int __base=10)
long stol (const __wvstring &__str, std::size_t *__idx=0, int __base=10)
long double stold (const __vstring &__str, std::size_t *__idx=0)
long double stold (const __wvstring &__str, std::size_t *__idx=0)
long long stoll (const __vstring &__str, std::size_t *__idx=0, int
    __base=10)
long long stoll (const __wvstring &__str, std::size_t *__idx=0, int
    __base=10)
unsigned long stoul (const __vstring &__str, std::size_t *__idx=0, int
    __base=10)
unsigned long stoul (const __wvstring &__str, std::size_t *__idx=0, int
    __base=10)
unsigned long long stoull (const __vstring &__str, std::size_t *__idx,
    int __base=10)
unsigned long long stoull (const __wvstring &__str, std::size_t
    *__idx=0, int __base=10)
template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> void swap
    (__versa_string< _CharT, _Traits, _Alloc, _Base > &__lhs,
    __versa_string< _CharT, _Traits, _Alloc, _Base > &__rhs)
    Swap contents of two strings.
template<typename _Tp> void swap (_ExtPtr_allocator< _Tp > &__larg,
    _ExtPtr_allocator< _Tp > &__rarg)
template<class _CharT, class __Alloc> void swap (_Rope_char_ref_proxy<
    _CharT, __Alloc > __a, _Rope_char_ref_proxy< _CharT, __Alloc > __b)
template<class _Key, class _Tp, class _HashFn, class _EqlKey, class
    _Alloc> void swap (hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc >
    &__hm1, hash_map< _Key, _Tp, _HashFn, _EqlKey, _Alloc > &__hm2)
template<class _Key, class _Tp, class _HashFn, class _EqlKey, class
    _Alloc> void swap (hash_multimap< _Key, _Tp, _HashFn, _EqlKey,
    _Alloc > &__hm1, hash_multimap< _Key, _Tp, _HashFn, _EqlKey, _Alloc
    > &__hm2)
template<class _Val, class _HashFcn, class _EqualKey, class _Alloc> void
    swap (hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1,
    hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
template<class _Val, class _HashFcn, class _EqualKey, class _Alloc> void
    swap (hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1,
    hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
template<class _Val, class _Key, class _HF, class _Extract, class
    _EqKey, class _All> void swap (hashtable< _Val, _Key, _HF, _Extract,
    _EqKey, _All > &__ht1, hashtable< _Val, _Key, _HF, _Extract, _EqKey,
    _All > &__ht2)
template<class _CharT, class _Alloc> void swap (rope< _CharT, _Alloc >
    &__x, rope< _CharT, _Alloc > &__y)
template<class _Tp, class _Alloc> void swap (slist< _Tp, _Alloc > &__x,
    slist< _Tp, _Alloc > &__y)
template<typename _Cond> void swap (throw_value_base< _Cond > &__a,
    throw_value_base< _Cond > &__b)
__vstring to_string (double __val)
__vstring to_string (float __val)
__vstring to_string (int __val)
__vstring to_string (long __val)
__vstring to_string (long double __val)
__vstring to_string (long long __val)
__vstring to_string (unsigned __val)
__vstring to_string (unsigned long __val)
__vstring to_string (unsigned long long __val)
__wvstring to_wstring (double __val)
__wvstring to_wstring (float __val)
__wvstring to_wstring (int __val)
__wvstring to_wstring (long __val)
__wvstring to_wstring (long double __val)
__wvstring to_wstring (long long __val)
__wvstring to_wstring (unsigned __val)
__wvstring to_wstring (unsigned long __val)
__wvstring to_wstring (unsigned long long __val)
template<typename _InputIter, typename _Size, typename _ForwardIter>
    std::pair< _InputIter, _ForwardIter > uninitialized_copy_n
    (_InputIter __first, _Size __count, _ForwardIter __result)
    Copies the range [first,last) into result.

okay breathe. that was a lot. drink some water bestie 🫶

✨ VARIABLES ✨

these are the globals, the constants, the class-level static baddies that just exist and you don't even have to instantiate anything to reach them:

const _Lock_policy __default_lock_policy
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__e
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__gamma_e
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__ln_10
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__ln_2
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__ln_3
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__log10_e
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__log2_e
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__one_div_e
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__one_div_pi
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__one_div_root_2
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__phi
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__pi
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__pi_half
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__pi_quarter
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__pi_third
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__root_2
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__root_3
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__root_5
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__root_7
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__root_pi_div_2
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__two_div_pi
template<typename _RealType> constexpr _RealType __math_constants< _RealType >::__two_div_root_pi
template<typename _Value> const int __numeric_traits_floating< _Value >::__digits10
template<typename _Value> const bool __numeric_traits_floating< _Value >::__is_signed
template<typename _Value> const int __numeric_traits_floating< _Value >::__max_digits10
template<typename _Value> const int __numeric_traits_floating< _Value >::__max_exponent10
template<typename _Value> const int __numeric_traits_integer< _Value >::__digits
template<typename _Value> const bool __numeric_traits_integer< _Value >::__is_signed
template<typename _Value> const _Value __numeric_traits_integer< _Value >::__max
template<typename _Value> const _Value __numeric_traits_integer< _Value >::__min
template<typename _Tp> _Atomic_word __pool_alloc< _Tp >::_S_force_new
template<typename _CharT, typename _Traits, typename _Alloc> __rc_string_base< _CharT, _Traits, _Alloc >::_Rep_empty __rc_string_base< _CharT, _Traits, _Alloc >::_S_empty_rep
template<typename _CharT, typename _Traits, typename _Alloc, template< typename, typename, typename > class _Base> const __versa_string< _CharT, _Traits, _Alloc, _Base >::size_type __versa_string< _CharT, _Traits, _Alloc, _Base >::npos
template<typename _PrimeType> const _PrimeType _Hashtable_prime_list< _PrimeType >::__stl_prime_list [_S_num_primes]
template<typename _Tp> std::size_t bitmap_allocator< _Tp >::_S_block_size
template<typename _Tp> bitmap_allocator< _Tp >::_BPVector::size_type bitmap_allocator< _Tp >::_S_last_dealloc_index
template<typename _Tp> bitmap_allocator< _Tp >::_BPVector bitmap_allocator< _Tp >::_S_mem_blocks
template<typename _Tp> bitmap_allocator< _Tp >::__mutex_type bitmap_allocator< _Tp >::_S_mut
template<class _CharT, class _Alloc> rope< _CharT, _Alloc > identity_element (_Rope_Concat_fn< _CharT, _Alloc >)
template<class _CharT, class _Alloc> _CharT rope< _CharT, _Alloc >::_S_empty_c_str [1]
template<class _CharT, class _Alloc> const unsigned long rope< _CharT, _Alloc >::_S_min_len [int(__detail::_S_max_rope_depth)+1]
template<class _CharT, class _Alloc> const rope< _CharT, _Alloc >::size_type rope< _CharT, _Alloc >::npos

that's the whole variable roster, no cuts, no edits, we do not gatekeep here 💖

🌸 DETAILED DESCRIPTION 🌸

GNU extensions for public use.

that's it. that's the whole description. short king energy but we respect it 👑

🎀 TYPEDEF DOCUMENTATION 🎀

template<typename _Tp> using __gnu_cxx::__int_traits

Convenience alias for __numeric_traits<integer-type>.

one whole typedef, one whole line of description, and it's still doing the most for you — a cute little shortcut name so you don't have to type the whole traits thing. slay ✨

💅 FUNCTION DOCUMENTATION 💅

okay now we get into the actual documented functions, the ones with real prose attached, let's go 🦋

template<typename _ToType, typename _FromType> _ToType __gnu_cxx::__static_pointer_cast (_FromType * __arg) [inline]

Casting operations for cases where _FromType is a standard pointer. _ToType can be a standard or non-standard pointer.

so: you've got a normal-ass pointer coming in, and the thing you're casting to might be a normal pointer or one of those fancy custom ones. either way, this handles it 💫

template<typename _ToType, typename _FromType> _ToType __gnu_cxx::__static_pointer_cast (const _FromType & __arg) [inline]

Casting operations for cases where _FromType is not a standard pointer. _ToType can be a standard or non-standard pointer. Given that _FromType is not a pointer, it must have a get() method that returns the standard pointer equivalent of the address it points to, and must have an element_type typedef which names the type it points to.

heads up bestie: if _FromType isn't a real pointer, this overload has requirements. it needs that get() method and that element_type typedef or it's simply not going to work. no cap 🔥

std::size_t __gnu_cxx::_Bit_scan_forward (std::size_t __num) [inline]

Generic Version of the bsf instruction.

Referenced by __gnu_cxx::bitmap_allocator< _Tp1 >::_M_allocate_single_object().

found the first set bit, moving on, that's the vibe 💀

and we are STILL not done, the function docs keep rolling, so stay with me bestie, more coming in the next part 💜

`std::iota` 🌈

template<typename _ForwardIterator, typename _Tp> void std::iota
    (_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
    [constexpr]

bestie this one is a whole vibe 💅 it makes you a range of sequentially increasing values, no cap. for every element in the range [first,last) it assigns value and then increments value as if by ++value. so you hand it a starting number and it just goes up and up and up for the whole range. iconic fr fr.

Parameters — the receipts:

__first — start of range 🫶
__last — end of range 🌸
__value — starting value ⭐

`__gnu_cxx::operator!=` (`__versa_string` vs `__versa_string`) 💖

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

test if two strings are different, periodt.

__lhs — first string 🌸
__rhs — second string 🌸

Returns — true if __lhs.compare(__rhs) != 0, false otherwise ✨

`__gnu_cxx::operator!=` (`__versa_string` vs C string) 💖

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

test if a string and a C string are different 🦋

__lhs — string 💜
__rhs — C string 💜

Returns — true if __lhs.compare(__rhs) != 0, false otherwise ✨

`__gnu_cxx::operator!=` (C string vs `__versa_string`) 💖

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator!=
    (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
    _Base > & __rhs) [inline]

test if a C string and a string are different 🌸

__lhs — C string 🎀
__rhs — string 🎀

Returns — true if __rhs.compare(__lhs) != 0, false otherwise ✨

note the flip bestie: it's __rhs.compare(__lhs) here, not the other way round 👀

`__gnu_cxx::operator+` (`_CharT` + `__versa_string`) 🔥

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (_CharT __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs)

concatenate a character and a string, slay 🎀

__lhs — first string ✨
__rhs — last string ✨

Returns — a new string with __lhs followed by __rhs 💖

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::append(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::push_back(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::reserve(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

`__gnu_cxx::operator+` (`__versa_string` + `_CharT`) 🔥

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string<
    _CharT, _Traits, _Alloc, _Base > & __lhs, _CharT __rhs)

concatenate a string and a character, same energy, other direction 💅

__lhs — first string ✨
__rhs — last string ✨

Returns — a new string with __lhs followed by __rhs 💖

`__gnu_cxx::operator+` (`__versa_string` + `__versa_string`) 🔥

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string<
    _CharT, _Traits, _Alloc, _Base > & __lhs, const __versa_string< _CharT,
    _Traits, _Alloc, _Base > & __rhs)

concatenate two strings, the classic 😌💖

__lhs — first string ✨
__rhs — last string ✨

Returns — a new string with the value of __lhs followed by __rhs 🌈

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::append(), __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::reserve(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

heads up: no push_back() in this one's reference list, don't let anyone tell you otherwise 🙈

`__gnu_cxx::operator+` (`__versa_string` + C string) 🔥

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const __versa_string<
    _CharT, _Traits, _Alloc, _Base > & __lhs, const _CharT * __rhs)

concatenate a string and a C string 🦋

__lhs — first string ✨
__rhs — last string ✨

Returns — a new string with __lhs followed by __rhs 💖

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

`__gnu_cxx::operator+` (C string + `__versa_string`) 🔥

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> __versa_string< _CharT,
    _Traits, _Alloc, _Base > __gnu_cxx::operator+ (const _CharT * __lhs,
    const __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs)

concatenate a C string and a string 🦋

__lhs — first string ✨
__rhs — last string ✨

Returns — a new string with the value of __lhs followed by __rhs 🌈

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

`__gnu_cxx::operator<` (`__versa_string` vs `__versa_string`) 🌊

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

test if one string comes before another 🎀

__lhs — first string 💜
__rhs — second string 💜

Returns — true if __lhs precedes __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator<` (`__versa_string` vs C string) 🌊

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

test if a string comes before a C string 🌸

__lhs — string 💜
__rhs — C string 💜

Returns — true if __lhs precedes __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator<` (C string vs `__versa_string`) 🌊

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<
    (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
    _Base > & __rhs) [inline]

test if a C string comes before a string 🌸

__lhs — C string 💜
__rhs — string 💜

Returns — true if __lhs precedes __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator<=` (`__versa_string` vs `__versa_string`) 🍃

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

test if one string doesn't follow another 🌸

__lhs — first string 💜
__rhs — second string 💜

Returns — true if __lhs doesn't follow __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator<=` (`__versa_string` vs C string) 🍃

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<=
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

test if a string doesn't follow a C string 🌸

__lhs — string 💜
__rhs — C string 💜

Returns — true if __lhs doesn't follow __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator<=` (C string vs `__versa_string`) 🍃

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator<=
    (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
    _Base > & __rhs) [inline]

test if a C string doesn't follow a string 🌸

__lhs — C string 💜
__rhs — string 💜

Returns — true if __lhs doesn't follow __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator==` (`__versa_string` vs `__versa_string`) ✅

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator==
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

test if two strings are the same, the moment of truth 😌

__lhs — first string 💜
__rhs — second string 💜

Returns — true if __lhs.compare(__rhs) == 0, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::data(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

`__gnu_cxx::operator==` (`__versa_string` vs C string) ✅

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator==
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

test if a string and a C string are the same 🌸

__lhs — string 💜
__rhs — C string 💜

Returns — true if __lhs.compare(__rhs) == 0, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::data(), and __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::size() 👑

`__gnu_cxx::operator==` (C string vs `__versa_string`) ✅

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator==
    (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
    _Base > & __rhs) [inline]

test if a C string and a string are the same 🌸

__lhs — C string 💜
__rhs — string 💜

Returns — true if __rhs.compare(__lhs) == 0, false otherwise ✨

again bestie, the compare goes __rhs.compare(__lhs) — flipped, but make it fashion 💅

`__gnu_cxx::operator==` (`_Pointer_adapter` vs `_Pointer_adapter`) 🌈✨

template<typename _Tp> bool __gnu_cxx::operator== (const _Pointer_adapter<
    _Tp > & __lhs, const _Pointer_adapter< _Tp > & __rhs) [inline]

comparison operators for _Pointer_adapter defer to the base class' comparison operators, when possible 👑 no cap, it just hands the job off when it can.

`__gnu_cxx::operator>` (`__versa_string` vs `__versa_string`) 💙

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator>
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

test if one string follows another 🎀

__lhs — first string 💜
__rhs — second string 💜

Returns — true if __lhs follows __rhs, false otherwise ✨

References — __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare() 🔍

`__gnu_cxx::operator>` (`__versa_string` vs C string) 💙

template<typename _CharT, typename _Traits, typename _Alloc, template<
    typename, typename, typename > class _Base> bool __gnu_cxx::operator>
    (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
    _CharT * __rhs) [inline]

test if a string follows a C string 🌸

__lhs — string 💜
__rhs — C string 💜

Returns — true if __lhs follows __rhs, false otherwise ✨

References __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare(). 💖

`operator>` — Test if C string follows string. ✨

   template<typename _CharT, typename _Traits, typename _Alloc, template<
       typename, typename, typename > class _Base> bool __gnu_cxx::operator>
       (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
       _Base > & __rhs) [inline]

Parameters:
- __lhs — C string. (the little C-string bestie) 🎀
- __rhs — String. (the big string energy) 🦋
Returns: True if __lhs follows __rhs. False otherwise. 💅
References: __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

`operator>=` — Test if string doesn't precede string. 🌸

   template<typename _CharT, typename _Traits, typename _Alloc, template<
       typename, typename, typename > class _Base> bool __gnu_cxx::operator>=
       (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
       __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Parameters:
- __lhs — First string.
- __rhs — Second string.
Returns: True if __lhs doesn't precede __rhs. False otherwise. 🦋
References: __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

`operator>=` — Test if string doesn't precede C string. ✨

   template<typename _CharT, typename _Traits, typename _Alloc, template<
       typename, typename, typename > class _Base> bool __gnu_cxx::operator>=
       (const __versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs, const
       _CharT * __rhs) [inline]

Parameters:
- __lhs — String.
- __rhs — C string.
Returns: True if __lhs doesn't precede __rhs. False otherwise. 🌸
References: __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

`operator>=` — Test if C string doesn't precede string. 💖

   template<typename _CharT, typename _Traits, typename _Alloc, template<
       typename, typename, typename > class _Base> bool __gnu_cxx::operator>=
       (const _CharT * __lhs, const __versa_string< _CharT, _Traits, _Alloc,
       _Base > & __rhs) [inline]

Parameters:
- __lhs — C string.
- __rhs — String.
Returns: True if __lhs doesn't precede __rhs. False otherwise. ✨
References: __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::compare().

`swap` — Swap contents of two strings. ⚡️

   template<typename _CharT, typename _Traits, typename _Alloc, template<
       typename, typename, typename > class _Base> void __gnu_cxx::swap
       (__versa_string< _CharT, _Traits, _Alloc, _Base > & __lhs,
       __versa_string< _CharT, _Traits, _Alloc, _Base > & __rhs) [inline]

Parameters:
- __lhs — First string.
- __rhs — Second string.
Exchanges the contents of __lhs and __rhs in constant time. ⚡️
References: __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >::swap().

Author

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

And that's the whole vibe, bestie! This page is from libstdc++ and the footer says __gnu_cxx(3) — no date in sight, but it's timeless, periodt. 💖✨

📦 where this page comes from

arch rolling: gcc 16.2.1+r23+gd564253eb6c8-1 · GPL-3.0-or-later WITH GCC-exception-3.1 AND GFDL-1.3-or-later
fedora 44: libstdc++-docs 16.2.1-2.fc44
fedora 44: libstdc++-docs 16.2.1-3.fc44 · GPL-3.0-or-later AND LGPL-3.0-or-later AND (GPL-3.0-or-later WITH GCC-exception-3.1) AND (GPL-3.0-or-later WITH Texinfo-exception) AND (LGPL-2.1-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GNU-compiler-exception) AND BSL-1.0 AND GFDL-1.3-or-later AND Linux-man-pages-copyleft-2-para AND SunPro AND BSD-1-Clause AND BSD-2-Clause AND BSD-2-Clause-Views AND BSD-3-Clause AND BSD-4-Clause AND BSD-Source-Code AND Zlib AND MIT AND Apache-2.0 AND (Apache-2.0 WITH LLVM-Exception) AND ZPL-2.1 AND ISC AND LicenseRef-Fedora-Public-Domain AND HP-1986 AND curl AND Martin-Birgmeier AND HPND-Markus-Kuhn AND dtoa AND SMLNJ AND AMD-newlib AND OAR AND HPND-merchantability-variant AND HPND-Intel
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

__gnu_cxx(3)

✨ NAME ✨

🦋 SYNOPSIS 🦋

🌸 Namespaces 🌸

👑 Classes 👑

🎀 Typedefs 🎀

💜 Enumerations 💜

Functions ✨💅

✨ identity_element ✨

🌀 iota

🌸 is_heap

🌸 is_sorted

🔥 lexicographical_compare_3way

🎀 mem_fun1

🎀 mem_fun1_ref

🚫 operator!= — the "not equal" committee 🚫

✖️ operator* (for throw_value_base)

➕ operator+ — the concatenation cinematic universe 🌈

versa_string operator+

rope / iterator operator+

throw_value_base operator+

std::ptrdiff_t on the left operator+

➕= operator+= (rope only, but make it count) 🧵

➖ operator-

🌸 operator< — the "who comes first" committee 🌸

🦋 operator<< — the print-it-out besties 🦋

💜 operator<= — "doesn't follow", very demure 💜

✨ operator== — the equivalence girlies, they ate ✨

✨ VARIABLES ✨

🌸 DETAILED DESCRIPTION 🌸

🎀 TYPEDEF DOCUMENTATION 🎀

template&lt;typename _Tp&gt; using __gnu_cxx::__int_traits

💅 FUNCTION DOCUMENTATION 💅

template&lt;typename _ToType, typename _FromType&gt; _ToType __gnu_cxx::__static_pointer_cast (_FromType * __arg) [inline]

template&lt;typename _ToType, typename _FromType&gt; _ToType __gnu_cxx::__static_pointer_cast (const _FromType & __arg) [inline]

std::size_t __gnu_cxx::_Bit_scan_forward (std::size_t __num) [inline]

std::iota 🌈

__gnu_cxx::operator!= (__versa_string vs __versa_string) 💖

__gnu_cxx::operator!= (__versa_string vs C string) 💖

__gnu_cxx::operator!= (C string vs __versa_string) 💖

__gnu_cxx::operator+ (_CharT + __versa_string) 🔥

__gnu_cxx::operator+ (__versa_string + _CharT) 🔥

__gnu_cxx::operator+ (__versa_string + __versa_string) 🔥

__gnu_cxx::operator+ (__versa_string + C string) 🔥

__gnu_cxx::operator+ (C string + __versa_string) 🔥

__gnu_cxx::operator< (__versa_string vs __versa_string) 🌊

__gnu_cxx::operator< (__versa_string vs C string) 🌊

__gnu_cxx::operator< (C string vs __versa_string) 🌊

__gnu_cxx::operator<= (__versa_string vs __versa_string) 🍃

__gnu_cxx::operator<= (__versa_string vs C string) 🍃

__gnu_cxx::operator<= (C string vs __versa_string) 🍃

__gnu_cxx::operator== (__versa_string vs __versa_string) ✅

__gnu_cxx::operator== (__versa_string vs C string) ✅

__gnu_cxx::operator== (C string vs __versa_string) ✅

__gnu_cxx::operator== (_Pointer_adapter vs _Pointer_adapter) 🌈✨

__gnu_cxx::operator> (__versa_string vs __versa_string) 💙

__gnu_cxx::operator> (__versa_string vs C string) 💙

operator> — Test if C string follows string. ✨

operator>= — Test if string doesn't precede string. 🌸

operator>= — Test if string doesn't precede C string. ✨

operator>= — Test if C string doesn't precede string. 💖

swap — Swap contents of two strings. ⚡️

Author

✨ `identity_element` ✨

🌀 `iota`

🌸 `is_heap`

🌸 `is_sorted`

🔥 `lexicographical_compare_3way`

🎀 `mem_fun1`

🎀 `mem_fun1_ref`

🚫 `operator!=` — the "not equal" committee 🚫

✖️ `operator*` (for `throw_value_base`)

➕ `operator+` — the concatenation cinematic universe 🌈

versa_string `operator+`

rope / iterator `operator+`

throw_value_base `operator+`

`std::ptrdiff_t` on the left `operator+`

➕= `operator+=` (rope only, but make it count) 🧵

➖ `operator-`

🌸 `operator<` — the "who comes first" committee 🌸

🦋 `operator<<` — the print-it-out besties 🦋

💜 `operator<=` — "doesn't follow", very demure 💜

✨ `operator==` — the equivalence girlies, they ate ✨

template<typename _Tp> using __gnu_cxx::__int_traits

template<typename _ToType, typename _FromType> _ToType __gnu_cxx::__static_pointer_cast (_FromType * __arg) [inline]

template<typename _ToType, typename _FromType> _ToType __gnu_cxx::__static_pointer_cast (const _FromType & __arg) [inline]

`std::iota` 🌈

`__gnu_cxx::operator!=` (`__versa_string` vs `__versa_string`) 💖

`__gnu_cxx::operator!=` (`__versa_string` vs C string) 💖

`__gnu_cxx::operator!=` (C string vs `__versa_string`) 💖

`__gnu_cxx::operator+` (`_CharT` + `__versa_string`) 🔥

`__gnu_cxx::operator+` (`__versa_string` + `_CharT`) 🔥

`__gnu_cxx::operator+` (`__versa_string` + `__versa_string`) 🔥

`__gnu_cxx::operator+` (`__versa_string` + C string) 🔥

`__gnu_cxx::operator+` (C string + `__versa_string`) 🔥

`__gnu_cxx::operator<` (`__versa_string` vs `__versa_string`) 🌊

`__gnu_cxx::operator<` (`__versa_string` vs C string) 🌊

`__gnu_cxx::operator<` (C string vs `__versa_string`) 🌊

`__gnu_cxx::operator<=` (`__versa_string` vs `__versa_string`) 🍃

`__gnu_cxx::operator<=` (`__versa_string` vs C string) 🍃

`__gnu_cxx::operator<=` (C string vs `__versa_string`) 🍃

`__gnu_cxx::operator==` (`__versa_string` vs `__versa_string`) ✅

`__gnu_cxx::operator==` (`__versa_string` vs C string) ✅

`__gnu_cxx::operator==` (C string vs `__versa_string`) ✅

`__gnu_cxx::operator==` (`_Pointer_adapter` vs `_Pointer_adapter`) 🌈✨

`__gnu_cxx::operator>` (`__versa_string` vs `__versa_string`) 💙

`__gnu_cxx::operator>` (`__versa_string` vs C string) 💙

`operator>` — Test if C string follows string. ✨

`operator>=` — Test if string doesn't precede string. 🌸

`operator>=` — Test if string doesn't precede C string. ✨

`operator>=` — Test if C string doesn't precede string. 💖

`swap` — Swap contents of two strings. ⚡️