| C__gnu_parallel::__accumulate_binop_reduct< _BinOp > | General reduction, using a binary operator |
| Cstd::__add_pointer_helper< _Tp, bool > | Add_pointer |
| Cstd::__add_pointer_helper< _Tp > | |
| Cstd::__allocated_ptr< _Alloc > | Non-standard RAII type for managing pointers obtained from allocators |
| Cstd::__atomic_base< _ITp > | Base class for atomic integrals |
| Cstd::__atomic_base< _PTp * > | Partial specialization for pointer types |
| Cstd::__atomic_base< _Tp * > | |
| Cstd::__atomic_base< bool > | |
| ▼Cstd::__atomic_base< char > | |
| Cstd::atomic< char > | Explicit specialization for char |
| ▼Cstd::__atomic_base< char16_t > | |
| Cstd::atomic< char16_t > | Explicit specialization for char16_t |
| ▼Cstd::__atomic_base< char32_t > | |
| Cstd::atomic< char32_t > | Explicit specialization for char32_t |
| ▼Cstd::__atomic_base< int > | |
| Cstd::atomic< int > | Explicit specialization for int |
| ▼Cstd::__atomic_base< long > | |
| Cstd::atomic< long > | Explicit specialization for long |
| ▼Cstd::__atomic_base< long long > | |
| Cstd::atomic< long long > | Explicit specialization for long long |
| ▼Cstd::__atomic_base< short > | |
| Cstd::atomic< short > | Explicit specialization for short |
| ▼Cstd::__atomic_base< signed char > | |
| Cstd::atomic< signed char > | Explicit specialization for signed char |
| ▼Cstd::__atomic_base< unsigned char > | |
| Cstd::atomic< unsigned char > | Explicit specialization for unsigned char |
| ▼Cstd::__atomic_base< unsigned int > | |
| Cstd::atomic< unsigned int > | Explicit specialization for unsigned int |
| ▼Cstd::__atomic_base< unsigned long > | |
| Cstd::atomic< unsigned long > | Explicit specialization for unsigned long |
| ▼Cstd::__atomic_base< unsigned long long > | |
| Cstd::atomic< unsigned long long > | Explicit specialization for unsigned long long |
| ▼Cstd::__atomic_base< unsigned short > | |
| Cstd::atomic< unsigned short > | Explicit specialization for unsigned short |
| ▼Cstd::__atomic_base< wchar_t > | |
| Cstd::atomic< wchar_t > | Explicit specialization for wchar_t |
| ▼Cstd::__atomic_flag_base | Base type for atomic_flag |
| Cstd::atomic_flag | Atomic_flag |
| C__gnu_cxx::__common_pool_policy< _PoolTp, _Thread > | Policy for shared __pool objects |
| Cstd::__detector< _Default, _AlwaysVoid, _Op, _Args > | Implementation of the detection idiom (negative case) |
| Cstd::__detector< _Default, __void_t< _Op< _Args... > >, _Op, _Args... > | Implementation of the detection idiom (positive case) |
| ▼Cstd::tr2::__dynamic_bitset_base< _WordT, _Alloc > | |
| Cstd::tr2::dynamic_bitset< _WordT, _Alloc > | The dynamic_bitset class represents a sequence of bits |
| C__cxxabiv1::__forced_unwind | Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding |
| ▼Cstd::__future_base | Base class and enclosing scope |
| ▼Cstd::__basic_future< _Res &> | |
| Cstd::future< _Res & > | Partial specialization for future<R&> |
| Cstd::shared_future< _Res & > | Partial specialization for shared_future<R&> |
| ▼Cstd::__basic_future< void > | |
| Cstd::future< void > | Explicit specialization for future<void> |
| Cstd::shared_future< void > | Explicit specialization for shared_future<void> |
| ▼Cstd::__basic_future< _Res > | Common implementation for future and shared_future |
| Cstd::future< _Res > | Primary template for future |
| Cstd::shared_future< _Res > | Primary template for shared_future |
| ▼C__gnu_parallel::__generic_find_selector | Base class of all __gnu_parallel::__find_template selectors |
| C__gnu_parallel::__adjacent_find_selector | Test predicate on two adjacent elements |
| C__gnu_parallel::__find_first_of_selector< _FIterator > | Test predicate on several elements |
| C__gnu_parallel::__find_if_selector | Test predicate on a single element, used for std::find() and std::find_if () |
| C__gnu_parallel::__mismatch_selector | Test inverted predicate on a single element |
| ▼C__gnu_parallel::__generic_for_each_selector< _It > | Generic __selector for embarrassingly parallel functions |
| C__gnu_parallel::__accumulate_selector< _It > | Std::accumulate() selector |
| C__gnu_parallel::__adjacent_difference_selector< _It > | Selector that returns the difference between two adjacent __elements |
| C__gnu_parallel::__count_if_selector< _It, _Diff > | Std::count_if () selector |
| C__gnu_parallel::__count_selector< _It, _Diff > | Std::count() selector |
| C__gnu_parallel::__fill_selector< _It > | Std::fill() selector |
| C__gnu_parallel::__for_each_selector< _It > | Std::for_each() selector |
| C__gnu_parallel::__generate_selector< _It > | Std::generate() selector |
| C__gnu_parallel::__identity_selector< _It > | Selector that just returns the passed iterator |
| C__gnu_parallel::__inner_product_selector< _It, _It2, _Tp > | Std::inner_product() selector |
| C__gnu_parallel::__replace_if_selector< _It, _Op, _Tp > | Std::replace() selector |
| C__gnu_parallel::__replace_selector< _It, _Tp > | Std::replace() selector |
| C__gnu_parallel::__transform1_selector< _It > | Std::transform() __selector, one input sequence variant |
| C__gnu_parallel::__transform2_selector< _It > | Std::transform() __selector, two input sequences variant |
| Cstd::__is_location_invariant< _Tp > | |
| C__gnu_parallel::__max_element_reduct< _Compare, _It > | Reduction for finding the maximum element, using a comparator |
| C__gnu_parallel::__min_element_reduct< _Compare, _It > | Reduction for finding the maximum element, using a comparator |
| C__gnu_cxx::__detail::__mini_vector< _Tp > | __mini_vector<> is a stripped down version of the full-fledged std::vector<> |
| ▼C__gnu_cxx::__mt_alloc_base< _Tp > | Base class for _Tp dependent member functions |
| C__gnu_cxx::__mt_alloc< _Tp, _Poolp > | 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).Further details: https://gcc.gnu.org/onlinedocs/libstdc++/manual/mt_allocator.html |
| C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 3-way merging with __sentinels turned off |
| C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 3-way merging with __sentinels turned on |
| C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 4-way merging with __sentinels turned off |
| C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 4-way merging with __sentinels turned on |
| C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for k-way merging with __sentinels turned on |
| C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for k-way merging with __sentinels turned off |
| ▼Cstd::__numeric_limits_base | Part of std::numeric_limits |
| Cstd::numeric_limits< _Tp > | Properties of fundamental types |
| C__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread > | Policy for individual __pool objects |
| C__gnu_cxx::__pool< _Thread > | Data describing the underlying memory pool, parameterized on threading support |
| ▼C__gnu_cxx::__pool_alloc_base | Base class for __pool_alloc |
| C__gnu_cxx::__pool_alloc< _Tp > | Allocator using a memory pool with a single lock |
| ▼C__gnu_cxx::__pool_base | Base class for pool object |
| C__gnu_cxx::__pool< false > | Specialization for single thread |
| C__gnu_cxx::__pool< true > | Specialization for thread enabled, via gthreads.h |
| C__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc > | |
| Cstd::tr2::__reflection_typelist< _Elements > | |
| Cstd::tr2::__reflection_typelist< _First, _Rest... > | Partial specialization |
| Cstd::tr2::__reflection_typelist<> | Specialization for an empty typelist |
| C__gnu_cxx::__scoped_lock | Scoped lock idiom |
| C__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > | Template class __versa_string.Data structure managing sequences of characters and character-like objects |
| C__gnu_debug::_After_nth_from< _Iterator > | |
| Cstd::_Base_bitset< _Nw > | |
| Cstd::_Base_bitset< 0 > | |
| Cstd::_Base_bitset< 1 > | |
| ▼Cstd::_Base_bitset<((_Nb)/(__CHAR_BIT__ *__SIZEOF_LONG__)+((_Nb) %(__CHAR_BIT__ *__SIZEOF_LONG__)==0 ? 0 :1))> | |
| Cstd::bitset< _Nb > | The bitset class represents a fixed-size sequence of bits.(Note that bitset does not meet the formal requirements of a container. Mainly, it lacks iterators.) |
| C__gnu_debug::_BeforeBeginHelper< _Sequence > | |
| Cstd::_Bind< _Signature > | Type of the function object returned from bind() |
| Cstd::_Bind_result< _Result, _Signature > | Type of the function object returned from bind<R>() |
| C__gnu_cxx::__detail::_Bitmap_counter< _Tp > | The bitmap counter which acts as the bitmap manipulator, and manages the bit-manipulation functions and the searching and identification functions on the bit-map |
| C__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block *> | |
| Cstd::__detail::_BracketMatcher< _TraitsT, __icase, __collate > | Matches a character range (bracket expression) |
| C__gnu_cxx::_Caster< _ToType > | |
| C__gnu_cxx::_Char_types< _CharT > | Mapping from character type to associated types |
| ▼C__gnu_pbds::detail::pat_trie_base::_CIter< Node, Leaf, Head, Inode, Is_Forward_Iterator > | Const iterator |
| C__gnu_pbds::detail::pat_trie_base::_Iter< Node, Leaf, Head, Inode, Is_Forward_Iterator > | Iterator |
| Cstd::__detail::_Compiler< _TraitsT > | Builds an NFA from an input iterator range |
| Cstd::__parallel::_CRandNumber< _MustBeInt > | Functor wrapper for std::rand() |
| Cstd::__detail::_Default_ranged_hash | Default ranged hash function H. In principle it should be a function object composed from objects of type H1 and H2 such that h(k, N) = h2(h1(k), N), but that would mean making extra copies of h1 and h2. So instead we'll just use a tag to tell class template hashtable to do that composition |
| ▼Cstd::_Deque_base< _Tp, _Alloc > | |
| Cstd::deque< _Tp, _Alloc > | A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end |
| ▼Cstd::_Deque_base< _StateSeqT, std::allocator< _StateSeqT > > | |
| Cstd::deque< _StateSeqT > | |
| Cstd::_Deque_iterator< _Tp, _Ref, _Ptr > | A deque::iterator |
| Cstd::_Deque_iterator< _Tp, _Tp &, _Ptr > | |
| C__gnu_parallel::_DRandomShufflingGlobalData< _RAIter > | Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle() |
| C__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator > | Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle() |
| C__gnu_parallel::_DummyReduct | Reduction function doing nothing |
| ▼Cstd::_Enable_copy_move< _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag > | A mixin helper to conditionally enable or disable the copy/move special members |
| Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag > | A mixin helper to conditionally enable or disable the special members |
| ▼Cstd::_Enable_copy_move< is_copy_constructible< _Tp >::value, __and_< is_copy_constructible< _Tp >, is_copy_assignable< _Tp > >::value, is_move_constructible< _Tp >::value, __and_< is_move_constructible< _Tp >, is_move_assignable< _Tp > >::value, optional< _Tp > > | |
| Cstd::experimental::fundamentals_v1::optional< _Tp > | Class template for optional values |
| Cstd::_Enable_default_constructor< _Switch, _Tag > | A mixin helper to conditionally enable or disable the default constructor |
| ▼Cstd::_Enable_default_constructor< _Default, _Tag > | |
| Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag > | A mixin helper to conditionally enable or disable the special members |
| Cstd::_Enable_destructor< _Switch, _Tag > | A mixin helper to conditionally enable or disable the default destructor |
| ▼Cstd::_Enable_destructor< _Destructor, _Tag > | |
| Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag > | A mixin helper to conditionally enable or disable the special members |
| C__gnu_debug::_Equal_to< _Type > | |
| ▼Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| ▼Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Unordered_multiset and unordered_multimap specializations |
| Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Unordered_map and unordered_set specializations |
| Cstd::__detail::_Executor< _BiIter, _Alloc, _TraitsT, __dfs_mode > | Takes a regex and an input string and does the matching |
| C__gnu_cxx::_ExtPtr_allocator< _Tp > | An example allocator which uses a non-standard pointer type.This allocator specifies that containers use a 'relative pointer' as it's pointer type. (See ext/pointer.h) Memory allocation in this example is still performed using std::allocator |
| ▼Cstd::_Function_base | Base class of all polymorphic function object wrappers |
| Cstd::function< _Res(_ArgTypes...)> | Primary class template for std::function.Polymorphic function wrapper |
| ▼Cstd::_Fwd_list_base< _Tp, _Alloc > | Base class for forward_list |
| Cstd::forward_list< _Tp, _Alloc > | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence |
| Cstd::_Fwd_list_const_iterator< _Tp > | A forward_list::const_iterator |
| Cstd::_Fwd_list_iterator< _Tp > | A forward_list::iterator |
| ▼Cstd::_Fwd_list_node_base | A helper basic node class for forward_list. This is just a linked list with nothing inside it. There are purely list shuffling utility methods here |
| Cstd::_Fwd_list_node< _Tp > | A helper node class for forward_list. This is just a linked list with uninitialized storage for a data value in each node. There is a sorting utility method |
| C__gnu_parallel::_GuardedIterator< _RAIter, _Compare > | _Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code > | |
| ▼Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, _Traits::__hash_cached::value > | |
| ▼Cstd::__detail::_Hashtable_base< _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::__detail::_Hash_node< _Value, _Cache_hash_code > | |
| ▼Cstd::__detail::_Hash_node_base | |
| ▼Cstd::__detail::_Hash_node_value_base< _Value > | |
| Cstd::__detail::_Hash_node< _Value, false > | |
| Cstd::__detail::_Hash_node< _Value, true > | |
| Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, __use_ebo > | |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 0, __alloc_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > > > | |
| ▼Cstd::__detail::_Hashtable_alloc< __alloc_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > > > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 0, _Equal > | |
| Cstd::__detail::_Hashtable_base< _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits > | |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 0, _ExtractKey > | |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false > | Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11 |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true > | Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11 |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, false > | Specialization: ranged hash function, no caching hash codes. H1 and H2 are provided but ignored. We define a dummy hash code type |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 0, _H2 > | |
| Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, true > | Partial specialization used when nodes contain a cached hash code |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 0, _NodeAlloc > | |
| ▼Cstd::__detail::_Hashtable_alloc< _NodeAlloc > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 1, _H1 > | |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false > | Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11 |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true > | Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11 |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 1, _Hash > | |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, false > | Specialization: ranged hash function, no caching hash codes. H1 and H2 are provided but ignored. We define a dummy hash code type |
| ▼Cstd::__detail::_Hashtable_ebo_helper< 2, _H2 > | |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false > | Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11 |
| Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true > | Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11 |
| Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, false > | Specialization not using EBO |
| Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, true > | Specialization using EBO |
| Cstd::__detail::_Hashtable_traits< _Cache_hash_code, _Constant_iterators, _Unique_keys > | |
| ▼Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Constant_iterators > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| ▼Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| ▼Cstd::__detail::_Insert_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Specialization |
| Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Specialization |
| C__gnu_cxx::_Invalid_type | |
| C__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory > | A triple of iterators. The usual iterator operations are applied to all three child iterators |
| C__gnu_parallel::_Job< _DifferenceTp > | One __job for a certain thread |
| ▼Cstd::_List_base< _Tp, _Alloc > | See bits/stl_deque.h's _Deque_base for an explanation |
| Cstd::list< _Tp, _Alloc > | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence |
| ▼Cstd::_List_base< __inp, __rebind_inp > | |
| Cstd::list< __inp, __rebind_inp > | |
| Cstd::_List_const_iterator< _Tp > | A list::const_iterator |
| Cstd::_List_iterator< _Tp > | A list::iterator |
| ▼Cstd::__detail::_List_node_base | Common part of a node in the list |
| Cstd::__detail::_List_node_header | The list node header |
| Cstd::_List_node< _Tp > | An actual node in the list |
| Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code > | |
| ▼Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache > | |
| Cstd::__detail::_Local_const_iterator< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __constant_iterators, __cache > | Local const_iterators |
| Cstd::__detail::_Local_iterator< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __constant_iterators, __cache > | Local iterators |
| C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_Loser | Internal representation of a _LoserTree element |
| C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_Loser | Internal representation of _LoserTree __elements |
| ▼C__gnu_parallel::_LoserTreeBase< _Tp, _Compare > | Guarded loser/tournament tree |
| C__gnu_parallel::_LoserTree< __stable, _Tp, _Compare > | Stable _LoserTree variant |
| C__gnu_parallel::_LoserTree< false, _Tp, _Compare > | Unstable _LoserTree variant |
| ▼C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare > | Base class of _Loser Tree implementation using pointers |
| C__gnu_parallel::_LoserTreePointer< __stable, _Tp, _Compare > | Stable _LoserTree implementation |
| C__gnu_parallel::_LoserTreePointer< false, _Tp, _Compare > | Unstable _LoserTree implementation |
| ▼C__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare > | Unguarded loser tree, keeping only pointers to the elements in the tree structure |
| C__gnu_parallel::_LoserTreePointerUnguarded< __stable, _Tp, _Compare > | Stable unguarded _LoserTree variant storing pointers |
| C__gnu_parallel::_LoserTreePointerUnguarded< false, _Tp, _Compare > | Unstable unguarded _LoserTree variant storing pointers |
| C__gnu_parallel::_LoserTreeTraits< _Tp > | Traits for determining whether the loser tree should use pointers or copies |
| ▼C__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare > | Base class for unguarded _LoserTree implementation |
| C__gnu_parallel::_LoserTreeUnguarded< __stable, _Tp, _Compare > | Stable implementation of unguarded _LoserTree |
| C__gnu_parallel::_LoserTreeUnguarded< false, _Tp, _Compare > | Non-Stable implementation of unguarded _LoserTree |
| ▼Cstd::__detail::_Map_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| Cstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Partial specialization, __unique_keys set to false |
| Cstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Partial specialization, __unique_keys set to true |
| ▼Cstd::__detail::_Map_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::__detail::_Mask_range_hashing | Range hashing function assuming that second arg is a power of 2 |
| C__gnu_pbds::detail::pat_trie_base::_Metadata< Metadata, _Alloc > | Metadata base primary template |
| C__gnu_pbds::detail::pat_trie_base::_Metadata< null_type, _Alloc > | Specialization for null metadata |
| Cstd::__detail::_Mod_range_hashing | Default range hashing function: use division to fold a large number into the range [0, N) |
| Cstd::_Mu< _Arg, _IsBindExp, _IsPlaceholder > | |
| Cstd::_Mu< _Arg, false, false > | |
| Cstd::_Mu< _Arg, false, true > | |
| Cstd::_Mu< _Arg, true, false > | |
| Cstd::_Mu< reference_wrapper< _Tp >, false, false > | |
| ▼C__gnu_pbds::detail::pat_trie_base::_Node_base< _ATraits, Metadata > | Node base |
| C__gnu_pbds::detail::pat_trie_base::_Head< _ATraits, Metadata > | Head node for PATRICIA tree |
| C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata > | Internal node type, PATRICIA tree |
| C__gnu_pbds::detail::pat_trie_base::_Leaf< _ATraits, Metadata > | Leaf node for PATRICIA tree |
| ▼C__gnu_pbds::detail::pat_trie_base::_Node_citer< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc > | Node const iterator |
| C__gnu_pbds::detail::pat_trie_base::_Node_iter< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc > | Node iterator |
| Cstd::__detail::_Node_iterator_base< _Value, _Cache_hash_code > | Base class for node iterators |
| ▼Cstd::__detail::_Node_iterator_base< _Value, __cache > | |
| Cstd::__detail::_Node_const_iterator< _Value, __constant_iterators, __cache > | Node const_iterators, used to iterate through all the hashtable |
| Cstd::__detail::_Node_iterator< _Value, __constant_iterators, __cache > | Node iterators, used to iterate through all the hashtable |
| C__gnu_debug::_Not_equal_to< _Type > | |
| Cstd::_Not_fn< _Fn > | Generalized negator |
| C__gnu_parallel::_Nothing | Functor doing nothing |
| C__gnu_parallel::_Piece< _DifferenceTp > | Subsequence description |
| Cstd::_Placeholder< _Num > | The type of placeholder objects defined by libstdc++ |
| C__gnu_parallel::_PMWMSSortingData< _RAIter > | Data accessed by all threads |
| C__gnu_cxx::_Pointer_adapter< _Storage_policy > | |
| Cstd::__detail::_Power2_rehash_policy | Rehash policy providing power of 2 bucket numbers. Avoids modulo operations |
| Cstd::__detail::_Prime_rehash_policy | Default value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load factor small enough |
| C__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp > | Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course |
| C__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp > | _Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality |
| C__gnu_parallel::_QSBThreadLocal< _RAIter > | Information local to one thread in the parallel quicksort run |
| Cstd::__detail::_Quoted_string< _String, _CharT > | Struct for delimited strings |
| C__gnu_parallel::_RandomNumber | Random number generator, based on the Mersenne twister |
| ▼Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, typename > | |
| Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc > | |
| Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc > | |
| ▼Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits > | |
| Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false_type > | Specialization when rehash policy doesn't provide load factor management |
| Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true_type > | Specialization when rehash policy provide load factor management |
| C__gnu_cxx::_Relative_pointer_impl< _Tp > | 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 |
| C__gnu_cxx::_Relative_pointer_impl< const _Tp > | |
| C__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp > | Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided. Calling them would not make sense in a concurrent setting |
| C__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > > | |
| ▼Cstd::__future_base::_Result_base | Base class for results |
| ▼Cstd::__future_base::_Result< _Res > | A result object that has storage for an object of type _Res |
| Cstd::__future_base::_Result_alloc< _Res, _Alloc > | A result object that uses an allocator |
| Cstd::__future_base::_Result< _Res & > | Partial specialization for reference types |
| Cstd::__future_base::_Result< void > | Explicit specialization for void |
| C__gnu_debug::_Safe_container< _SafeContainer, _Alloc, _SafeBase, _IsCxx11AllocatorAware > | Safe class dealing with some allocator dependent operations |
| ▼C__gnu_debug::_Safe_iterator_base | Basic functionality for a safe iterator |
| C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category > | Safe iterator wrapper |
| ▼C__gnu_debug::_Safe_local_iterator_base | Basic functionality for a safe iterator |
| C__gnu_debug::_Safe_local_iterator< _Iterator, _Sequence > | Safe iterator wrapper |
| C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, std::bidirectional_iterator_tag > | |
| C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, std::forward_iterator_tag > | |
| ▼C__gnu_debug::_Safe_sequence_base | Base class that supports tracking of iterators that reference a sequence |
| ▼C__gnu_debug::_Safe_sequence< _Sequence > | Base class for constructing a safe sequence type that tracks iterators that reference it |
| C__gnu_debug::_Safe_node_sequence< _Sequence > | Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence |
| ▼C__gnu_debug::_Safe_unordered_container_base | Base class that supports tracking of local iterators that reference an unordered container |
| C__gnu_debug::_Safe_unordered_container< _Container > | Base class for constructing a safe unordered container type that tracks iterators that reference it |
| ▼C__gnu_debug::_Safe_unordered_container< unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > > | |
| ▼C__gnu_debug::_Safe_container< unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container > | |
| Cstd::__debug::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > | Class std::unordered_map with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_unordered_container< unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > > | |
| ▼C__gnu_debug::_Safe_container< unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container > | |
| Cstd::__debug::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > | Class std::unordered_multimap with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_unordered_container< unordered_multiset< _Value, _Hash, _Pred, _Alloc > > | |
| ▼C__gnu_debug::_Safe_container< unordered_multiset< _Value, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container > | |
| Cstd::__debug::unordered_multiset< _Value, _Hash, _Pred, _Alloc > | Class std::unordered_multiset with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_unordered_container< unordered_set< _Value, _Hash, _Pred, _Alloc > > | |
| ▼C__gnu_debug::_Safe_container< unordered_set< _Value, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container > | |
| Cstd::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc > | Class std::unordered_set with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< _SafeSequence > | |
| C__gnu_debug::_Safe_forward_list< _SafeSequence > | Special iterators swap and invalidation for forward_list because of the before_begin iterator |
| ▼C__gnu_debug::_Safe_sequence< basic_string< _CharT, _Traits, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< basic_string< _CharT, _Traits, _Allocator >, _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)> | |
| C__gnu_debug::basic_string< _CharT, _Traits, _Allocator > | Class std::basic_string with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< deque< _Tp, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< deque< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_sequence > | |
| Cstd::__debug::deque< _Tp, _Allocator > | Class std::deque with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< forward_list< _Tp, _Alloc > > | |
| ▼C__gnu_debug::_Safe_forward_list< forward_list< _Tp, _Alloc > > | |
| ▼C__gnu_debug::_Safe_container< forward_list< _Tp, _Alloc >, _Alloc, __gnu_debug::_Safe_forward_list > | |
| Cstd::__debug::forward_list< _Tp, _Alloc > | Class std::forward_list with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< list< _Tp, _Allocator > > | |
| ▼C__gnu_debug::_Safe_node_sequence< list< _Tp, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< list< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence > | |
| Cstd::__debug::list< _Tp, _Allocator > | Class std::list with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< map< _Key, _Tp, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_node_sequence< map< _Key, _Tp, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< map< _Key, _Tp, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence > | |
| Cstd::__debug::map< _Key, _Tp, _Compare, _Allocator > | Class std::map with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< multimap< _Key, _Tp, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_node_sequence< multimap< _Key, _Tp, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< multimap< _Key, _Tp, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence > | |
| Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator > | Class std::multimap with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< multiset< _Key, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_node_sequence< multiset< _Key, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< multiset< _Key, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence > | |
| Cstd::__debug::multiset< _Key, _Compare, _Allocator > | Class std::multiset with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< set< _Key, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_node_sequence< set< _Key, _Compare, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< set< _Key, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence > | |
| Cstd::__debug::set< _Key, _Compare, _Allocator > | Class std::set with safety/checking/debug instrumentation |
| ▼C__gnu_debug::_Safe_sequence< vector< _Tp, _Allocator > > | |
| ▼C__gnu_debug::_Safe_container< vector< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_sequence > | |
| Cstd::__debug::vector< _Tp, _Allocator > | Class std::vector with safety/checking/debug instrumentation |
| C__gnu_debug::_Safe_vector< _SafeSequence, _BaseSequence > | Base class for Debug Mode vector |
| ▼C__gnu_debug::_Safe_vector< vector< _Tp, _Allocator >, ::vector< _Tp, _Allocator > > | |
| Cstd::__debug::vector< _Tp, _Allocator > | Class std::vector with safety/checking/debug instrumentation |
| C__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering > | Stable sorting functor |
| C__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering > | Non-__stable sorting functor |
| Cstd::__detail::_Scanner< _CharT > | Scans an input range for regex tokens |
| C__gnu_debug::_Sequence_traits< _Sequence > | |
| C__gnu_parallel::_Settings | Class _Settings Run-time settings for the parallel mode including all tunable parameters |
| Cstd::_Sp_ebo_helper< _Nm, _Tp, false > | Specialization not using EBO |
| Cstd::_Sp_ebo_helper< _Nm, _Tp, true > | Specialization using EBO |
| C__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator > | Split consistently |
| C__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator > | Split by sampling |
| C__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator > | Split by exact splitting |
| Cstd::__detail::_StateSeq< _TraitsT > | Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction |
| C__gnu_cxx::_Std_pointer_impl< _Tp > | A storage policy for use with _Pointer_adapter<> which yields a standard pointer |
| ▼Cstd::_Temporary_buffer< _ForwardIterator, _Tp > | |
| C__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp > | |
| Cstd::_Tuple_impl< _Idx, _Elements > | |
| ▼Cstd::_Tuple_impl< 0, _Elements... > | |
| Cstd::tuple< _Elements > | Primary class template, tuple |
| Cstd::tuple< _Bound_args... > | |
| Cstd::tuple< _ForwardIterator1, _ForwardIterator1, _BinaryPredicate > | |
| Cstd::tuple< std::array< _Tp, _Len >, _Pred > | |
| ▼Cstd::_Tuple_impl< 0, _T1, _T2 > | |
| Cstd::tuple< _T1, _T2 > | Partial specialization, 2-element tuple. Includes construction and assignment from a pair |
| ▼Cstd::_Tuple_impl< _Idx+1, _Tail... > | |
| Cstd::_Tuple_impl< _Idx, _Head, _Tail... > | |
| C__gnu_cxx::_Unqualified_type< _Tp > | |
| ▼Cstd::_Vector_base< _Tp, _Alloc > | See bits/stl_deque.h's _Deque_base for an explanation |
| Cstd::vector< _Tp, _Alloc > | A standard container which offers fixed time access to individual elements in any order |
| ▼Cstd::_Vector_base< __diff_type, std::allocator< __diff_type > > | |
| Cstd::vector< __diff_type > | |
| ▼Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > > | |
| Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > > | |
| ▼Cstd::_Vector_base< _CharClassT, std::allocator< _CharClassT > > | |
| Cstd::vector< _CharClassT > | |
| ▼Cstd::_Vector_base< _CharT, std::allocator< _CharT > > | |
| Cstd::vector< _CharT > | |
| ▼Cstd::_Vector_base< _Cmpt, std::allocator< _Cmpt > > | |
| Cstd::vector< _Cmpt > | |
| ▼Cstd::_Vector_base< _Node *, _Nodeptr_Alloc > | |
| Cstd::vector< _Node *, _Nodeptr_Alloc > | |
| ▼Cstd::_Vector_base< _RealType, std::allocator< _RealType > > | |
| Cstd::vector< _RealType > | |
| ▼Cstd::_Vector_base< _State< _TraitsT::char_type >, std::allocator< _State< _TraitsT::char_type > > > | |
| Cstd::vector< _State< _TraitsT::char_type > > | |
| ▼Cstd::_Vector_base< _StringT, std::allocator< _StringT > > | |
| Cstd::vector< _StringT > | |
| ▼Cstd::_Vector_base< block_type, allocator_type > | |
| Cstd::vector< block_type, allocator_type > | |
| ▼Cstd::_Vector_base< Catalog_info *, std::allocator< Catalog_info *> > | |
| Cstd::vector< Catalog_info *> | |
| ▼Cstd::_Vector_base< double, std::allocator< double > > | |
| Cstd::vector< double > | |
| ▼Cstd::_Vector_base< int, std::allocator< int > > | |
| Cstd::vector< int > | |
| ▼Cstd::_Vector_base< result_type, std::allocator< result_type > > | |
| Cstd::vector< result_type > | |
| ▼Cstd::_Vector_base< size_t, std::allocator< size_t > > | |
| Cstd::vector< size_t > | |
| ▼Cstd::_Vector_base< std::pair< _BiIter, int >, std::allocator< std::pair< _BiIter, int > > > | |
| Cstd::vector< std::pair< _BiIter, int > > | |
| ▼Cstd::_Vector_base< std::pair< _StateIdT, std::vector >, std::allocator< std::pair< _StateIdT, std::vector > > > | |
| Cstd::vector< std::pair< _StateIdT, std::vector > > | |
| ▼Cstd::_Vector_base< std::pair< _StrTransT, _StrTransT >, std::allocator< std::pair< _StrTransT, _StrTransT > > > | |
| Cstd::vector< std::pair< _StrTransT, _StrTransT > > | |
| ▼Cstd::_Vector_base< sub_match< _Bi_iter >, _Alloc > | |
| ▼Cstd::vector< sub_match< _Bi_iter >, _Alloc > | |
| Cstd::match_results< _Bi_iter, _Alloc > | The results of a match or search operation |
| ▼Cstd::_Vector_base< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > > | |
| ▼Cstd::vector< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > > | |
| Cstd::match_results< _Bi_iter > | |
| ▼Cstd::_Vector_base< sub_match< _BiIter >, _Alloc > | |
| Cstd::vector< sub_match< _BiIter >, _Alloc > | |
| Cstd::add_const< _Tp > | Add_const |
| Cstd::add_cv< _Tp > | Add_cv |
| Cstd::add_lvalue_reference< _Tp > | Add_lvalue_reference |
| Cstd::add_rvalue_reference< _Tp > | Add_rvalue_reference |
| Cstd::add_volatile< _Tp > | Add_volatile |
| Cstd::adopt_lock_t | Assume the calling thread has already obtained mutex ownership and manage it |
| Cstd::aligned_storage< _Len, _Align > | Alignment type |
| Cstd::aligned_storage< sizeof(_M_ptr), alignof(void *)> | |
| Cstd::aligned_storage< sizeof(_Res), __alignof__(_Res)> | |
| Cstd::aligned_storage< sizeof(_Tp), __alignof__(_Tp)> | |
| Cstd::aligned_storage< sizeof(_Tp), alignof(_Tp)> | |
| Cstd::aligned_storage< sizeof(_Value), __alignof__(_Value)> | |
| Cstd::aligned_union< _Len, _Types > | Provide aligned storage for types |
| Cstd::allocator< void > | Allocator<void> specialization |
| Cstd::allocator_arg_t | [allocator.tag] |
| ▼Cstd::allocator_traits< _Alloc > | Uniform interface to all allocator types |
| C__gnu_cxx::__alloc_traits< _Alloc, typename > | Uniform interface to C++98 and C++11 allocators |
| ▼Cstd::allocator_traits< _Tp_alloc_type > | |
| C__gnu_cxx::__alloc_traits< _Tp_alloc_type > | |
| Cstd::allocator_traits< allocator< _Tp > > | Partial specialization for std::allocator |
| C__gnu_cxx::limit_condition::always_adjustor | Always enter the condition |
| C__gnu_cxx::random_condition::always_adjustor | Always enter the condition |
| ▼C__gnu_cxx::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 |
| C__gnu_cxx::throw_allocator_base< _Tp, _Cond > | Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code.Note: Deallocate not allowed to throw |
| ▼C__gnu_cxx::throw_allocator_base< _Tp, limit_condition > | |
| C__gnu_cxx::throw_allocator_limit< _Tp > | Allocator throwing via limit condition |
| ▼C__gnu_cxx::throw_allocator_base< _Tp, random_condition > | |
| C__gnu_cxx::throw_allocator_random< _Tp > | Allocator throwing via random condition |
| Cstd::experimental::fundamentals_v1::any | A type-safe container of any type |
| Cstd::array< _Tp, _Nm > | A standard container for storing a fixed size sequence of elements |
| Cstd::atomic< _Tp > | Generic atomic type, primary class template |
| Cstd::atomic< _Tp * > | Partial specialization for pointer types |
| Cstd::atomic< bool > | Atomic<bool> |
| Cstd::auto_ptr< _Tp > | A simple smart pointer providing strict ownership semantics |
| Cstd::auto_ptr_ref< _Tp1 > | |
| Cstd::tr2::bases< _Tp > | Sequence abstraction metafunctions for manipulating a typelist |
| C__gnu_pbds::basic_branch< Key, Mapped, Tag, Node_Update, Policy_Tl, _Alloc > | |
| ▼C__gnu_pbds::basic_branch< Key, Mapped, Tag, detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Tag, _Alloc > ::node_update, __gnu_cxx::typelist::create2< Cmp_Fn, detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Tag, _Alloc > >::type, _Alloc > | |
| C__gnu_pbds::tree< Key, Mapped, Cmp_Fn, Tag, Node_Update, _Alloc > | |
| ▼C__gnu_pbds::basic_branch< Key, Mapped, Tag, detail::trie_traits< Key, Mapped, _ATraits, Node_Update, Tag, _Alloc > ::node_update, __gnu_cxx::typelist::create2< _ATraits, detail::trie_traits< Key, Mapped, _ATraits, Node_Update, Tag, _Alloc > >::type, _Alloc > | |
| C__gnu_pbds::trie< Key, Mapped, _ATraits, Tag, Node_Update, _Alloc > | |
| C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, Tag, Policy_Tl, _Alloc > | |
| ▼C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, cc_hash_tag, __gnu_cxx::typelist::create1< Comb_Hash_Fn >::type, _Alloc > | |
| C__gnu_pbds::cc_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Hash_Fn, Resize_Policy, Store_Hash, _Alloc > | |
| ▼C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, gp_hash_tag, __gnu_cxx::typelist::create2< Comb_Probe_Fn, Probe_Fn >::type, _Alloc > | |
| C__gnu_pbds::gp_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Probe_Fn, Probe_Fn, Resize_Policy, Store_Hash, _Alloc > | |
| ▼C__gnu_pbds::basic_invalidation_guarantee | |
| ▼C__gnu_pbds::point_invalidation_guarantee | |
| C__gnu_pbds::range_invalidation_guarantee | |
| Cstd::basic_regex< _Ch_type, _Rx_traits > | |
| ▼Cstd::basic_streambuf< _CharT, _Traits > | The actual work of input and output (interface) |
| C__gnu_cxx::stdio_sync_filebuf< _CharT, _Traits > | Provides a layer of compatibility for C.This GNU extension provides extensions for working with standard C FILE*'s. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char> |
| ▼Cstd::basic_filebuf< _CharT, encoding_char_traits< _CharT > > | |
| C__gnu_cxx::enc_filebuf< _CharT > | Class enc_filebuf |
| Cstd::basic_filebuf< char_type, traits_type > | |
| ▼Cstd::basic_filebuf< _CharT, _Traits > | The actual work of input and output (for files) |
| C__gnu_cxx::stdio_filebuf< _CharT, _Traits > | Provides a layer of compatibility for C/POSIX.This GNU extension provides extensions for working with standard C FILE*'s and POSIX file descriptors. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char> |
| Cstd::basic_stringbuf< _CharT, _Traits, _Alloc > | The actual work of input and output (for std::string) |
| ▼Cstd::basic_streambuf< _Elem, _Tr > | |
| Cstd::wbuffer_convert< _Codecvt, _Elem, _Tr > | Buffer conversions |
| Cstd::basic_streambuf< char, _Traits > | |
| Cstd::basic_streambuf< char, char_traits< char > > | |
| Cstd::basic_string< _CharT, _Traits, _Alloc > | Managing sequences of characters and character-like objects |
| Cstd::basic_string< _CharT > | |
| ▼Cstd::basic_string< _CharT, _Traits, _Allocator > | |
| C__gnu_debug::basic_string< _CharT, _Traits, _Allocator > | Class std::basic_string with safety/checking/debug instrumentation |
| Cstd::basic_string< _Elem, char_traits< _Elem >, _Wide_alloc > | |
| Cstd::basic_string< char > | |
| Cstd::basic_string< char, char_traits< char >, _Byte_alloc > | |
| Cstd::basic_string< char_type, _Traits, _Alloc > | |
| Cstd::basic_string< value_type > | |
| Cstd::experimental::fundamentals_v1::basic_string_view< _CharT, _Traits > | A non-owning reference to a string |
| Cstd::bernoulli_distribution | A Bernoulli random number distribution |
| ▼C__gnu_pbds::detail::bin_search_tree_const_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc > | Const iterator |
| C__gnu_pbds::detail::bin_search_tree_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc > | Iterator |
| ▼C__gnu_pbds::detail::bin_search_tree_const_node_it_< Node, Const_Iterator, Iterator, _Alloc > | Const node iterator |
| C__gnu_pbds::detail::bin_search_tree_node_it_< Node, Const_Iterator, Iterator, _Alloc > | Node iterator |
| C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Node, _Alloc > | Binary search tree traits, primary template |
| ▼C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc > | |
| C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization |
| ▼C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc > | |
| C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization |
| C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc > | Specialization |
| ▼C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc > | |
| C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization |
| ▼C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc > | |
| C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization |
| ▼Cstd::binary_function< _Arg1, _Arg2, _Result > | |
| Cstd::pointer_to_binary_function< _Arg1, _Arg2, _Result > | One of the adaptors for function pointers |
| Cstd::binary_function< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool > | |
| Cstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool > | |
| Cstd::binary_function< _Arg1, _Arg2, _Arg1 > | |
| Cstd::binary_function< _Arg1, _Arg2, _Arg2 > | |
| ▼Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool > | |
| Cstd::binary_negate< _Predicate > | One of the negation functors |
| ▼Cstd::binary_function< _T1, _T2, bool > | |
| C__gnu_parallel::_EqualFromLess< _T1, _T2, _Compare > | Constructs predicate for equality from strict weak ordering predicate |
| C__gnu_parallel::_EqualTo< _T1, _T2 > | Similar to std::equal_to, but allows two different types |
| C__gnu_parallel::_Less< _T1, _T2 > | Similar to std::less, but allows two different types |
| C__gnu_parallel::_LexicographicReverse< _T1, _T2, _Compare > | Compare __a pair of types lexicographically, descending |
| ▼Cstd::binary_function< _Tp *, _Arg, _Ret > | |
| Cstd::mem_fun1_t< _Ret, _Tp, _Arg > | One of the adaptors for member pointers |
| Cstd::binary_function< _Tp *, _Tp *, bool > | |
| ▼Cstd::binary_function< _Tp, _Arg, _Ret > | |
| Cstd::const_mem_fun1_ref_t< _Ret, _Tp, _Arg > | One of the adaptors for member pointers |
| Cstd::mem_fun1_ref_t< _Ret, _Tp, _Arg > | One of the adaptors for member pointers |
| ▼Cstd::binary_function< _Tp, _Tp, _Tp > | |
| Cstd::divides< _Tp > | One of the math functors |
| Cstd::minus< _Tp > | One of the math functors |
| Cstd::modulus< _Tp > | One of the math functors |
| Cstd::multiplies< _Tp > | One of the math functors |
| Cstd::plus< _Tp > | One of the math functors |
| ▼Cstd::binary_function< _Tp, _Tp, bool > | |
| Cstd::equal_to< _Tp > | One of the comparison functors |
| Cstd::greater< _Tp > | One of the comparison functors |
| Cstd::greater_equal< _Tp > | One of the comparison functors |
| Cstd::less< _Tp > | One of the comparison functors |
| Cstd::less_equal< _Tp > | One of the comparison functors |
| Cstd::logical_and< _Tp > | One of the Boolean operations functors |
| Cstd::logical_or< _Tp > | One of the Boolean operations functors |
| Cstd::not_equal_to< _Tp > | One of the comparison functors |
| ▼Cstd::binary_function< _Tp1, _Tp2, _Result > | |
| C__gnu_parallel::_Multiplies< _Tp1, _Tp2, _Result > | Similar to std::multiplies, but allows two different types |
| C__gnu_parallel::_Plus< _Tp1, _Tp2, _Result > | Similar to std::plus, but allows two different types |
| ▼Cstd::binary_function< const _Tp *, _Arg, _Ret > | |
| Cstd::const_mem_fun1_t< _Ret, _Tp, _Arg > | One of the adaptors for member pointers |
| Cstd::binary_function< rope< _CharT, _Alloc >, rope< _CharT, _Alloc >, rope< _CharT, _Alloc > > | |
| Cstd::binary_function< shared_ptr< _Tp >, shared_ptr< _Tp >, bool > | |
| ▼Cstd::binary_function< std::pair< _T1, _T2 >, std::pair< _T1, _T2 >, bool > | |
| C__gnu_parallel::_Lexicographic< _T1, _T2, _Compare > | Compare __a pair of types lexicographically, ascending |
| Cstd::binary_function< value_type, value_type, bool > | |
| Cstd::binary_function< void, void, bool > | |
| Cstd::binary_function< weak_ptr< _Tp >, weak_ptr< _Tp >, bool > | |
| ▼C__gnu_pbds::detail::binary_heap_point_const_iterator_< Value_Type, Entry, Simple, _Alloc > | Const point-type iterator |
| C__gnu_pbds::detail::binary_heap_const_iterator_< Value_Type, Entry, Simple, _Alloc > | Const point-type iterator |
| Cstd::binomial_distribution< _IntType > | A discrete binomial random number distribution |
| Cstd::__debug::bitset< _Nb > | Class std::bitset with additional safety/checking/debug instrumentation |
| Cstd::tr2::bool_set | |
| ▼C__gnu_pbds::detail::branch_policy< Node_CItr, Node_Itr, _Alloc > | Primary template, base class for branch structure policies |
| ▼C__gnu_pbds::detail::trie_policy_base< Node_CItr, Node_Itr, _ATraits, _Alloc > | Base class for trie policies |
| C__gnu_pbds::trie_order_statistics_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc > | Functor updating ranks of entrees |
| C__gnu_pbds::trie_prefix_search_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc > | A node updator that allows tries to be searched for the range of values that match a certain prefix |
| C__gnu_pbds::tree_order_statistics_node_update< Node_CItr, Node_Itr, Cmp_Fn, _Alloc > | Functor updating ranks of entrees |
| C__gnu_pbds::detail::branch_policy< Node_CItr, Node_CItr, _Alloc > | Specialization for const iterators |
| Cstd::cauchy_distribution< _RealType > | A cauchy_distribution random number distribution |
| C__gnu_pbds::cc_hash_max_collision_check_resize_trigger< External_Load_Access, Size_Type > | A resize trigger policy based on collision checks. It keeps the simulated load factor lower than some given load factor |
| ▼C__gnu_cxx::char_traits< _CharT > | Base class used to implement std::char_traits |
| ▼Cstd::char_traits< _CharT > | Basis for explicit traits specializations |
| C__gnu_cxx::encoding_char_traits< _CharT > | Encoding_char_traits |
| Cstd::char_traits< __gnu_cxx::character< _Value, _Int, _St > > | Char_traits<__gnu_cxx::character> specialization |
| Cstd::char_traits< char > | 21.1.3.1 char_traits specializations |
| Cstd::char_traits< wchar_t > | 21.1.3.2 char_traits specializations |
| C__gnu_cxx::character< _Value, _Int, _St > | A POD class that serves as a character abstraction class |
| Cstd::chi_squared_distribution< _RealType > | A chi_squared_distribution random number distribution |
| ▼Cstd::codecvt_base | Empty base class for codecvt facet [22.2.1.5] |
| ▼Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state > | |
| Cstd::codecvt< _InternT, _ExternT, encoding_state > | Codecvt<InternT, _ExternT, encoding_state> specialization |
| ▼Cstd::__codecvt_abstract_base< char, char, mbstate_t > | |
| Cstd::codecvt< char, char, mbstate_t > | Class codecvt<char, char, mbstate_t> specialization |
| ▼Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t > | |
| Cstd::codecvt< char16_t, char, mbstate_t > | Class codecvt<char16_t, char, mbstate_t> specialization |
| ▼Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t > | |
| Cstd::codecvt< char32_t, char, mbstate_t > | Class codecvt<char32_t, char, mbstate_t> specialization |
| ▼Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t > | |
| Cstd::codecvt< wchar_t, char, mbstate_t > | Class codecvt<wchar_t, char, mbstate_t> specialization |
| ▼Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT > | Common base for codecvt functions |
| Cstd::codecvt< _Elem, char, mbstate_t > | |
| ▼Cstd::codecvt< _InternT, _ExternT, _StateT > | Primary class template codecvt.NB: Generic, mostly useless implementation |
| Cstd::codecvt_byname< _InternT, _ExternT, _StateT > | Class codecvt_byname [22.2.1.6] |
| Cstd::common_type< _Tp > | Common_type |
| Cstd::common_type< _CTp::type, _Rp... > | |
| Cstd::common_type< _Tp0, _Tp0 > | |
| Cstd::common_type< _Types... > | |
| Cstd::common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > > | Specialization of common_type for chrono::duration types |
| Cstd::common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > > | Specialization of common_type for chrono::time_point types |
| Cstd::complex< _Tp > | |
| Cstd::complex< double > | 26.2.3 complex specializations complex<double> specialization |
| Cstd::complex< float > | 26.2.3 complex specializations complex<float> specialization |
| Cstd::complex< long double > | 26.2.3 complex specializations complex<long double> specialization |
| C__gnu_pbds::detail::cond_dealtor< Entry, _Alloc > | Conditional deallocate constructor argument |
| C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >::cond_dtor< Size_Type > | Conditional destructor |
| ▼C__gnu_cxx::condition_base | Base struct for condition policy |
| ▼C__gnu_cxx::limit_condition | Base class for incremental control and throw |
| C__gnu_cxx::throw_allocator_base< _Tp, limit_condition > | |
| ▼C__gnu_cxx::throw_value_base< limit_condition > | |
| C__gnu_cxx::throw_value_limit | Type throwing via limit condition |
| ▼C__gnu_cxx::random_condition | Base class for random probability control and throw |
| C__gnu_cxx::throw_allocator_base< _Tp, random_condition > | |
| ▼C__gnu_cxx::throw_value_base< random_condition > | |
| C__gnu_cxx::throw_value_random | Type throwing via random condition |
| Cstd::condition_variable | Condition_variable |
| Cstd::_V2::condition_variable_any | Condition_variable_any |
| Cstd::conditional< _Cond, _Iftrue, _Iffalse > | Define a member typedef type to one of two argument types |
| Cstd::conditional< _UseCache::value, std::bitset< _S_cache_size >, _Dummy > | |
| ▼C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::const_iterator | Constant child iterator |
| C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::iterator | Child iterator |
| C__gnu_cxx::constant_binary_fun< _Result, _Arg1, _Arg2 > | An SGI extension |
| C__gnu_cxx::constant_unary_fun< _Result, _Argument > | An SGI extension |
| C__gnu_cxx::constant_void_fun< _Result > | An SGI extension |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, Tag, Policy_Tl > | Dispatch mechanism, primary template for associative types |
| C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type > | Specialization for binary_heap |
| C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type > | Specialization for binomial_heap |
| C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type > | Specialization for pairing_heap |
| C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type > | Specialization for rc_binary_heap |
| C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type > | Specialization for thin_heap |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl > | Specialization colision-chaining hash map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree map |
| C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree map |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl > | Specialization colision-chaining hash set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree set |
| C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree set |
| ▼C__gnu_pbds::container_tag | Base data structure tag |
| ▼C__gnu_pbds::associative_tag | Basic associative-container |
| ▼C__gnu_pbds::basic_branch_tag | Basic branch structure |
| ▼C__gnu_pbds::tree_tag | Basic tree structure |
| C__gnu_pbds::ov_tree_tag | Ordered-vector tree |
| C__gnu_pbds::rb_tree_tag | Red-black tree |
| C__gnu_pbds::splay_tree_tag | Splay tree |
| ▼C__gnu_pbds::trie_tag | Basic trie structure |
| C__gnu_pbds::pat_trie_tag | PATRICIA trie |
| ▼C__gnu_pbds::basic_hash_tag | Basic hash structure |
| C__gnu_pbds::cc_hash_tag | Collision-chaining hash |
| C__gnu_pbds::gp_hash_tag | General-probing hash |
| C__gnu_pbds::list_update_tag | List-update |
| ▼C__gnu_pbds::priority_queue_tag | Basic priority-queue |
| C__gnu_pbds::binary_heap_tag | Binary-heap (array-based) |
| C__gnu_pbds::binomial_heap_tag | Binomial-heap |
| C__gnu_pbds::pairing_heap_tag | Pairing-heap |
| C__gnu_pbds::rc_binomial_heap_tag | Redundant-counter binomial-heap |
| C__gnu_pbds::thin_heap_tag | Thin heap |
| ▼C__gnu_pbds::sequence_tag | Basic sequence |
| C__gnu_pbds::string_tag | Basic string container, inclusive of strings, ropes, etc |
| C__gnu_pbds::container_traits_base< _Tag > | Primary template, container traits base |
| C__gnu_pbds::container_traits_base< binary_heap_tag > | Specialization, binary heap |
| C__gnu_pbds::container_traits_base< binomial_heap_tag > | Specialization, binomial heap |
| C__gnu_pbds::container_traits_base< cc_hash_tag > | Specialization, cc hash |
| ▼C__gnu_pbds::container_traits_base< Cntnr::container_category > | |
| C__gnu_pbds::container_traits< Cntnr > | Container traits |
| C__gnu_pbds::container_traits_base< gp_hash_tag > | Specialization, gp hash |
| C__gnu_pbds::container_traits_base< list_update_tag > | Specialization, list update |
| C__gnu_pbds::container_traits_base< ov_tree_tag > | Specialization, ov tree |
| C__gnu_pbds::container_traits_base< pairing_heap_tag > | Specialization, pairing heap |
| C__gnu_pbds::container_traits_base< pat_trie_tag > | Specialization, pat trie |
| C__gnu_pbds::container_traits_base< rb_tree_tag > | Specialization, rb tree |
| C__gnu_pbds::container_traits_base< rc_binomial_heap_tag > | Specialization, rc binomial heap |
| C__gnu_pbds::container_traits_base< splay_tree_tag > | Specialization, splay tree |
| C__gnu_pbds::container_traits_base< thin_heap_tag > | Specialization, thin heap |
| ▼Cstd::ctype_base | Base class for ctype |
| ▼Cstd::__ctype_abstract_base< wchar_t > | |
| Cstd::ctype< wchar_t > | The ctype<wchar_t> specialization.This class defines classification and conversion functions for the wchar_t type. It gets used by wchar_t streams for many I/O operations. The wchar_t specialization provides a number of optimizations as well |
| ▼Cstd::__ctype_abstract_base< _CharT > | Common base for ctype facet |
| ▼Cstd::ctype< _CharT > | Primary class template ctype facet.This template class defines classification and conversion functions for character sets. It wraps cctype functionality. Ctype gets used by streams for many I/O operations |
| Cstd::ctype_byname< _CharT > | Class ctype_byname [22.2.1.2] |
| ▼Cstd::ctype< char > | The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well |
| Cstd::ctype_byname< char > | 22.2.1.4 Class ctype_byname specializations |
| C__gnu_cxx::debug_allocator< _Alloc > | A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard |
| Cstd::decay< _Tp > | Decay |
| Cstd::decimal::decimal128 | 3.2.4 Class decimal128 |
| Cstd::decimal::decimal32 | 3.2.2 Class decimal32 |
| Cstd::decimal::decimal64 | 3.2.3 Class decimal64 |
| C__gnu_pbds::detail::default_comb_hash_fn | Primary template, default_comb_hash_fn |
| Cstd::default_delete< _Tp > | Primary template of default_delete, used by unique_ptr for single objects |
| Cstd::default_delete< _Tp[]> | Specialization of default_delete for arrays, used by unique_ptr<T[]> |
| C__gnu_pbds::detail::default_eq_fn< Key > | Primary template, default_eq_fn |
| C__gnu_pbds::detail::default_hash_fn< Key > | Primary template, default_hash_fn |
| C__gnu_pbds::detail::default_probe_fn< Comb_Probe_Fn > | Primary template, default_probe_fn |
| C__gnu_pbds::detail::default_resize_policy< Comb_Hash_Fn > | Primary template, default_resize_policy |
| C__gnu_pbds::detail::default_trie_access_traits< Key > | Primary template, default_trie_access_traits |
| C__gnu_pbds::detail::default_trie_access_traits< std::basic_string< Char, Char_Traits, std::allocator< char > > > | Partial specialization, default_trie_access_traits |
| C__gnu_pbds::detail::default_update_policy | Default update policy |
| Cstd::defer_lock_t | Do not acquire ownership of the mutex |
| Cstd::tr2::direct_bases< _Tp > | Enumerate all the direct base classes of a class. Form of a typelist |
| Cstd::discard_block_engine< _RandomNumberEngine, __p, __r > | |
| Cstd::discrete_distribution< _IntType > | A discrete_distribution random number distribution |
| Cstd::divides< void > | One of the math functors |
| C__gnu_pbds::detail::dumnode_const_iterator< Key, Data, _Alloc > | Constant node iterator |
| Cstd::chrono::duration< _Rep, _Period > | Duration |
| Cstd::chrono::duration_values< _Rep > | Duration_values |
| Cstd::enable_if< bool, _Tp > | Define a member typedef type only if a boolean constant is true |
| Cstd::enable_shared_from_this< _Tp > | Base class allowing use of member function shared_from_this |
| C__gnu_cxx::encoding_state | Extension to use iconv for dealing with character encodings |
| C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, No_Throw > | Entry compare, primary template |
| C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false > | Specialization, false |
| C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, true > | Specialization, true |
| C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, No_Throw > | Entry predicate primary class template |
| C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, false > | Specialization, false |
| C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, true > | Specialization, true |
| C__gnu_pbds::detail::eq_by_less< Key, Cmp_Fn > | Equivalence function |
| Cstd::equal_to< void > | One of the comparison functors |
| Cstd::_V2::error_category | |
| Cstd::error_code | |
| Cstd::error_condition | |
| ▼Cstd::exception | Base class for all library exceptions |
| C__gnu_cxx::forced_error | Thown by exception safety machinery |
| C__gnu_cxx::recursive_init_error | Exception thrown by __cxa_guard_acquire.C++ 2011 6.7 [stmt.dcl]/4: If control re-enters the declaration recursively while the variable is being initialized, the behavior is undefined |
| Cstd::bad_alloc | Exception possibly thrown by new.bad_alloc (or classes derived from it) is used to report allocation errors from the throwing forms of new |
| ▼Cstd::bad_cast | Thrown during incorrect typecasting.If you attempt an invalid dynamic_cast expression, an instance of this class (or something derived from this class) is thrown |
| Cstd::experimental::fundamentals_v1::bad_any_cast | Exception class thrown by a failed any_cast |
| Cstd::bad_exception | |
| Cstd::bad_function_call | Exception class thrown when class template function's operator() is called with an empty target |
| Cstd::bad_typeid | Thrown when a NULL pointer in a typeid expression is used |
| Cstd::bad_weak_ptr | Exception possibly thrown by shared_ptr |
| Cstd::ios_base::failure | These are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure |
| ▼Cstd::logic_error | One of two subclasses of exception |
| ▼C__gnu_pbds::container_error | Base class for exceptions |
| C__gnu_pbds::insert_error | An entry cannot be inserted into a container object for logical reasons (not, e.g., if memory is unabvailable, in which case the allocator_type's exception will be thrown) |
| C__gnu_pbds::join_error | A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps |
| C__gnu_pbds::resize_error | A container cannot be resized |
| Cstd::domain_error | |
| Cstd::experimental::fundamentals_v1::bad_optional_access | Exception class thrown when a disengaged optional object is dereferenced |
| Cstd::future_error | Exception type thrown by futures |
| Cstd::invalid_argument | |
| Cstd::length_error | |
| Cstd::out_of_range | |
| ▼Cstd::runtime_error | One of two subclasses of exception |
| Cstd::overflow_error | |
| Cstd::range_error | |
| Cstd::regex_error | A regular expression exception class.The regular expression library throws objects of this class on error |
| ▼Cstd::system_error | An exception type that includes an error_code value |
| Cstd::experimental::filesystem::v1::filesystem_error | Exception type thrown by the Filesystem TS library |
| Cstd::underflow_error | |
| Cstd::__exception_ptr::exception_ptr | An opaque pointer to an arbitrary exception |
| Cstd::exponential_distribution< _RealType > | An exponential continuous distribution for random numbers |
| Cstd::extreme_value_distribution< _RealType > | A extreme_value_distribution random number distribution |
| ▼Cstd::locale::facet | Localization functionality base class.The facet class is the base class for a localization feature, such as money, time, and number printing. It provides common support for facets and reference management |
| Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state > | |
| Cstd::__codecvt_abstract_base< char, char, mbstate_t > | |
| Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t > | |
| Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t > | |
| Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t > | |
| Cstd::__ctype_abstract_base< wchar_t > | |
| Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT > | Common base for codecvt functions |
| Cstd::__ctype_abstract_base< _CharT > | Common base for ctype facet |
| ▼Cstd::collate< _CharT > | Facet for localized string comparison |
| Cstd::collate_byname< _CharT > | Class collate_byname [22.2.4.2] |
| Cstd::ctype< char > | The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well |
| ▼Cstd::messages< _CharT > | Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined |
| Cstd::messages_byname< _CharT > | Class messages_byname [22.2.7.2] |
| Cstd::money_get< _CharT, _InIter > | Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string |
| Cstd::money_put< _CharT, _OutIter > | Primary class template money_put.This facet encapsulates the code to format and output a monetary amount |
| ▼Cstd::moneypunct< _CharT, _Intl > | Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations |
| Cstd::moneypunct_byname< _CharT, _Intl > | Class moneypunct_byname [22.2.6.4] |
| Cstd::num_get< _CharT, _InIter > | Primary class template num_get.This facet encapsulates the code to parse and return a number from a string. It is used by the istream numeric extraction operators |
| Cstd::num_put< _CharT, _OutIter > | Primary class template num_put.This facet encapsulates the code to convert a number to a string. It is used by the ostream numeric insertion operators |
| ▼Cstd::numpunct< _CharT > | Primary class template numpunct.This facet stores several pieces of information related to printing and scanning numbers, such as the decimal point character. It takes a template parameter specifying the char type. The numpunct facet is used by streams for many I/O operations involving numbers |
| Cstd::numpunct_byname< _CharT > | Class numpunct_byname [22.2.3.2] |
| ▼Cstd::time_get< _CharT, _InIter > | Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators |
| Cstd::time_get_byname< _CharT, _InIter > | Class time_get_byname [22.2.5.2] |
| ▼Cstd::time_put< _CharT, _OutIter > | Primary class template time_put.This facet encapsulates the code to format and output dates and times according to formats used by strftime() |
| Cstd::time_put_byname< _CharT, _OutIter > | Class time_put_byname [22.2.5.4] |
| ▼C__gnu_parallel::find_tag | Base class for for std::find() variants |
| C__gnu_parallel::constant_size_blocks_tag | Selects the constant block size variant for std::find() |
| C__gnu_parallel::equal_split_tag | Selects the equal splitting variant for std::find() |
| C__gnu_parallel::growing_blocks_tag | Selects the growing block size variant for std::find() |
| Cstd::fisher_f_distribution< _RealType > | A fisher_f_distribution random number distribution |
| Cstd::fpos< _StateT > | Class representing stream positions |
| ▼C__gnu_cxx::free_list | The free list class for managing chunks of memory to be given to and returned by the bitmap_allocator |
| C__gnu_cxx::bitmap_allocator< _Tp > | Bitmap Allocator, primary template |
| Cstd::from_chars_result | Result type of std::from_chars |
| Cstd::gamma_distribution< _RealType > | A gamma continuous distribution for random numbers |
| Cstd::gamma_distribution< double > | |
| Cstd::gamma_distribution< result_type > | |
| Cstd::geometric_distribution< _IntType > | A discrete geometric random number distribution |
| Cstd::greater< void > | One of the comparison functors |
| Cstd::greater_equal< void > | One of the comparison functors |
| C__gnu_cxx::random_condition::group_adjustor | Group condition |
| Cstd::gslice | Class defining multi-dimensional subset of an array |
| Cstd::gslice_array< _Tp > | Reference to multi-dimensional subset of an array |
| Cstd::hash< _Tp > | Primary class template hash |
| Cstd::hash< __debug::bitset< _Nb > > | Std::hash specialization for bitset |
| Cstd::hash< __debug::vector< bool, _Alloc > > | Std::hash specialization for vector<bool> |
| Cstd::hash< __gnu_cxx::__u16vstring > | Std::hash specialization for __u16vstring |
| Cstd::hash< __gnu_cxx::__u32vstring > | Std::hash specialization for __u32vstring |
| Cstd::hash< __gnu_cxx::__vstring > | Std::hash specialization for __vstring |
| Cstd::hash< __gnu_cxx::__wvstring > | Std::hash specialization for __wvstring |
| Cstd::hash< __shared_ptr< _Tp, _Lp > > | Std::hash specialization for __shared_ptr |
| Cstd::hash< _Tp * > | Partial specializations for pointer types |
| Cstd::hash< bool > | Explicit specialization for bool |
| Cstd::hash< char > | Explicit specialization for char |
| Cstd::hash< char16_t > | Explicit specialization for char16_t |
| Cstd::hash< char32_t > | Explicit specialization for char32_t |
| Cstd::hash< double > | Specialization for double |
| Cstd::hash< error_code > | Std::hash specialization for error_code |
| Cstd::hash< experimental::optional< _Tp > > | Std::hash partial specialization for experimental::optional |
| Cstd::hash< experimental::shared_ptr< _Tp > > | Std::hash specialization for shared_ptr |
| Cstd::hash< float > | Specialization for float |
| Cstd::hash< int > | Explicit specialization for int |
| Cstd::hash< long > | Explicit specialization for long |
| Cstd::hash< long double > | Specialization for long double |
| Cstd::hash< long long > | Explicit specialization for long long |
| Cstd::hash< shared_ptr< _Tp > > | Std::hash specialization for shared_ptr |
| Cstd::hash< short > | Explicit specialization for short |
| Cstd::hash< signed char > | Explicit specialization for signed char |
| Cstd::hash< string > | Std::hash specialization for string |
| Cstd::hash< thread::id > | Std::hash specialization for thread::id |
| Cstd::hash< type_index > | Std::hash specialization for type_index |
| Cstd::hash< u16string > | Std::hash specialization for u16string |
| Cstd::hash< u32string > | Std::hash specialization for u32string |
| Cstd::hash< unique_ptr< _Tp, _Dp > > | Std::hash specialization for unique_ptr |
| Cstd::hash< unsigned char > | Explicit specialization for unsigned char |
| Cstd::hash< unsigned int > | Explicit specialization for unsigned int |
| Cstd::hash< unsigned long > | Explicit specialization for unsigned long |
| Cstd::hash< unsigned long long > | Explicit specialization for unsigned long long |
| Cstd::hash< unsigned short > | Explicit specialization for unsigned short |
| Cstd::hash< wchar_t > | Explicit specialization for wchar_t |
| Cstd::hash< wstring > | Std::hash specialization for wstring |
| Cstd::hash<::bitset< _Nb > > | Std::hash specialization for bitset |
| Cstd::hash<::vector< bool, _Alloc > > | Std::hash specialization for vector<bool> |
| ▼C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, Store_Hash > | Primary template |
| C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy > | |
| C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy > | |
| C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, false > | Specialization 1 - The client requests that hash values not be stored |
| C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, true > | Specialization 2 - The client requests that hash values be stored |
| C__gnu_pbds::hash_exponential_size_policy< Size_Type > | A size policy whose sequence of sizes form an exponential sequence (typically powers of 2 |
| C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, Hold_Size > | Primary template |
| ▼C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, External_Load_Access > | |
| C__gnu_pbds::hash_load_check_resize_trigger< External_Load_Access, Size_Type > | A resize trigger policy based on a load check. It keeps the load factor between some load factors load_min and load_max |
| C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, true > | Specializations |
| C__gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc > | |
| C__gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqualKey, _Alloc > | |
| C__gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > | |
| C__gnu_pbds::hash_prime_size_policy | A size policy whose sequence of sizes form a nearly-exponential sequence of primes |
| C__gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc > | |
| C__gnu_pbds::hash_standard_resize_policy< Size_Policy, Trigger_Policy, External_Size_Access, Size_Type > | A resize policy which delegates operations to size and trigger policies |
| Cstd::locale::id | Facet ID class.The ID class provides facets with an index used to identify them. Every facet class must define a public static member locale::id, or be derived from a facet that provides this member, otherwise the facet cannot be used in a locale. The locale::id ensures that each class type gets a unique identifier |
| Cstd::thread::id | Thread::id |
| Cstd::experimental::fundamentals_v1::in_place_t | Tag type for in-place construction |
| Cstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > | |
| Cstd::indirect_array< _Tp > | Reference to arbitrary subset of an array |
| Cstd::initializer_list< _E > | Initializer_list |
| ▼Cstd::input_iterator_tag | Marking input iterators |
| ▼Cstd::forward_iterator_tag | Forward iterators support a superset of input iterator operations |
| ▼Cstd::bidirectional_iterator_tag | Bidirectional iterators support a superset of forward iterator operations |
| Cstd::random_access_iterator_tag | Random-access iterators support a superset of bidirectional iterator operations |
| Cstd::integer_sequence< _Tp, _Idx > | Class template integer_sequence |
| ▼Cstd::integral_constant< _Tp, __v > | Integral_constant |
| Cstd::__is_tuple_like_impl< std::pair< _T1, _T2 > > | Partial specialization for std::pair |
| Cstd::is_array< typename > | Is_array |
| Cstd::is_assignable< _Tp, _Up > | Is_assignable |
| Cstd::is_bind_expression< _Tp > | Determines if the given type _Tp is a function object that should be treated as a subexpression when evaluating calls to function objects returned by bind() |
| Cstd::is_bind_expression< _Bind< _Signature > > | Class template _Bind is always a bind expression |
| Cstd::is_bind_expression< _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression |
| Cstd::is_bind_expression< const _Bind< _Signature > > | Class template _Bind is always a bind expression |
| Cstd::is_bind_expression< const _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression |
| Cstd::is_bind_expression< const volatile _Bind< _Signature > > | Class template _Bind is always a bind expression |
| Cstd::is_bind_expression< const volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression |
| Cstd::is_bind_expression< volatile _Bind< _Signature > > | Class template _Bind is always a bind expression |
| Cstd::is_bind_expression< volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression |
| Cstd::is_compound< _Tp > | Is_compound |
| Cstd::is_const< typename > | Is_const |
| Cstd::is_error_code_enum< _Tp > | Is_error_code_enum |
| Cstd::is_error_code_enum< future_errc > | Specialization |
| Cstd::is_error_condition_enum< _Tp > | Is_error_condition_enum |
| Cstd::is_function< _Tp > | Is_function |
| Cstd::is_integral< _Tp > | Is_integral |
| Cstd::is_lvalue_reference< typename > | Is_lvalue_reference |
| Cstd::is_member_function_pointer< _Tp > | Is_member_function_pointer |
| Cstd::is_member_pointer< _Tp > | Is_member_pointer |
| Cstd::is_nothrow_constructible< _Tp, _Args > | Is_nothrow_constructible |
| Cstd::is_nothrow_default_constructible< _Tp > | Is_nothrow_default_constructible |
| Cstd::is_object< _Tp > | Is_object |
| Cstd::is_rvalue_reference< typename > | Is_rvalue_reference |
| Cstd::is_same< _Tp, _Up > | Is_same |
| Cstd::is_trivially_assignable< _Tp, _Up > | Is_trivially_assignable |
| Cstd::is_trivially_constructible< _Tp, _Args > | Is_trivially_constructible |
| Cstd::is_trivially_default_constructible< _Tp > | Is_trivially_default_constructible |
| Cstd::is_void< _Tp > | Is_void |
| Cstd::is_volatile< typename > | Is_volatile |
| Cstd::uses_allocator< tuple< _Types... >, _Alloc > | Partial specialization for tuples |
| ▼Cstd::integral_constant< bool, !ratio_equal< _R1, _R2 >::value > | |
| Cstd::ratio_not_equal< _R1, _R2 > | Ratio_not_equal |
| ▼Cstd::integral_constant< bool, !ratio_less< _R1, _R2 >::value > | |
| Cstd::ratio_greater_equal< _R1, _R2 > | Ratio_greater_equal |
| ▼Cstd::integral_constant< bool, !ratio_less< _R2, _R1 >::value > | |
| Cstd::ratio_less_equal< _R1, _R2 > | Ratio_less_equal |
| ▼Cstd::integral_constant< bool, __has_virtual_destructor(_Tp)> | |
| Cstd::has_virtual_destructor< _Tp > | Has_virtual_destructor |
| ▼Cstd::integral_constant< bool, __is_abstract(_Tp)> | |
| Cstd::is_abstract< _Tp > | Is_abstract |
| ▼Cstd::integral_constant< bool, __is_base_of(_Base, _Derived)> | |
| Cstd::is_base_of< _Base, _Derived > | Is_base_of |
| ▼Cstd::integral_constant< bool, __is_base_of(random_access_iterator_tag, _Cat)> | |
| Cstd::is_base_of< random_access_iterator_tag, _Cat > | |
| ▼Cstd::integral_constant< bool, __is_class(_Tp)> | |
| Cstd::is_class< _Tp > | Is_class |
| ▼Cstd::integral_constant< bool, __is_empty(_Tp)> | |
| Cstd::is_empty< _Tp > | Is_empty |
| ▼Cstd::integral_constant< bool, __is_enum(_Tp)> | |
| Cstd::is_enum< _Tp > | Is_enum |
| ▼Cstd::integral_constant< bool, __is_final(_Tp)> | |
| Cstd::is_final< _Tp > | Is_final |
| ▼Cstd::integral_constant< bool, __is_literal_type(_Tp)> | |
| Cstd::is_literal_type< _Tp > | Is_literal_type |
| ▼Cstd::integral_constant< bool, __is_pod(_Tp)> | |
| Cstd::is_pod< _Tp > | Is_pod (deprecated in C++20) |
| ▼Cstd::integral_constant< bool, __is_polymorphic(_Tp)> | |
| Cstd::is_polymorphic< _Tp > | Is_polymorphic |
| ▼Cstd::integral_constant< bool, __is_standard_layout(_Tp)> | |
| Cstd::is_standard_layout< _Tp > | Is_standard_layout |
| ▼Cstd::integral_constant< bool, __is_trivial(_Tp)> | |
| Cstd::is_trivial< _Tp > | Is_trivial |
| Cstd::integral_constant< bool, __is_trivially_copyable(_Tp)> | |
| ▼Cstd::integral_constant< bool, __is_union(_Tp)> | |
| Cstd::is_union< _Tp > | Is_union |
| ▼Cstd::integral_constant< bool, _R1::num==_R2::num &&_R1::den==_R2::den > | |
| Cstd::ratio_equal< _R1, _R2 > | Ratio_equal |
| Cstd::integral_constant< bool, noexcept(declval< _Tp >()=declval< _Up >())> | |
| ▼Cstd::integral_constant< bool, ratio_less< _R2, _R1 >::value > | |
| Cstd::ratio_greater< _R1, _R2 > | Ratio_greater |
| ▼Cstd::integral_constant< int, 0 > | |
| Cstd::is_placeholder< _Tp > | Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is |
| ▼Cstd::integral_constant< int, _Num > | |
| Cstd::is_placeholder< _Placeholder< _Num > > | |
| ▼Cstd::integral_constant< std::size_t, 0 > | |
| Cstd::extent< typename, _Uint > | Extent |
| Cstd::rank< typename > | Rank |
| Cstd::integral_constant< std::size_t, 1+rank< _Tp >::value > | |
| ▼Cstd::integral_constant< std::size_t, 2 > | |
| Cstd::tuple_size< std::pair< _Tp1, _Tp2 > > | Partial specialization for std::pair |
| ▼Cstd::integral_constant< std::size_t, _Nm > | |
| Cstd::tuple_size< std::__debug::array< _Tp, _Nm > > | Tuple_size |
| Cstd::tuple_size<::array< _Tp, _Nm > > | Partial specialization for std::array |
| Cstd::integral_constant< std::size_t, _Uint==0 ? 0 :extent< _Tp, _Uint - 1 >::value > | |
| Cstd::integral_constant< std::size_t, _Uint==0 ? _Size :extent< _Tp, _Uint - 1 >::value > | |
| ▼Cstd::integral_constant< std::size_t, alignof(_Tp)> | |
| Cstd::alignment_of< _Tp > | Alignment_of |
| ▼Cstd::integral_constant< std::size_t, sizeof...(_Elements)> | |
| Cstd::tuple_size< tuple< _Elements... > > | Class tuple_size |
| Cstd::integral_constant< unsigned, 0 > | |
| Cstd::integral_constant< unsigned, 1 > | |
| Cstd::integral_constant< unsigned, _Val > | |
| ▼Cstd::ios_base | The base of the I/O class hierarchy.This class defines everything that can be defined about I/O that does not depend on the type of characters being input or output. Most people will only see ios_base when they need to specify the full name of the various I/O flags (e.g., the openmodes) |
| ▼Cstd::basic_ios< char, _Traits > | |
| Cstd::basic_istream< char > | |
| ▼Cstd::basic_istream< char, _Traits > | |
| Cstd::basic_iostream< char > | |
| Cstd::basic_ostream< char > | |
| ▼Cstd::basic_ostream< char, _Traits > | |
| Cstd::basic_iostream< char > | |
| ▼Cstd::basic_ios< _CharT, _Traits > | Template class basic_ios, virtual base class for all stream classes |
| ▼Cstd::basic_istream< _CharT, _Traits > | Template class basic_istream |
| Cstd::basic_ifstream< _CharT, _Traits > | Controlling input for files |
| ▼Cstd::basic_iostream< _CharT, _Traits > | Template class basic_iostream |
| Cstd::basic_fstream< _CharT, _Traits > | Controlling input and output for files |
| Cstd::basic_stringstream< _CharT, _Traits, _Alloc > | Controlling input and output for std::string |
| Cstd::basic_istringstream< _CharT, _Traits, _Alloc > | Controlling input for std::string |
| ▼Cstd::basic_ostream< _CharT, _Traits > | Template class basic_ostream |
| Cstd::basic_iostream< _CharT, _Traits > | Template class basic_iostream |
| Cstd::basic_ofstream< _CharT, _Traits > | Controlling output for files |
| Cstd::basic_ostringstream< _CharT, _Traits, _Alloc > | Controlling output for std::string |
| Cstd::is_arithmetic< _Tp > | Is_arithmetic |
| Cstd::is_constructible< _Tp, _Args > | Is_constructible |
| Cstd::is_convertible< _From, _To > | Is_convertible |
| Cstd::is_copy_assignable< _Tp > | Is_copy_assignable |
| Cstd::is_copy_constructible< _Tp > | Is_copy_constructible |
| Cstd::is_default_constructible< _Tp > | Is_default_constructible |
| Cstd::is_destructible< _Tp > | Is_destructible |
| Cstd::is_floating_point< _Tp > | Is_floating_point |
| ▼Cstd::is_floating_point< _Rep > | |
| Cstd::chrono::treat_as_floating_point< _Rep > | Treat_as_floating_point |
| Cstd::is_fundamental< _Tp > | Is_fundamental |
| Cstd::is_member_object_pointer< _Tp > | Is_member_object_pointer |
| Cstd::is_move_assignable< _Tp > | Is_move_assignable |
| Cstd::is_move_constructible< _Tp > | Is_move_constructible |
| Cstd::is_nothrow_assignable< _Tp, _Up > | Is_nothrow_assignable |
| Cstd::is_nothrow_copy_assignable< _Tp > | Is_nothrow_copy_assignable |
| Cstd::is_nothrow_copy_constructible< _Tp > | Is_nothrow_copy_constructible |
| Cstd::is_nothrow_destructible< _Tp > | Is_nothrow_destructible |
| Cstd::is_nothrow_move_assignable< _Tp > | Is_nothrow_move_assignable |
| Cstd::is_nothrow_move_constructible< _Tp > | Is_nothrow_move_constructible |
| Cstd::is_nothrow_swappable< _Tp > | Is_nothrow_swappable |
| Cstd::is_nothrow_swappable_with< _Tp, _Up > | Is_nothrow_swappable_with |
| ▼Cstd::is_null_pointer< _Tp > | Is_null_pointer (LWG 2247) |
| Cstd::__is_nullptr_t< _Tp > | __is_nullptr_t (deprecated extension) |
| Cstd::is_pointer< _Tp > | Is_pointer |
| Cstd::is_reference< _Tp > | Is_reference |
| Cstd::is_scalar< _Tp > | Is_scalar |
| Cstd::is_swappable< _Tp > | Metafunctions used for detecting swappable types: p0185r1 |
| Cstd::is_swappable_with< _Tp, _Up > | Is_swappable_with |
| Cstd::is_trivially_copy_assignable< _Tp > | Is_trivially_copy_assignable |
| Cstd::is_trivially_copy_constructible< _Tp > | Is_trivially_copy_constructible |
| Cstd::is_trivially_destructible< _Tp > | Is_trivially_destructible |
| Cstd::is_trivially_move_assignable< _Tp > | Is_trivially_move_assignable |
| Cstd::is_trivially_move_constructible< _Tp > | Is_trivially_move_constructible |
| Cstd::is_void< _To > | |
| Cstd::experimental::filesystem::v1::path::iterator | An iterator for the components of a path |
| Cstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference > | Common iterator class |
| ▼Cstd::iterator< input_iterator_tag, _CharT, _Traits::off_type, _CharT *, _CharT > | |
| Cstd::istreambuf_iterator< _CharT, _Traits > | Provides input iterator semantics for streambufs |
| ▼Cstd::iterator< input_iterator_tag, _Tp, _Dist, const _Tp *, const _Tp &> | |
| Cstd::istream_iterator< _Tp, _CharT, _Traits, _Dist > | Provides input iterator semantics for streams |
| ▼Cstd::iterator< iterator_traits< _Iterator >::iterator_category, iterator_traits< _Iterator >::value_type, iterator_traits< _Iterator >::difference_type, iterator_traits< _Iterator >::pointer, iterator_traits< _Iterator >::reference > | |
| Cstd::reverse_iterator< _Iterator > | |
| ▼Cstd::iterator< output_iterator_tag, void, void, void, void > | |
| Cstd::back_insert_iterator< _Container > | Turns assignment into insertion |
| Cstd::front_insert_iterator< _Container > | Turns assignment into insertion |
| Cstd::insert_iterator< _Container > | Turns assignment into insertion |
| Cstd::ostream_iterator< _Tp, _CharT, _Traits > | Provides output iterator semantics for streams |
| Cstd::ostreambuf_iterator< _CharT, _Traits > | Provides output iterator semantics for streambufs |
| Cstd::raw_storage_iterator< _OutputIterator, _Tp > | |
| Cstd::iterator< std::output_iterator_tag, void, void, void, void > | |
| Cstd::iterator< std::random_access_iterator_tag, _CharT > | |
| Cstd::iterator< std::random_access_iterator_tag, bool > | |
| Cstd::iterator_traits< _Iterator > | Traits class for iterators |
| Cstd::iterator_traits< _Tp * > | Partial specialization for pointer types |
| Cstd::iterator_traits< _Tp > | |
| Cstd::iterator_traits< const _Tp * > | Partial specialization for const pointer types |
| C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, Node_Metadata, _Alloc > | Base class for a basic heap |
| ▼C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, _Alloc::size_type, _Alloc > | |
| ▼C__gnu_pbds::detail::binomial_heap_base< Value_Type, Cmp_Fn, _Alloc > | Base class for binomial heap |
| C__gnu_pbds::detail::binomial_heap< Value_Type, Cmp_Fn, _Alloc > | |
| C__gnu_pbds::detail::rc_binomial_heap< Value_Type, Cmp_Fn, _Alloc > | |
| C__gnu_pbds::detail::thin_heap< Value_Type, Cmp_Fn, _Alloc > | |
| ▼C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, null_type, _Alloc > | |
| C__gnu_pbds::detail::pairing_heap< Value_Type, Cmp_Fn, _Alloc > | |
| C__gnu_pbds::detail::left_child_next_sibling_heap_node_< _Value, _Metadata, _Alloc > | Node |
| ▼C__gnu_pbds::detail::left_child_next_sibling_heap_node_point_const_iterator_< Node, _Alloc > | Const point-type iterator |
| C__gnu_pbds::detail::left_child_next_sibling_heap_const_iterator_< Node, _Alloc > | Const point-type iterator |
| Cstd::less< void > | One of the comparison functors |
| Cstd::less_equal< void > | One of the comparison functors |
| C__gnu_cxx::limit_condition::limit_adjustor | Enter the nth condition |
| Cstd::linear_congruential_engine< _UIntType, __a, __c, __m > | A model of a linear congruential random number generator |
| C__gnu_pbds::linear_probe_fn< Size_Type > | A probe sequence policy using fixed increments |
| C__gnu_pbds::list_update< Key, Mapped, Eq_Fn, Update_Policy, _Alloc > | |
| Cstd::locale | Container class for localization functionality.The locale class is first a class wrapper for C library locales. It is also an extensible container for user-defined localization. A locale is a collection of facets that implement various localization features such as money, time, and number printing |
| Cstd::lock_guard< _Mutex > | A simple scoped lock type |
| Cstd::logical_and< void > | One of the Boolean operations functors |
| Cstd::logical_not< void > | One of the Boolean operations functors |
| Cstd::logical_or< void > | One of the Boolean operations functors |
| Cstd::lognormal_distribution< _RealType > | A lognormal_distribution random number distribution |
| C__gnu_pbds::detail::lu_counter_metadata< Size_Type > | A list-update metadata type that moves elements to the front of the list based on the counter algorithm |
| C__gnu_pbds::detail::lu_counter_policy_base< Size_Type > | Base class for list-update counter policy |
| ▼C__gnu_pbds::detail::lu_counter_policy_base< _Alloc::size_type > | |
| C__gnu_pbds::lu_counter_policy< Max_Count, _Alloc > | |
| C__gnu_pbds::lu_move_to_front_policy< _Alloc > | |
| Cstd::make_signed< _Tp > | Make_signed |
| Cstd::make_unsigned< _Tp > | Make_unsigned |
| Cstd::make_unsigned< _DiffT > | |
| C__gnu_cxx::malloc_allocator< _Tp > | An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard |
| Cstd::map< _Key, _Tp, _Compare, _Alloc > | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time |
| Cstd::mask_array< _Tp > | Reference to selected subset of an array |
| ▼C__gnu_pbds::detail::mask_based_range_hashing< Size_Type > | Range hashing policy |
| C__gnu_pbds::direct_mask_range_hashing< Size_Type > | A mask range-hashing class (uses a bitmask) |
| ▼C__gnu_pbds::detail::maybe_null_type< Key, Mapped, _Alloc, Store_Hash > | Base class for conditionally defining a static data member |
| ▼C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, Store_Hash > | Traits for abstract types |
| C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy > | |
| C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy > | |
| ▼C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, false > | |
| C__gnu_pbds::detail::lu_map< Key, Mapped, Eq_Fn, _Alloc, Update_Policy > | List-based (with updates) associative container. Skip to the lu, my darling |
| C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc > | Ordered-vector tree associative-container |
| C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc > | PATRICIA trie.This implementation loosely borrows ideas from: 1) Fast Mergeable Integer Maps, Okasaki, Gill 1998 2) Ptset: Sets of integers implemented as Patricia trees, Jean-Christophe Filliatr, 2000 |
| C__gnu_pbds::detail::maybe_null_type< Key, null_type, _Alloc, Store_Hash > | Specialization that defines a static data member of type null_type |
| Cstd::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > | |
| Cstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > | |
| ▼Cstd::messages_base | Messages facet base class providing catalog typedef |
| Cstd::messages< _CharT > | Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined |
| Cstd::minus< void > | One of the math functors |
| ▼C__gnu_pbds::detail::mod_based_range_hashing< Size_Type > | Mod based range hashing |
| C__gnu_pbds::direct_mod_range_hashing< Size_Type > | A mod range-hashing class (uses the modulo function) |
| Cstd::modulus< void > | One of the math functors |
| ▼Cstd::money_base | Money format ordering data.This class contains an ordered array of 4 fields to represent the pattern for formatting a money amount. Each field may contain one entry from the part enum. symbol, sign, and value must be present and the remaining field must contain either none or space |
| Cstd::moneypunct< _CharT, _Intl > | Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations |
| Cstd::move_iterator< _Iterator > | |
| Cstd::multimap< _Key, _Tp, _Compare, _Alloc > | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time |
| Cstd::multiplies< void > | One of the math functors |
| Cstd::multiset< _Key, _Compare, _Alloc > | A standard container made up of elements, which can be retrieved in logarithmic time |
| Cstd::mutex | The standard mutex type |
| Cstd::negate< void > | One of the math functors |
| Cstd::negative_binomial_distribution< _IntType > | A negative_binomial_distribution random number distribution |
| Cstd::nested_exception | Exception class with exception_ptr data member |
| C__gnu_cxx::limit_condition::never_adjustor | Never enter the condition |
| C__gnu_cxx::random_condition::never_adjustor | Never enter the condition |
| ▼C__gnu_cxx::new_allocator< _Tp > | An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard |
| Cstd::allocator< value_type > | |
| Cstd::allocator< _Tp > | The standard allocator, as per [20.4] |
| C__gnu_pbds::detail::no_throw_copies< Key, Mapped > | Primary template |
| C__gnu_pbds::detail::no_throw_copies< Key, null_type > | Specialization |
| Cstd::normal_distribution< _RealType > | A normal continuous distribution for random numbers |
| Cstd::normal_distribution< double > | |
| Cstd::normal_distribution< result_type > | |
| Cstd::not_equal_to< void > | One of the comparison functors |
| ▼C__gnu_pbds::null_type | Represents no type, or absence of type, for template tricks |
| C__gnu_pbds::null_node_update< _Tp1, _Tp2, _Tp3, _Tp4 > | A null node updator, indicating that no node updates are required |
| Cstd::experimental::fundamentals_v1::nullopt_t | Tag type to disengage optional objects |
| Cstd::numeric_limits< bool > | Numeric_limits<bool> specialization |
| Cstd::numeric_limits< char > | Numeric_limits<char> specialization |
| Cstd::numeric_limits< char16_t > | Numeric_limits<char16_t> specialization |
| Cstd::numeric_limits< char32_t > | Numeric_limits<char32_t> specialization |
| Cstd::numeric_limits< double > | Numeric_limits<double> specialization |
| Cstd::numeric_limits< float > | Numeric_limits<float> specialization |
| Cstd::numeric_limits< int > | Numeric_limits<int> specialization |
| Cstd::numeric_limits< long > | Numeric_limits<long> specialization |
| Cstd::numeric_limits< long double > | Numeric_limits<long double> specialization |
| Cstd::numeric_limits< long long > | Numeric_limits<long long> specialization |
| Cstd::numeric_limits< short > | Numeric_limits<short> specialization |
| Cstd::numeric_limits< signed char > | Numeric_limits<signed char> specialization |
| Cstd::numeric_limits< unsigned char > | Numeric_limits<unsigned char> specialization |
| Cstd::numeric_limits< unsigned int > | Numeric_limits<unsigned int> specialization |
| Cstd::numeric_limits< unsigned long > | Numeric_limits<unsigned long> specialization |
| Cstd::numeric_limits< unsigned long long > | Numeric_limits<unsigned long long> specialization |
| Cstd::numeric_limits< unsigned short > | Numeric_limits<unsigned short> specialization |
| Cstd::numeric_limits< wchar_t > | Numeric_limits<wchar_t> specialization |
| Cstd::once_flag | Flag type used by std::call_once |
| Cstd::experimental::fundamentals_v2::ostream_joiner< _DelimT, _CharT, _Traits > | Output iterator that inserts a delimiter between elements |
| Cstd::output_iterator_tag | Marking output iterators |
| ▼C__gnu_pbds::detail::ov_tree_node_const_it_< Value_Type, Metadata_Type, _Alloc > | Const node reference |
| C__gnu_pbds::detail::ov_tree_node_it_< Value_Type, Metadata_Type, _Alloc > | Node reference |
| Cstd::owner_less< _Tp > | Primary template owner_less |
| Cstd::experimental::fundamentals_v2::owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr |
| Cstd::owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr |
| Cstd::owner_less< void > | Void specialization of owner_less compares either shared_ptr or weak_ptr |
| Cstd::experimental::fundamentals_v2::owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr |
| Cstd::owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr |
| Cstd::packaged_task< _Res(_ArgTypes...)> | Packaged_task |
| Cstd::pair< _T1, _T2 > | Struct holding two objects of arbitrary type |
| ▼Cstd::pair< _Bi_iter, _Bi_iter > | |
| Cstd::sub_match< _Bi_iter > | |
| ▼Cstd::pair< _BiIter, _BiIter > | |
| Cstd::sub_match< _BiIter > | |
| ▼Cstd::pair< _Iterator1, _Iterator2 > | |
| C__gnu_parallel::_IteratorPair< _Iterator1, _Iterator2, _IteratorCategory > | A pair of iterators. The usual iterator operations are applied to both child iterators |
| Cstd::pair< _RAIter, _RAIter > | |
| Cstd::pair< char, _TokenT > | |
| Cstd::pair< char, char > | |
| Cstd::pair< entry_pointer, typename _Alloc::size_type > | |
| ▼C__gnu_parallel::parallel_tag | Recommends parallel execution at compile time, optionally using a user-specified number of threads |
| C__gnu_parallel::balanced_quicksort_tag | Forces parallel sorting using balanced quicksort at compile time |
| C__gnu_parallel::balanced_tag | Recommends parallel execution using dynamic load-balancing at compile time |
| C__gnu_parallel::default_parallel_tag | Recommends parallel execution using the default parallel algorithm |
| C__gnu_parallel::exact_tag | Forces parallel merging with exact splitting, at compile time |
| C__gnu_parallel::multiway_mergesort_exact_tag | Forces parallel sorting using multiway mergesort with exact splitting at compile time |
| C__gnu_parallel::multiway_mergesort_sampling_tag | Forces parallel sorting using multiway mergesort with splitting by sampling at compile time |
| C__gnu_parallel::multiway_mergesort_tag | Forces parallel sorting using multiway mergesort at compile time |
| C__gnu_parallel::omp_loop_static_tag | Recommends parallel execution using OpenMP static load-balancing at compile time |
| C__gnu_parallel::omp_loop_tag | Recommends parallel execution using OpenMP dynamic load-balancing at compile time |
| C__gnu_parallel::quicksort_tag | Forces parallel sorting using unbalanced quicksort at compile time |
| C__gnu_parallel::sampling_tag | Forces parallel merging with exact splitting, at compile time |
| C__gnu_parallel::unbalanced_tag | Recommends parallel execution using static load-balancing at compile time |
| Cstd::extreme_value_distribution< _RealType >::param_type | |
| Cstd::normal_distribution< _RealType >::param_type | |
| Cstd::gamma_distribution< _RealType >::param_type | |
| Cstd::cauchy_distribution< _RealType >::param_type | |
| Cstd::exponential_distribution< _RealType >::param_type | |
| Cstd::uniform_int_distribution< _IntType >::param_type | |
| Cstd::chi_squared_distribution< _RealType >::param_type | |
| Cstd::discrete_distribution< _IntType >::param_type | |
| Cstd::fisher_f_distribution< _RealType >::param_type | |
| Cstd::lognormal_distribution< _RealType >::param_type | |
| Cstd::poisson_distribution< _IntType >::param_type | |
| Cstd::uniform_real_distribution< _RealType >::param_type | |
| Cstd::piecewise_constant_distribution< _RealType >::param_type | |
| Cstd::geometric_distribution< _IntType >::param_type | |
| Cstd::piecewise_linear_distribution< _RealType >::param_type | |
| Cstd::weibull_distribution< _RealType >::param_type | |
| Cstd::negative_binomial_distribution< _IntType >::param_type | |
| Cstd::bernoulli_distribution::param_type | |
| Cstd::student_t_distribution< _RealType >::param_type | |
| Cstd::binomial_distribution< _IntType >::param_type | |
| ▼C__gnu_pbds::detail::pat_trie_base | Base type for PATRICIA trees |
| C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc > | PATRICIA trie.This implementation loosely borrows ideas from: 1) Fast Mergeable Integer Maps, Okasaki, Gill 1998 2) Ptset: Sets of integers implemented as Patricia trees, Jean-Christophe Filliatr, 2000 |
| Cstd::experimental::filesystem::v1::path | A filesystem path |
| Cstd::piecewise_constant_distribution< _RealType > | A piecewise_constant_distribution random number distribution |
| Cstd::piecewise_construct_t | Tag type for piecewise construction of std::pair objects |
| Cstd::piecewise_linear_distribution< _RealType > | A piecewise_linear_distribution random number distribution |
| Cstd::pointer_traits< _Ptr > | Uniform interface to all pointer-like types |
| Cstd::pointer_traits< _Tp * > | Partial specialization for built-in pointers |
| Cstd::poisson_distribution< _IntType > | A discrete Poisson random number distribution |
| C__gnu_pbds::priority_queue< _Tv, Cmp_Fn, Tag, _Alloc > | |
| Cstd::priority_queue< _Tp, _Sequence, _Compare > | A standard container automatically sorting its contents |
| C__gnu_pbds::detail::probe_fn_base< _Alloc > | Probe functor base |
| C__gnu_cxx::project1st< _Arg1, _Arg2 > | An SGI extension |
| C__gnu_cxx::project2nd< _Arg1, _Arg2 > | An SGI extension |
| Cstd::promise< _Res > | Primary template for promise |
| Cstd::promise< _Res & > | Partial specialization for promise<R&> |
| Cstd::promise< void > | Explicit specialization for promise<void> |
| Cstd::experimental::fundamentals_v2::propagate_const< _Tp > | Const-propagating wrapper |
| C__gnu_pbds::quadratic_probe_fn< Size_Type > | A probe sequence policy using square increments |
| Cstd::queue< _Tp, _Sequence > | A standard container giving FIFO behavior |
| Cstd::random_device | |
| ▼C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, Store_Hash > | Primary template |
| C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy > | |
| C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false > | |
| C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true > | |
| C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false > | |
| C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true > | |
| ▼C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash > | Primary template |
| C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy > | |
| C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false > | |
| C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true > | |
| C__gnu_pbds::detail::ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false > | |
| Cstd::ratio< _Num, _Den > | Provides compile-time rational arithmetic |
| Cstd::ratio_less< _R1, _R2 > | Ratio_less |
| C__gnu_cxx::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > | |
| C__gnu_pbds::detail::rb_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc > | Red-Black tree.This implementation uses an idea from the SGI STL (using a header node which is needed for efficient iteration) |
| C__gnu_pbds::detail::rb_tree_node_< Value_Type, Metadata, _Alloc > | Node for Red-Black trees |
| C__gnu_pbds::detail::rc< _Node, _Alloc > | Redundant binary counter |
| C__gnu_pbds::detail::rc< typename binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >::node, _Alloc > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, T > | Consistent API for accessing allocator-related types |
| C__gnu_pbds::detail::rebind_traits< _Alloc, _Node_base > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, Entry > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, entry > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, Metadata_Type > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, Node > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, node > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, rb_tree_node_ > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, splay_tree_node_ > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, this_type > | |
| C__gnu_pbds::detail::rebind_traits< _Alloc, Value_Type > | |
| Cstd::recursive_mutex | The standard recursive mutex type |
| Cstd::recursive_timed_mutex | Recursive_timed_mutex |
| Cstd::bitset< _Nb >::reference | |
| Cstd::tr2::dynamic_bitset< _WordT, _Alloc >::reference | |
| Cstd::reference_wrapper< _Tp > | Primary class template for reference_wrapper |
| Cstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits > | |
| Cstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits > | |
| Cstd::regex_traits< _Ch_type > | Describes aspects of a regular expression |
| Cstd::regex_traits< _CharType > | |
| Cstd::remove_all_extents< _Tp > | Remove_all_extents |
| Cstd::remove_const< _Tp > | Remove_const |
| Cstd::remove_cv< _Tp > | Remove_cv |
| Cstd::remove_extent< _Tp > | Remove_extent |
| Cstd::remove_pointer< _Tp > | Remove_pointer |
| Cstd::remove_reference< _Tp > | Remove_reference |
| Cstd::remove_volatile< _Tp > | Remove_volatile |
| C__gnu_pbds::detail::resize_policy< _Tp > | Resize policy for binary heap |
| ▼C__gnu_pbds::detail::resize_policy< _Alloc::size_type > | |
| C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc > | |
| Cstd::result_of< _Signature > | Result_of |
| C__gnu_cxx::rope< _CharT, _Alloc > | |
| C__gnu_pbds::sample_probe_fn | A sample probe policy |
| C__gnu_pbds::sample_range_hashing | A sample range-hashing functor |
| C__gnu_pbds::sample_ranged_hash_fn | A sample ranged-hash functor |
| C__gnu_pbds::sample_ranged_probe_fn | A sample ranged-probe functor |
| C__gnu_pbds::sample_resize_policy | A sample resize policy |
| C__gnu_pbds::sample_resize_trigger | A sample resize trigger policy |
| C__gnu_pbds::sample_size_policy | A sample size policy |
| C__gnu_pbds::sample_tree_node_update< Const_Node_Iter, Node_Iter, Cmp_Fn, _Alloc > | A sample node updator |
| C__gnu_pbds::sample_trie_access_traits | A sample trie element access traits |
| C__gnu_pbds::sample_trie_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc > | A sample node updator |
| C__gnu_pbds::sample_update_policy | A sample list-update policy |
| Cstd::scoped_allocator_adaptor< _OuterAlloc, _InnerAllocs > | An adaptor to recursively pass an allocator to the objects it constructs |
| Cstd::seed_seq | Generates sequences of seeds for random number generators |
| C__gnu_cxx::select1st< _Pair > | An SGI extension |
| C__gnu_cxx::select2nd< _Pair > | An SGI extension |
| C__gnu_pbds::detail::select_value_type< Key, Mapped > | Choose value_type to be a key/value pair or just a key |
| C__gnu_pbds::detail::select_value_type< Key, null_type > | Specialization for sets where the key is the value_type |
| Cstd::basic_ostream< _CharT, _Traits >::sentry | Performs setup work for output streams |
| Cstd::basic_istream< _CharT, _Traits >::sentry | Performs setup work for input streams |
| C__gnu_parallel::sequential_tag | Forces sequential execution at compile time |
| Cstd::set< _Key, _Compare, _Alloc > | A standard container made up of unique keys, which can be retrieved in logarithmic time |
| Cstd::shared_lock< _Mutex > | Shared_lock |
| Cstd::shared_ptr< _Tp > | A smart pointer with reference-counted copy semantics |
| Cstd::shared_ptr< _Dir > | |
| Cstd::shared_ptr< _Dir_stack > | |
| Cstd::shared_ptr< _RegexT > | |
| Cstd::shared_ptr< _State > | |
| Cstd::shared_ptr< _State_base > | |
| Cstd::shared_ptr< _State_type > | |
| Cstd::shared_ptr< const __detail::_NFA< _Rx_traits > > | |
| Cstd::shared_ptr< std::mutex > | |
| Cstd::shared_timed_mutex | The standard shared timed mutex type |
| Cstd::shuffle_order_engine< _RandomNumberEngine, __k > | Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits __k |
| Cstd::slice | Class defining one-dimensional subset of an array |
| Cstd::slice_array< _Tp > | Reference to one-dimensional subset of an array |
| C__gnu_cxx::slist< _Tp, _Alloc > | |
| C__gnu_pbds::detail::splay_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc > | Splay tree |
| C__gnu_pbds::detail::splay_tree_node_< Value_Type, Metadata, _Alloc > | Node for splay tree |
| Cstd::stack< _Tp, _Sequence > | A standard container giving FILO behavior |
| Cstd::stack< _StateSeqT > | |
| Cstd::chrono::_V2::steady_clock | Monotonic clock |
| ▼C__gnu_pbds::detail::stored_hash< _Th > | Stored hash |
| C__gnu_pbds::detail::stored_data< _Tv, _Th, Store_Hash > | Primary template for representation of stored data. Two types of data can be stored: value and hash |
| ▼C__gnu_pbds::detail::stored_value< _Tv > | Stored value |
| C__gnu_pbds::detail::stored_data< _Tv, _Th, Store_Hash > | Primary template for representation of stored data. Two types of data can be stored: value and hash |
| C__gnu_pbds::detail::stored_data< _Tv, _Th, false > | Specialization for representation of stored data of just value type |
| Cstd::student_t_distribution< _RealType > | A student_t_distribution random number distribution |
| Cstd::subtract_with_carry_engine< _UIntType, __w, __s, __r > | The Marsaglia-Zaman generator |
| C__gnu_pbds::detail::synth_access_traits< Type_Traits, Set, _ATraits > | Synthetic element access traits |
| Cstd::chrono::_V2::system_clock | System clock |
| Cstd::thread | Thread |
| C__gnu_cxx::throw_value_base< _Cond > | Class with exception generation control. Intended to be used as a value_type in templatized code |
| ▼Cstd::time_base | Time format ordering data.This class provides an enum representing different orderings of time: day, month, and year |
| Cstd::time_get< _CharT, _InIter > | Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators |
| Cstd::chrono::time_point< _Clock, _Dur > | Time_point |
| Cstd::timed_mutex | Timed_mutex |
| Cstd::to_chars_result | Result type of std::to_chars |
| C__gnu_pbds::detail::tree_metadata_helper< Node_Update, _BTp > | Tree metadata helper |
| C__gnu_pbds::detail::tree_metadata_helper< Node_Update, false > | Specialization, false |
| C__gnu_pbds::detail::tree_metadata_helper< Node_Update, true > | Specialization, true |
| C__gnu_pbds::detail::tree_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc > | Tree node metadata dispatch |
| C__gnu_pbds::detail::tree_traits< Key, Data, Cmp_Fn, Node_Update, Tag, _Alloc > | Tree traits class, primary template |
| C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Tree traits |
| C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Specialization |
| C__gnu_pbds::detail::trie_metadata_helper< Node_Update, _BTp > | Trie metadata helper |
| C__gnu_pbds::detail::trie_metadata_helper< Node_Update, false > | Specialization, false |
| C__gnu_pbds::detail::trie_metadata_helper< Node_Update, true > | Specialization, true |
| C__gnu_pbds::detail::trie_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc > | Trie node metadata dispatch |
| C__gnu_pbds::trie_string_access_traits< String, Min_E_Val, Max_E_Val, Reverse, _Alloc > | |
| C__gnu_pbds::detail::trie_traits< Key, Data, _ATraits, Node_Update, Tag, _Alloc > | Trie traits class, primary template |
| C__gnu_pbds::detail::trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization |
| C__gnu_pbds::detail::trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization |
| C__gnu_pbds::trivial_iterator_tag | A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities |
| Cstd::try_to_lock_t | Try to acquire ownership of the mutex without blocking |
| Cstd::tuple_element< _Int, _Tp > | Tuple_element |
| Cstd::tuple_element< 0, std::pair< _Tp1, _Tp2 > > | Partial specialization for std::pair |
| Cstd::tuple_element< 0, tuple< _Head, _Tail... > > | |
| Cstd::tuple_element< 1, std::pair< _Tp1, _Tp2 > > | Partial specialization for std::pair |
| ▼Cstd::tuple_element< __i - 1, tuple< _Tail... > > | |
| Cstd::tuple_element< __i, tuple< _Head, _Tail... > > | |
| Cstd::tuple_element< __i, tuple<> > | |
| Cstd::tuple_element< _Int, ::array< _Tp, _Nm > > | Partial specialization for std::array |
| Cstd::tuple_element< _Int, std::__debug::array< _Tp, _Nm > > | Tuple_element |
| Cstd::tuple_size< _Tp > | Tuple_size |
| C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >::type | Compare plus entry |
| Cstd::type_index | Class type_indexThe class type_index provides a simple wrapper for type_info which can be used as an index type in associative containers (23.6) and in unordered associative containers (23.7) |
| Cstd::type_info | Part of RTTI |
| ▼Cstd::unary_function< _Arg, _Result > | |
| Cstd::pointer_to_unary_function< _Arg, _Result > | One of the adaptors for function pointers |
| ▼Cstd::unary_function< __gnu_cxx::throw_value_limit, size_t > | |
| Cstd::hash< __gnu_cxx::throw_value_limit > | Explicit specialization of std::hash for __gnu_cxx::throw_value_limit |
| ▼Cstd::unary_function< __gnu_cxx::throw_value_random, size_t > | |
| Cstd::hash< __gnu_cxx::throw_value_random > | Explicit specialization of std::hash for __gnu_cxx::throw_value_random |
| ▼Cstd::unary_function< _FirstArgumentType, _ResultType > | |
| C__gnu_parallel::__binder2nd< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType > | Similar to std::binder2nd, but giving the argument types explicitly |
| Cstd::unary_function< _Functor::argument_type, _Functor::result_type > | |
| ▼Cstd::unary_function< _Operation2::argument_type, _Operation1::result_type > | |
| C__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 > | An SGI extension |
| C__gnu_cxx::unary_compose< _Operation1, _Operation2 > | An SGI extension |
| ▼Cstd::unary_function< _Operation::first_argument_type, _Operation::result_type > | |
| Cstd::binder2nd< _Operation > | One of the binder functors |
| ▼Cstd::unary_function< _Operation::second_argument_type, _Operation::result_type > | |
| Cstd::binder1st< _Operation > | One of the binder functors |
| Cstd::unary_function< _Pair, _Pair::first_type > | |
| Cstd::unary_function< _Pair, _Pair::second_type > | |
| ▼Cstd::unary_function< _Predicate::argument_type, bool > | |
| Cstd::unary_negate< _Predicate > | One of the negation functors |
| ▼Cstd::unary_function< _SecondArgumentType, _ResultType > | |
| C__gnu_parallel::__binder1st< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType > | Similar to std::binder1st, but giving the argument types explicitly |
| ▼Cstd::unary_function< _Tp *, _Ret > | |
| Cstd::mem_fun_t< _Ret, _Tp > | One of the adaptors for member pointers |
| ▼Cstd::unary_function< _Tp, _Ret > | |
| Cstd::const_mem_fun_ref_t< _Ret, _Tp > | One of the adaptors for member pointers |
| Cstd::mem_fun_ref_t< _Ret, _Tp > | One of the adaptors for member pointers |
| ▼Cstd::unary_function< _Tp, _Tp > | |
| Cstd::negate< _Tp > | One of the math functors |
| ▼Cstd::unary_function< _Tp, bool > | |
| Cstd::logical_not< _Tp > | One of the Boolean operations functors |
| Cstd::unary_function< _Value, _Value > | |
| ▼Cstd::unary_function< argument_type, bool > | |
| C__gnu_parallel::__unary_negate< _Predicate, argument_type > | Similar to std::unary_negate, but giving the argument types explicitly |
| ▼Cstd::unary_function< const _Tp *, _Ret > | |
| Cstd::const_mem_fun_t< _Ret, _Tp > | One of the adaptors for member pointers |
| Cstd::unary_function< pair< const _Key, _Tp >, pair< const _Key, _Tp > ::first_type > | |
| ▼Cstd::unary_function< std::pair< _Tp, _Tp >, bool > | |
| C__gnu_cxx::__detail::_Ffit_finder< _Tp > | The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator |
| ▼Cstd::unary_function< unsigned int, unsigned int > | |
| C__gnu_cxx::subtractive_rng | |
| Cstd::underlying_type< _Tp > | The underlying type of an enum |
| Cstd::uniform_int_distribution< _IntType > | Uniform discrete distribution for random numbers. A discrete random distribution on the range ![$[min, max]$](form_117.png) with equal probability throughout the range |
| Cstd::uniform_real_distribution< _RealType > | Uniform continuous distribution for random numbers |
| Cstd::unique_lock< _Mutex > | A movable scoped lock type |
| Cstd::unique_ptr< _Tp, _Dp > | 20.7.1.2 unique_ptr for single objects |
| Cstd::unique_ptr< _Codecvt > | |
| Cstd::unique_ptr< _Res_type > | |
| Cstd::unique_ptr< _Result< _Res > > | |
| Cstd::unique_ptr< _Result_base > | |
| Cstd::unique_ptr< _Tp[], _Dp > | 20.7.1.3 unique_ptr for array objects with a runtime length |
| Cstd::unique_ptr< bool[]> | |
| Cstd::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > | A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys |
| Cstd::unordered_map< _Key, _Tp, _Hash, _Pred > | |
| Cstd::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > | A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys |
| Cstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc > | A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves |
| Cstd::unordered_set< _Value, _Hash, _Pred, _Alloc > | A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves |
| Cstd::uses_allocator< _Tp, _Alloc > | Declare uses_allocator so it can be specialized in <queue> etc |
| Cstd::valarray< _Tp > | Smart array designed to support numeric processing |
| Cstd::valarray< size_t > | |
| Cstd::value > 0)> | |
| Cstd::vector< bool, _Alloc > | A specialization of vector for booleans which offers fixed time access to individual elements in any order |
| Cstd::weak_ptr< _Tp > | A non-owning observer for a pointer owned by a shared_ptr |
| Cstd::weak_ptr< _State_baseV2 > | |
| Cstd::weibull_distribution< _RealType > | A weibull_distribution random number distribution |
| Cstd::wstring_convert< _Codecvt, _Elem, _Wide_alloc, _Byte_alloc > | String conversions |
1.8.14