Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

C__cxxabiv1::__forced_unwind	Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
C__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >	Policy for shared __pool objects
C__gnu_cxx::__detail::__mini_vector< _Tp >	__mini_vector<> is a stripped down version of the full-fledged std::vector<>
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::__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: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.html
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 >
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_cxx::_Caster< _ToType >
C__gnu_cxx::_Char_types< _CharT >	Mapping from character type to associated types
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
C__gnu_cxx::_Invalid_type
C__gnu_cxx::_Pointer_adapter< _Storage_policy >
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_cxx::_Std_pointer_impl< _Tp >	A storage policy for use with _Pointer_adapter<> which yields a standard pointer
C__gnu_cxx::_Unqualified_type< _Tp >
▼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
▼C__gnu_cxx::array_allocator_base< _Tp >	Base class
C__gnu_cxx::array_allocator< _Tp, _Array >	An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
▼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
C__gnu_cxx::character< _Value, _Int, _St >	A POD class that serves as a character abstraction class
▼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
C__gnu_cxx::debug_allocator< _Alloc >	A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard
C__gnu_cxx::enc_filebuf< _CharT >	Class enc_filebuf
C__gnu_cxx::encoding_state	Extension to use iconv for dealing with character encodings
C__gnu_cxx::forced_error	Thown by exception safety machinery
▼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
C__gnu_cxx::limit_condition::always_adjustor	Always enter the condition
C__gnu_cxx::limit_condition::limit_adjustor	Enter the nth condition
C__gnu_cxx::limit_condition::never_adjustor	Never enter the condition
C__gnu_cxx::malloc_allocator< _Tp >	An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
▼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_cxx::random_condition::always_adjustor	Always enter the condition
C__gnu_cxx::random_condition::group_adjustor	Group condition
C__gnu_cxx::random_condition::never_adjustor	Never enter the condition
C__gnu_cxx::recursive_init_error	Exception thrown by __cxa_guard_acquire.6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) while the object is being initialized, the behavior is undefined
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>
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>
C__gnu_cxx::throw_value_base< _Cond >	Class with exception generation control. Intended to be used as a value_type in templatized code
C__gnu_debug::_After_nth_from< _Iterator >
C__gnu_debug::_BeforeBeginHelper< _Sequence >
C__gnu_debug::_Equal_to< _Type >
C__gnu_debug::_Not_equal_to< _Type >
▼C__gnu_debug::_Safe_iterator_base	Basic functionality for a safe iterator
C__gnu_debug::_Safe_iterator< _Iterator, _Sequence >	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_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_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_sequence< map< _Key, _Tp, _Compare, _Allocator > >
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 > >
Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator >	Class std::multimap with safety/checking/debug instrumentation
▼C__gnu_debug::_Safe_sequence< multiset< _Key, _Compare, _Allocator > >
Cstd::__debug::multiset< _Key, _Compare, _Allocator >	Class std::multiset with safety/checking/debug instrumentation
▼C__gnu_debug::_Safe_sequence< set< _Key, _Compare, _Allocator > >
Cstd::__debug::set< _Key, _Compare, _Allocator >	Class std::set with safety/checking/debug instrumentation
C__gnu_parallel::__accumulate_binop_reduct< _BinOp >	General reduction, using a binary operator
▼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
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_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
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
C__gnu_parallel::_GuardedIterator< _RAIter, _Compare >	_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
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
▼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::_LoserTreeBase< _Tp, _Compare >::_Loser	Internal representation of a _LoserTree element
▼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::_LoserTreePointerBase< _Tp, _Compare >::_Loser	Internal representation of _LoserTree __elements
▼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
C__gnu_parallel::_Nothing	Functor doing nothing
C__gnu_parallel::_Piece< _DifferenceTp >	Subsequence description
C__gnu_parallel::_PMWMSSortingData< _RAIter >	Data accessed by all threads
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
C__gnu_parallel::_RandomNumber	Random number generator, based on the Mersenne twister
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::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >	Stable sorting functor
C__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >	Non-__stable sorting functor
C__gnu_parallel::_Settings	Class _Settings Run-time settings for the parallel mode including all tunable parameters
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
▼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()
▼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
C__gnu_parallel::sequential_tag	Forces sequential execution at compile time
C__gnu_pbds::basic_branch< Key, Mapped, Tag, Node_Update, Policy_Tl, _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_invalidation_guarantee
▼C__gnu_pbds::point_invalidation_guarantee
C__gnu_pbds::range_invalidation_guarantee
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_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
▼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< 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
▼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, null_type, Cmp_Fn, Node_Update, Node, _Alloc >	Specialization
▼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
▼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
C__gnu_pbds::detail::cond_dealtor< Entry, _Alloc >	Conditional deallocate constructor argument
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::detail::default_comb_hash_fn	Primary template, default_comb_hash_fn
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
C__gnu_pbds::detail::dumnode_const_iterator< Key, Data, _Alloc >	Constant node iterator
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, false >::type	Compare plus entry
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
▼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::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, true >	Specializations
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_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
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::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::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)
C__gnu_pbds::detail::no_throw_copies< Key, Mapped >	Primary template
C__gnu_pbds::detail::no_throw_copies< Key, null_type >	Specialization
C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >::cond_dtor< Size_Type >	Conditional destructor
▼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
▼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
▼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
▼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_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
▼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
C__gnu_pbds::detail::probe_fn_base< _Alloc >	Probe functor base
▼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 >
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::resize_policy< _Tp >	Resize policy for binary heap
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
▼C__gnu_pbds::detail::stored_hash< _Th >	Stored hash
C__gnu_pbds::detail::stored_data< _Tv, _Th >	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 >	Primary template for representation of stored data. Two types of data can be stored: value and hash
C__gnu_pbds::detail::stored_data< _Tv, null_type >	Specialization for representation of stored data of just value type
C__gnu_pbds::detail::synth_access_traits< Type_Traits, Set, _ATraits >	Synthetic element access traits
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::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::detail::type_base< Key, Mapped, _Alloc, Store_Hash >	Primary template
▼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::type_base< Key, Mapped, _Alloc, false >
C__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, true >
C__gnu_pbds::detail::type_base< Key, null_type, _Alloc, false >
C__gnu_pbds::detail::type_base< Key, null_type, _Alloc, true >
C__gnu_pbds::detail::type_dispatch< Key, Mapped, _Alloc, Store_Hash >	Type base dispatch
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::hash_prime_size_policy	A size policy whose sequence of sizes form a nearly-exponential sequence of primes
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
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 >
C__gnu_pbds::lu_move_to_front_policy< _Alloc >
▼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
C__gnu_pbds::priority_queue< _Tv, Cmp_Fn, Tag, _Alloc >
C__gnu_pbds::quadratic_probe_fn< Size_Type >	A probe sequence policy using square increments
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
C__gnu_pbds::trie_string_access_traits< String, Min_E_Val, Max_E_Val, Reverse, _Alloc >
C__gnu_pbds::trivial_iterator_tag	A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
▼C__gnu_profile::__object_info_base	Base class for a line in the object table
▼C__gnu_profile::__container_size_info	A container size instrumentation line in the object table
C__gnu_profile::__container_size_stack_info	A container size instrumentation line in the stack table
▼C__gnu_profile::__hashfunc_info	A hash performance instrumentation line in the object table
C__gnu_profile::__hashfunc_stack_info	A hash performance instrumentation line in the stack table
C__gnu_profile::__list2vector_info	A list-to-vector instrumentation line in the object table
▼C__gnu_profile::__map2umap_info	A map-to-unordered_map instrumentation line in the object table
C__gnu_profile::__map2umap_stack_info	A map-to-unordered_map instrumentation line in the stack table
▼C__gnu_profile::__vector2list_info	A vector-to-list instrumentation line in the object table
C__gnu_profile::__vector2list_stack_info	A vector-to-list instrumentation line in the stack table
C__gnu_profile::__reentrance_guard	Reentrance guard
C__gnu_profile::__stack_hash	Hash function for summary trace using call stack as index
C__gnu_profile::__stack_info_base< __object_info >	Base class for a line in the stack table
C__gnu_profile::__trace_base< __object_info, __stack_info >	Base class for all trace producers
C__gnu_profile::__warning_data	Representation of a warning
▼C__gnu_profile::__trace_base< __container_size_info, __container_size_stack_info >
▼C__gnu_profile::__trace_container_size	Container size instrumentation trace producer
C__gnu_profile::__trace_hashtable_size	Hashtable size instrumentation trace producer
C__gnu_profile::__trace_vector_size	Hashtable size instrumentation trace producer
▼C__gnu_profile::__trace_base< __hashfunc_info, __hashfunc_stack_info >
C__gnu_profile::__trace_hash_func	Hash performance instrumentation producer
C__gnu_profile::__trace_base< __list2slist_info, __list2slist_stack_info >
C__gnu_profile::__trace_base< __list2vector_info, __list2vector_stack_info >
▼C__gnu_profile::__trace_base< __map2umap_info, __map2umap_stack_info >
C__gnu_profile::__trace_map2umap	Map-to-unordered_map instrumentation producer
▼C__gnu_profile::__trace_base< __vector2list_info, __vector2list_stack_info >
C__gnu_profile::__trace_vector_to_list	Vector-to-list instrumentation producer
C__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >
Cstd::_Deque_iterator< _Tp, _Tp &, _Tp * >
▼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< _Destructor, _Tag >
Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag >	A mixin helper to conditionally enable or disable the special members
▼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::_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::_Hashtable_ebo_helper< 0, __alloctr_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > >::__type >
▼Cstd::__detail::_Hashtable_alloc< __alloctr_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > >::__type >
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::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
▼Cstd::_List_base< __inp, __rebind_inp >
Cstd::list< __inp, __rebind_inp >
▼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
▼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::_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_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
▼Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, _Alloc >
Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > >
▼Cstd::_Vector_base< _CharClassT, _Alloc >
Cstd::vector< _CharClassT >
▼Cstd::_Vector_base< _CharT, _Alloc >
Cstd::vector< _CharT >
▼Cstd::_Vector_base< _Node *, _Nodeptr_Alloc >
Cstd::vector< _Node *, _Nodeptr_Alloc >
▼Cstd::_Vector_base< _State< _TraitsT >, _Alloc >
Cstd::vector< _State< _TraitsT > >
▼Cstd::_Vector_base< _StringT, _Alloc >
Cstd::vector< _StringT >
▼Cstd::_Vector_base< int, _Alloc >
Cstd::vector< int >
▼Cstd::_Vector_base< result_type, _Alloc >
Cstd::vector< result_type >
▼Cstd::_Vector_base< size_t, _Alloc >
Cstd::vector< size_t >
▼Cstd::_Vector_base< std::pair< _StrTransT, _StrTransT >, _Alloc >
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 >
Cstd::match_results< _Bi_iter, _Alloc >	The results of a match or search operation
▼Cstd::_Vector_base< sub_match< _BiIter >, _Alloc >
Cstd::vector< sub_match< _BiIter >, _Alloc >
▼Cstd::allocator_traits< _Tp_alloc_type >
C__gnu_cxx::__alloc_traits< _Tp_alloc_type >
▼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, 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 >
Cstd::basic_string< _CharT >
Cstd::basic_string< char >
▼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, 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< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool >
Cstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool >
▼Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool >
Cstd::binary_negate< _Predicate >	One of the negation functors
Cstd::binary_function< _Sp, _Sp, bool >
▼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, _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< 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< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >
▼C__gnu_pbds::container_traits_base< Cntnr::container_category >
C__gnu_pbds::container_traits< Cntnr >	Container traits
▼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
▼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::random_access_iterator_tag, bool >
▼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::lu_counter_policy_base< _Alloc::size_type >
C__gnu_pbds::lu_counter_policy< Max_Count, _Alloc >
Cstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
▼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 >
▼Cpoint_const_iterator_	Const point-type iterator
▼Cconst_iterator_	Const range-type iterator
Citerator_	Range-type iterator
Cpoint_iterator_	Find type iterator
C__gnu_pbds::detail::rc< typename binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >::node, _Alloc >
▼C__gnu_pbds::detail::resize_policy< _Alloc::size_type >
C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >
Cstd::stack< _StateSeqT >
Cstd::__atomic_base< _ITp >	Base class for atomic integrals
Cstd::__atomic_base< _PTp * >	Partial specialization for pointer types
▼Cstd::__atomic_flag_base	Base type for atomic_flag
Cstd::atomic_flag	Atomic_flag
Cstd::__detail::_BracketMatcher< _TraitsT, __icase, __collate >	Matches a character range (bracket expression)
Cstd::__detail::_Compiler< _TraitsT >	Builds an NFA from an input iterator interval
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::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, __cache_hash_code >
Cstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, false >	Specialization
Cstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, true >	Specialization
▼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, true >	Specialization
▼Cstd::__detail::_Equality_base
Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >	Specialization
Cstd::__detail::_Executor< _BiIter, _Alloc, _TraitsT, __dfs_mode >	Takes a regex and an input string in and do the matching
Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code >
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< _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, _Unique_keys >
Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
▼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, _Unique_keys >	Specialization
Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, false >	Specialization
Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, true >	Specialization
▼Cstd::__detail::_List_node_base	Common part of a node in the list
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::_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::_Mod_range_hashing	Default range hashing function: use division to fold a large number into the range [0, N)
Cstd::__detail::_Node_iterator_base< _Value, _Cache_hash_code >	Base class for node iterators
Cstd::__detail::_Prime_rehash_policy	Default value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load factor small enough
▼Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _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::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _Prime_rehash_policy, _Traits >	Specialization
Cstd::__detail::_Scanner< _CharT >	Scans an input range for regex tokens
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
Cstd::__exception_ptr::exception_ptr	An opaque pointer to an arbitrary exception
Cstd::__has_iterator_category_helper< _Tp >	Traits class for iterators
Cstd::__parallel::_CRandNumber< _MustBeInt >	Functor wrapper for std::rand()
Cstd::__profile::map< _Key, _Tp, _Compare, _Allocator >	Class std::map wrapper with performance instrumentation
Cstd::__profile::multimap< _Key, _Tp, _Compare, _Allocator >	Class std::multimap wrapper with performance instrumentation
Cstd::__profile::multiset< _Key, _Compare, _Allocator >	Class std::multiset wrapper with performance instrumentation
Cstd::__profile::set< _Key, _Compare, _Allocator >	Class std::set wrapper with performance instrumentation
▼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_iterator< _Tp, _Ref, _Ptr >	A deque::iterator
▼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_default_constructor< _Switch, _Tag >	A mixin helper to conditionally enable or disable the default constructor
Cstd::_Enable_destructor< _Switch, _Tag >	A mixin helper to conditionally enable or disable the default destructor
▼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
▼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_const_iterator< _Tp >	A list::const_iterator
Cstd::_List_iterator< _Tp >	A list::iterator
Cstd::_Sp_ebo_helper< _Nm, _Tp, false >	Specialization not using EBO
Cstd::_Sp_ebo_helper< _Nm, _Tp, true >	Specialization using EBO
Cstd::_Temporary_buffer< _ForwardIterator, _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::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 >	Uniform interface to C++98 and C++0x allocators
Cstd::auto_ptr< _Tp >	A simple smart pointer providing strict ownership semantics
Cstd::auto_ptr_ref< _Tp1 >
Cstd::bad_weak_ptr	Exception possibly thrown by shared_ptr
Cstd::basic_regex< _Ch_type, _Rx_traits >
Cstd::basic_string< _CharT, _Traits, _Alloc >	Managing sequences of characters and character-like objects
Cstd::bernoulli_distribution	A Bernoulli random number distribution
Cstd::bernoulli_distribution::param_type
▼Cstd::binary_function< _Arg1, _Arg2, _Result >
Cstd::pointer_to_binary_function< _Arg1, _Arg2, _Result >	One of the adaptors for function pointers
Cstd::binomial_distribution< _IntType >	A discrete binomial random number distribution
Cstd::cauchy_distribution< _RealType >	A cauchy_distribution random number distribution
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
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< 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< _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::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< char_type >
▼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
Cstd::default_delete< _Tp >	Primary template of default_delete, used by unique_ptr
Cstd::default_delete< _Tp[]>	Specialization for arrays, default_delete
Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >
Cstd::discrete_distribution< _IntType >	A discrete_distribution random number distribution
Cstd::enable_shared_from_this< _Tp >	Base class allowing use of member function shared_from_this
Cstd::exponential_distribution< _RealType >	An exponential continuous distribution for random numbers
Cstd::extreme_value_distribution< _RealType >	A extreme_value_distribution random number distribution
Cstd::fisher_f_distribution< _RealType >	A fisher_f_distribution random number distribution
Cstd::fpos< _StateT >	Class representing stream positions
Cstd::gamma_distribution< _RealType >	A gamma continuous distribution for random numbers
Cstd::geometric_distribution< _IntType >	A discrete geometric random number distribution
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< __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< 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< 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<::vector< bool, _Alloc > >	Std::hash specialization for vector<bool>
Cstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >
Cstd::indirect_array< _Tp >	Reference to arbitrary subset of an array
▼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::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< _CharT, _Traits >	Template class basic_ios, virtual base class for all stream classes
Cstd::ios_base::failure	These are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
Cstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >	Common iterator class
Cstd::iterator_traits< _Tp * >	Partial specialization for pointer types
Cstd::iterator_traits< const _Tp * >	Partial specialization for const pointer types
Cstd::linear_congruential_engine< _UIntType, __a, __c, __m >	A model of a linear congruential random number generator
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::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< 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]
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::lognormal_distribution< _RealType >	A lognormal_distribution random number distribution
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
Cstd::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f >
▼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::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::multiset< _Key, _Compare, _Alloc >	A standard container made up of elements, which can be retrieved in logarithmic time
Cstd::negative_binomial_distribution< _IntType >	A negative_binomial_distribution random number distribution
Cstd::nested_exception	Exception class with exception_ptr data member
Cstd::normal_distribution< _RealType >	A normal continuous distribution for random numbers
Cstd::output_iterator_tag	Marking output iterators
Cstd::owner_less< _Tp >	Primary template owner_less
Cstd::owner_less< shared_ptr< _Tp > >	Partial specialization of owner_less for shared_ptr
Cstd::owner_less< weak_ptr< _Tp > >	Partial specialization of owner_less for weak_ptr
Cstd::pair< _T1, _T2 >	Struct holding two objects of arbitrary type
Cstd::piecewise_constant_distribution< _RealType >	A piecewise_constant_distribution random number distribution
Cstd::piecewise_construct_t	Piecewise_construct_t
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
Cstd::priority_queue< _Tp, _Sequence, _Compare >	A standard container automatically sorting its contents
Cstd::queue< _Tp, _Sequence >	A standard container giving FIFO behavior
Cstd::random_device
Cstd::regex_error	A regular expression exception class.The regular expression library throws objects of this class on error
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::seed_seq	Generates sequences of seeds for random number generators
Cstd::set< _Key, _Compare, _Alloc >	A standard container made up of unique keys, which can be retrieved in logarithmic time
Cstd::shared_ptr< _Tp >	A smart pointer with reference-counted copy semantics
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 __w
Cstd::slice	Class defining one-dimensional subset of an array
Cstd::slice_array< _Tp >	Reference to one-dimensional subset of an array
Cstd::stack< _Tp, _Sequence >	A standard container giving FILO behavior
Cstd::student_t_distribution< _RealType >	A student_t_distribution random number distribution
▼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::unary_function< _Arg, _Result >
Cstd::pointer_to_unary_function< _Arg, _Result >	One of the adaptors for function pointers
Cstd::uniform_int_distribution< _IntType >	Uniform discrete distribution for random numbers. A discrete random distribution on the range with equal probability throughout the range
Cstd::uniform_real_distribution< _RealType >	Uniform continuous distribution for random numbers
Cstd::unique_ptr< _Tp, _Dp >	20.7.1.2 unique_ptr for single objects
Cstd::unique_ptr< _Tp[], _Dp >	20.7.1.3 unique_ptr for array objects with a runtime length
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_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::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 smart pointer with weak semantics
Cstd::weibull_distribution< _RealType >	A weibull_distribution random number distribution
▼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< _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< 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< 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::unique_ptr< std::vector< bool > >
Cstd::unique_ptr< std::vector< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > > > >