Class Hierarchy

Go to the graphical class hierarchy

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

[detail level 12345]

Cstd::__add_pointer_helper< _Tp >
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
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: https://gcc.gnu.org/onlinedocs/libstdc++/manual/mt_allocator.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::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_cxx::debug_allocator< _Alloc >	A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard
C__gnu_cxx::encoding_state	Extension to use iconv for dealing with character encodings
▼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::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_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc >
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::project1st< _Arg1, _Arg2 >	An SGI extension
C__gnu_cxx::project2nd< _Arg1, _Arg2 >	An SGI extension
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::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc >
C__gnu_cxx::rope< _CharT, _Alloc >
C__gnu_cxx::select1st< _Pair >	An SGI extension
C__gnu_cxx::select2nd< _Pair >	An SGI extension
C__gnu_cxx::slist< _Tp, _Alloc >
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_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 >	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_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::_Sequence_traits< _Sequence >
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_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::__trace_base< __object_info, __stack_info >	Base class for all trace producers
C__gnu_profile::__warning_data	Representation of a warning
Cstd::__is_trivially_copy_assignable_impl< _Tp >
Cstd::__is_trivially_copy_constructible_impl< _Tp >
Cstd::__is_trivially_move_assignable_impl< _Tp >
Cstd::__is_trivially_move_constructible_impl< _Tp >
Cstd::__iterator_traits< _Iterator >
Cstd::__iterator_traits< _Tp >
▼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
▼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_cxx::__detail::_Bitmap_counter< _Alloc_block * >
▼Cstd::_Deque_base< _StateSeqT, std::allocator< _StateSeqT > >
Cstd::deque< _StateSeqT >
Cstd::_Deque_iterator< _Tp, _Tp &, _Ptr >
▼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< _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, __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::_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::_Maybe_get_result_type< _Functor >
Cstd::_Weak_result_type_impl< _Functor >
▼Cstd::_Maybe_get_result_type< remove_cv< _Functor >::type >
Cstd::_Weak_result_type_impl< remove_cv< _Functor >::type >
▼Cstd::_Maybe_get_result_type< remove_cv< _Tp >::type >
Cstd::_Weak_result_type_impl< remove_cv< _Tp >::type >
▼Cstd::_Maybe_get_result_type< remove_cv< remove_cv< _Tp >::type >::type >
Cstd::_Weak_result_type_impl< remove_cv< remove_cv< _Tp >::type >::type >
▼Cstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes... >
Cstd::function< _Res(_ArgTypes...)>	Primary class template for std::function.Polymorphic function wrapper
▼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
▼Cstd::experimental::fundamentals_v1::_Optional_base< _Tp >
Cstd::experimental::fundamentals_v1::optional< _Tp >	Class template for optional values
▼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 >
C__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
▼C__gnu_debug::_Safe_vector< vector< _Tp, _Allocator >, ::vector< _Tp, _Allocator > >
Cstd::__debug::vector< _Tp, _Allocator >	Class std::vector with safety/checking/debug instrumentation
▼Cstd::_Tuple_impl< 0, _Elements... >
Cstd::tuple< _Elements >	Primary class template, tuple
Cstd::tuple< _Bound_args... >
Cstd::tuple< _ForwardIterator1, _ForwardIterator1, _BinaryPredicate >
Cstd::tuple< pointer, _Dp >
Cstd::tuple< pointer, default_delete< _Codecvt > >
Cstd::tuple< pointer, default_delete< _Res_type > >
Cstd::tuple< pointer, default_delete< _Result< _Res > > >
Cstd::tuple< pointer, default_delete< _Result_base > >
Cstd::tuple< pointer, default_delete< bool > >
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... >
▼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::_Weak_result_type< _Tp >
Cstd::_Reference_wrapper_base< _Tp >
▼Cstd::_Weak_result_type< remove_cv< _Tp >::type >
Cstd::_Reference_wrapper_base< remove_cv< _Tp >::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::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_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 >
▼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 >
▼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< _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< _Sp, _Sp, bool >
▼Cstd::binary_function< _T1, _T2, _Res >
Cstd::_Maybe_unary_or_binary_function< _Res, _T1, _T2 >	Derives from binary_function, as appropriate
▼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 >
Cstd::common_type< _Tp, _Tp >
Cstd::common_type< _Types... >
Cstd::conditional< _UseCache::value, std::bitset< _S_cache_size()>, _Dummy >
▼C__gnu_pbds::container_traits_base< Cntnr::container_category >
C__gnu_pbds::container_traits< Cntnr >	Container traits
Cstd::gamma_distribution< double >
Cstd::gamma_distribution< result_type >
▼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::integral_constant< _Rep, static_cast< _Rep >(_Val)>
Cstd::integral_constant< bool, !is_function< _Tp >::value >
▼Cstd::integral_constant< bool, !is_fundamental< _Tp >::value >
Cstd::is_compound< _Tp >	Is_compound
▼Cstd::integral_constant< bool, !ratio_equal< _R1, _R2 >::value >
Cstd::ratio_not_equal< _R1, _R2 >	Ratio_not_equal
Cstd::integral_constant< bool, __big_less< _Left::__hi, _Left::__lo, _Right::__hi, _Right::__lo >::value >
▼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_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
▼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, is_function< _Tp >::value >
Cstd::integral_constant< bool, noexcept(_Tp())>
Cstd::integral_constant< bool, noexcept(_Tp(declval< _Args >()...))>
Cstd::integral_constant< bool, noexcept(declval< _Tp >()=declval< _Up >())>
Cstd::integral_constant< bool, noexcept(static_cast< _Tp >(declval< _Arg >()))>
Cstd::integral_constant< bool,(__hi1< __hi2||(__hi1==__hi2 &&__lo1< __lo2))>
Cstd::value > 0)>
▼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< intmax_t, __static_abs< _Pn >::value >
Cstd::integral_constant< intmax_t, __static_abs< _Qn >::value >
Cstd::integral_constant< intmax_t, _Pn *__static_sign< _Pn >::value >
Cstd::integral_constant< intmax_t,(_Pn< 0) ? -1 :1 >
▼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::is_floating_point< _Rep >
Cstd::chrono::treat_as_floating_point< _Rep >	Treat_as_floating_point
Cstd::is_nothrow_assignable< _Tp &, _Tp && >
Cstd::is_nothrow_assignable< _Tp &, const _Tp & >
Cstd::is_nothrow_constructible< _Tp, _Tp && >
Cstd::is_nothrow_constructible< _Tp, const _Tp & >
▼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 >
▼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::make_unsigned< _DiffT >
Cstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
Cstd::normal_distribution< double >
Cstd::normal_distribution< result_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 >
▼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 >
Cstd::regex_traits< _CharType >
▼C__gnu_pbds::detail::resize_policy< _Alloc::size_type >
C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >
Cstd::scoped_allocator_adaptor< _InnerHead, _InnerTail... >
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::stack< _StateSeqT >
Cstd::__add_pointer_helper< _Tp, bool >	Add_pointer
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_flag_base	Base type for atomic_flag
Cstd::atomic_flag	Atomic_flag
Cstd::__debug::bitset< _Nb >	Class std::bitset with additional safety/checking/debug instrumentation
Cstd::__detail::_BracketMatcher< _TraitsT, __icase, __collate >	Matches a character range (bracket expression)
Cstd::__detail::_Compiler< _TraitsT >	Builds an NFA from an input iterator range
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 and does 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 >
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 >	Specialization
Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >	Specialization
▼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::_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::_Mask_range_hashing	Range hashing function assuming that second arg is a power of 2
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::_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
Cstd::__detail::_Quoted_string< _String, _CharT >	Struct for delimited strings
▼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, std::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, std::true_type >	Specialization when rehash policy provide load factor management
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::__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::__exception_ptr::exception_ptr	An opaque pointer to an arbitrary exception
▼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
▼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
Cstd::__is_location_invariant< _Tp >
Cstd::__is_trivially_copy_assignable_impl< _Tp, bool >	Is_trivially_copy_assignable
Cstd::__is_trivially_copy_constructible_impl< _Tp, bool >	Is_trivially_copy_constructible
Cstd::__is_trivially_move_assignable_impl< _Tp, bool >	Is_trivially_move_assignable
Cstd::__is_trivially_move_constructible_impl< _Tp, bool >	Is_trivially_move_constructible
Cstd::__iterator_traits< _Iterator, typename >	Traits class for iterators
▼Cstd::__numeric_limits_base	Part of std::numeric_limits
Cstd::numeric_limits< _Tp >	Properties of fundamental types
Cstd::__parallel::_CRandNumber< _MustBeInt >	Functor wrapper for std::rand()
Cstd::__profile::bitset< _Nb >	Class std::bitset wrapper with performance instrumentation, none at the moment
Cstd::__profile::deque< _Tp, _Allocator >	Class std::deque wrapper with performance instrumentation
Cstd::__profile::forward_list< _Tp, _Alloc >	Class std::forward_list wrapper with performance instrumentation
Cstd::__profile::list< _Tp, _Allocator >	List wrapper with performance instrumentation
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::__profile::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >	Class std::unordered_map wrapper with performance instrumentation
Cstd::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >	Class std::unordered_multimap wrapper with performance instrumentation
Cstd::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >	Unordered_multiset wrapper with performance instrumentation
Cstd::__profile::unordered_set< _Key, _Hash, _Pred, _Alloc >	Unordered_set wrapper with performance instrumentation
▼Cstd::__shared_mutex_cv	A shared mutex type implemented using std::condition_variable
Cstd::shared_timed_mutex	The standard shared timed mutex type
Cstd::_Base_bitset< _Nw >
Cstd::_Base_bitset< 0 >
Cstd::_Base_bitset< 1 >
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>()
▼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::_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
▼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::_Maybe_get_result_type< _Functor, typename >	If we have found a result_type, extract it
Cstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes >
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 >
Cstd::_Not_fn< _Fn >	Generalized negator
Cstd::_Placeholder< _Num >	The type of placeholder objects defined by libstdc++
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 >
C__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp >
Cstd::_Tuple_impl< _Idx, _Elements >
Cstd::_V2::condition_variable_any	Condition_variable_any
Cstd::_V2::error_category	Error_category
▼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::_Weak_result_type< _Functor >
Cstd::_Weak_result_type_impl< _Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL >	Retrieve the result type for a function pointer
Cstd::_Weak_result_type_impl< _Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL >	Retrieve the result type for a varargs function pointer
Cstd::_Weak_result_type_impl< _Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL >	Retrieve the result type for a function type
Cstd::_Weak_result_type_impl< _Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL >	Retrieve the result type for a varargs function type
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_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< allocator< _Tp > >	Partial specialization for std::allocator
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::basic_istream< _CharT, _Traits >::sentry	Performs setup work for input streams
Cstd::basic_ostream< _CharT, _Traits >::sentry	Performs setup work for output streams
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_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::binomial_distribution< _IntType >::param_type
Cstd::bitset< _Nb >::reference
Cstd::cauchy_distribution< _RealType >	A cauchy_distribution random number distribution
Cstd::cauchy_distribution< _RealType >::param_type
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::chi_squared_distribution< _RealType >::param_type
Cstd::chrono::_V2::steady_clock	Monotonic clock
Cstd::chrono::_V2::system_clock	System clock
Cstd::chrono::duration< _Rep, _Period >	Duration
Cstd::chrono::duration_values< _Rep >	Duration_values
Cstd::chrono::time_point< _Clock, _Dur >	Time_point
▼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::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
Cstd::condition_variable	Condition_variable
Cstd::conditional< _Cond, _Iftrue, _Iffalse >	Define a member typedef type to one of two argument types
▼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
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
Cstd::default_delete< _Tp >	Primary template of default_delete, used by unique_ptr
Cstd::default_delete< _Tp[]>	Specialization for arrays, default_delete
Cstd::defer_lock_t	Do not acquire ownership of the mutex
Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >
Cstd::discrete_distribution< _IntType >	A discrete_distribution random number distribution
Cstd::discrete_distribution< _IntType >::param_type
Cstd::divides< void >	One of the math functors
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
Cstd::equal_to< void >	One of the comparison functors
Cstd::error_code	Error_code
Cstd::error_condition	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	Thrown to indicate error code of underlying system
Cstd::underflow_error
Cstd::experimental::filesystem::v1::path	A filesystem path
Cstd::experimental::filesystem::v1::path::iterator	An iterator for the components of a path
Cstd::experimental::fundamentals_v1::_Has_addressof< _Tp >	Trait that detects the presence of an overloaded unary operator&
Cstd::experimental::fundamentals_v1::_Optional_base< _Tp, _ShouldProvideDestructor >	Class template that holds the necessary state for Optional values and that has the responsibility for construction and the special members
Cstd::experimental::fundamentals_v1::_Optional_base< _Tp, false >	Partial specialization that is exactly identical to the primary template save for not providing a destructor, to fulfill triviality requirements
Cstd::experimental::fundamentals_v1::any	A type-safe container of any type
Cstd::experimental::fundamentals_v1::basic_string_view< _CharT, _Traits >	A non-owning reference to a string
Cstd::experimental::fundamentals_v1::in_place_t	Tag type for in-place construction
Cstd::experimental::fundamentals_v1::nullopt_t	Tag type to disengage optional objects
Cstd::experimental::fundamentals_v2::ostream_joiner< _DelimT, _CharT, _Traits >	Output iterator that inserts a delimiter between elements
Cstd::experimental::fundamentals_v2::owner_less< shared_ptr< _Tp > >	Partial specialization of owner_less for shared_ptr
Cstd::experimental::fundamentals_v2::owner_less< weak_ptr< _Tp > >	Partial specialization of owner_less for weak_ptr
Cstd::experimental::fundamentals_v2::propagate_const< _Tp >	Const-propagating wrapper
Cstd::exponential_distribution< _RealType >	An exponential continuous distribution for random numbers
Cstd::exponential_distribution< _RealType >::param_type
Cstd::extreme_value_distribution< _RealType >	A extreme_value_distribution random number distribution
Cstd::extreme_value_distribution< _RealType >::param_type
Cstd::fisher_f_distribution< _RealType >	A fisher_f_distribution random number distribution
Cstd::fisher_f_distribution< _RealType >::param_type
Cstd::fpos< _StateT >	Class representing stream positions
Cstd::gamma_distribution< _RealType >	A gamma continuous distribution for random numbers
Cstd::gamma_distribution< _RealType >::param_type
Cstd::geometric_distribution< _IntType >	A discrete geometric random number distribution
Cstd::geometric_distribution< _IntType >::param_type
Cstd::greater< void >	One of the comparison functors
Cstd::greater_equal< void >	One of the comparison functors
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< __profile::bitset< _Nb > >	Std::hash specialization for bitset
Cstd::hash< __profile::vector< bool, _Alloc > >	Std::hash specialization for vector<bool>
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::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>
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_assignable< _Tp &, _Tp && >
Cstd::is_assignable< _Tp &, const _Tp & >
Cstd::is_constructible< _Tp, _Tp && >
Cstd::is_constructible< _Tp, const _Tp & >
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_const< typename >	Is_const
Cstd::is_constructible< _Tp, _Args >	Is_constructible
Cstd::is_default_constructible< _Tp >	Is_default_constructible
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< typename >	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_object< _Tp >	Is_object
Cstd::is_rvalue_reference< typename >	Is_rvalue_reference
Cstd::is_same< typename, typename >	Is_same
Cstd::is_trivially_assignable< _Tp, _Up >	Is_trivially_assignable
Cstd::is_void< _Tp >	Is_void
Cstd::is_volatile< typename >	Is_volatile
Cstd::uses_allocator< tuple< _Types... >, _Alloc >	Partial specialization for tuples
▼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_convertible< _From, _To >	Is_convertible
Cstd::is_copy_assignable< _Tp >	Is_copy_assignable
Cstd::is_copy_constructible< _Tp >	Is_copy_constructible
Cstd::is_destructible< _Tp >	Is_destructible
Cstd::is_floating_point< _Tp >	Is_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_constructible< _Tp, _Args >	Is_nothrow_constructible
Cstd::is_nothrow_copy_assignable< _Tp >	Is_nothrow_copy_assignable
Cstd::is_nothrow_copy_constructible< _Tp >	Is_nothrow_copy_constructible
Cstd::is_nothrow_default_constructible< _Tp >	Is_nothrow_default_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 (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_constructible< _Tp, _Args >	Is_trivially_constructible
Cstd::is_trivially_default_constructible< _Tp >	Is_trivially_default_constructible
Cstd::is_trivially_destructible< _Tp >	Is_trivially_destructible
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::less< void >	One of the comparison functors
Cstd::less_equal< void >	One of the comparison functors
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< 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]
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::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
Cstd::lognormal_distribution< _RealType >::param_type
Cstd::make_signed< _Tp >	Make_signed
Cstd::make_unsigned< _Tp >	Make_unsigned
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::minus< void >	One of the math functors
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::negative_binomial_distribution< _IntType >::param_type
Cstd::nested_exception	Exception class with exception_ptr data member
Cstd::normal_distribution< _RealType >	A normal continuous distribution for random numbers
Cstd::normal_distribution< _RealType >::param_type
Cstd::not_equal_to< void >	One of the comparison functors
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	Once_flag
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< void >	Void specialization of owner_less
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::piecewise_constant_distribution< _RealType >	A piecewise_constant_distribution random number distribution
Cstd::piecewise_constant_distribution< _RealType >::param_type
Cstd::piecewise_construct_t	Piecewise_construct_t
Cstd::piecewise_linear_distribution< _RealType >	A piecewise_linear_distribution random number distribution
Cstd::piecewise_linear_distribution< _RealType >::param_type
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::poisson_distribution< _IntType >::param_type
Cstd::priority_queue< _Tp, _Sequence, _Compare >	A standard container automatically sorting its contents
Cstd::promise< _Res >	Primary template for promise
Cstd::promise< _Res & >	Partial specialization for promise<R&>
Cstd::promise< void >	Explicit specialization for promise<void>
Cstd::queue< _Tp, _Sequence >	A standard container giving FIFO behavior
Cstd::random_device
Cstd::ratio< _Num, _Den >	Provides compile-time rational arithmetic
Cstd::recursive_mutex	The standard recursive mutex type
Cstd::recursive_timed_mutex	Recursive_timed_mutex
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::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
Cstd::result_of< _Signature >	Result_of
Cstd::scoped_allocator_adaptor< _OuterAlloc, _InnerAllocs >	Primary class template
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_lock< _Mutex >	Shared_lock
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 __k
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::student_t_distribution< _RealType >::param_type
Cstd::subtract_with_carry_engine< _UIntType, __w, __s, __r >	The Marsaglia-Zaman generator
Cstd::thread	Thread
Cstd::thread::id	Thread::id
▼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::timed_mutex	Timed_mutex
▼Cstd::tr2::__dynamic_bitset_base< _WordT, _Alloc >
Cstd::tr2::dynamic_bitset< _WordT, _Alloc >	The dynamic_bitset class represents a sequence of bits
Cstd::tr2::__reflection_typelist< _Elements >
Cstd::tr2::__reflection_typelist< _First, _Rest... >	Partial specialization
Cstd::tr2::__reflection_typelist<>	Specialization for an empty typelist
Cstd::tr2::bases< _Tp >	Sequence abstraction metafunctions for manipulating a typelist
Cstd::tr2::bool_set
Cstd::tr2::direct_bases< _Tp >	Enumerate all the direct base classes of a class. Form of a typelist
Cstd::tr2::dynamic_bitset< _WordT, _Alloc >::reference
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, 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
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 >
C__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 >	An SGI extension
C__gnu_cxx::subtractive_rng
C__gnu_cxx::unary_compose< _Operation1, _Operation2 >	An SGI extension
Cstd::pointer_to_unary_function< _Arg, _Result >	One of the adaptors for function pointers
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 with equal probability throughout the range
Cstd::uniform_int_distribution< _IntType >::param_type
Cstd::uniform_real_distribution< _RealType >	Uniform continuous distribution for random numbers
Cstd::uniform_real_distribution< _RealType >::param_type
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< _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::valarray< _Tp >	Smart array designed to support numeric processing
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::weibull_distribution< _RealType >::param_type
Cstd::wstring_convert< _Codecvt, _Elem, _Wide_alloc, _Byte_alloc >	String conversions
Cstd::chrono::time_point< _Clock, _Duration >
▼Cstd::tuple_element< __i - 1, tuple< _Tail... > >
Cstd::tuple_element< __i, tuple< _Head, _Tail... > >
▼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 >
▼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< _T1, _Res >
Cstd::_Maybe_unary_or_binary_function< _Res, _T1 >	Derives from unary_function, as appropriate
▼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 >
Cstd::unique_ptr< _Codecvt >
Cstd::unique_ptr< _Res_type >
Cstd::unique_ptr< _Result< _Res > >
Cstd::unique_ptr< _Result_base >
Cstd::unique_ptr< bool[]>
Cstd::unordered_map< _Key, _Tp, _Hash, _Pred >
Cstd::valarray< _Dom::value_type >
Cstd::valarray< size_t >
Cstd::weak_ptr< _State_baseV2 >