libstdc++
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
oCstd::__atomic_base< _Tp * >
oCstd::__atomic_base< bool >
oC__cxxabiv1::__forced_unwindThrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
oC__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >Policy for shared __pool objects
oC__gnu_cxx::__detail::__mini_vector< _Tp >__mini_vector<> is a stripped down version of the full-fledged std::vector<>
oC__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
oC__gnu_cxx::__mt_alloc_base< _Tp >Base class for _Tp dependent member functions
|\C__gnu_cxx::__mt_alloc< _Tp, _Poolp >This is a fixed size (power of 2) allocator which - when compiled with thread support - will maintain one freelist per size per thread plus a global one. Steps are taken to limit the per thread freelist sizes (by returning excess back to the global list).Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.html
oC__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread >Policy for individual __pool objects
oC__gnu_cxx::__pool< _Thread >Data describing the underlying memory pool, parameterized on threading support
oC__gnu_cxx::__pool_alloc_baseBase class for __pool_alloc
|\C__gnu_cxx::__pool_alloc< _Tp >Allocator using a memory pool with a single lock
oC__gnu_cxx::__pool_baseBase class for pool object
|oC__gnu_cxx::__pool< false >Specialization for single thread
|\C__gnu_cxx::__pool< true >Specialization for thread enabled, via gthreads.h
oC__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >
oC__gnu_cxx::__scoped_lockScoped lock idiom
oC__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >Template class __versa_string.Data structure managing sequences of characters and character-like objects
oC__gnu_cxx::_Caster< _ToType >
oC__gnu_cxx::_Char_types< _CharT >Mapping from character type to associated types
oC__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
oC__gnu_cxx::_Invalid_type
oC__gnu_cxx::_Pointer_adapter< _Storage_policy >
oC__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
oC__gnu_cxx::_Relative_pointer_impl< const _Tp >
oC__gnu_cxx::_Std_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which yields a standard pointer
oC__gnu_cxx::_Unqualified_type< _Tp >
oC__gnu_cxx::annotate_baseBase 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
|oC__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
|oC__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
oC__gnu_cxx::array_allocator_base< _Tp >Base class
|\C__gnu_cxx::array_allocator< typename, typename >An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
oC__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
oC__gnu_cxx::character< _Value, _Int, _St >A POD class that serves as a character abstraction class
oC__gnu_cxx::condition_baseBase struct for condition policy
|oC__gnu_cxx::limit_conditionBase class for incremental control and throw
||oC__gnu_cxx::throw_allocator_base< _Tp, limit_condition >
||\C__gnu_cxx::throw_value_base< limit_condition >
|| \C__gnu_cxx::throw_value_limitType throwing via limit condition
|\C__gnu_cxx::random_conditionBase class for random probability control and throw
| oC__gnu_cxx::throw_allocator_base< _Tp, random_condition >
| \C__gnu_cxx::throw_value_base< random_condition >
|  \C__gnu_cxx::throw_value_randomType throwing via random condition
oC__gnu_cxx::constant_binary_fun< _Result, _Arg1, _Arg2 >An SGI extension
oC__gnu_cxx::constant_unary_fun< _Result, _Argument >An SGI extension
oC__gnu_cxx::constant_void_fun< _Result >An SGI extension
oC__gnu_cxx::debug_allocator< _Alloc >A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard
oC__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
oC__gnu_cxx::free_listThe free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
|\C__gnu_cxx::bitmap_allocator< typename >Bitmap Allocator, primary template
oC__gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
oC__gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
oC__gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc >
oC__gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc >
oC__gnu_cxx::limit_condition::always_adjustorAlways enter the condition
oC__gnu_cxx::limit_condition::limit_adjustorEnter the nth condition
oC__gnu_cxx::limit_condition::never_adjustorNever enter the condition
oC__gnu_cxx::malloc_allocator< typename >An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
oC__gnu_cxx::new_allocator< typename >An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard
|oCstd::allocator< value_type >
|\Cstd::allocator< _Tp >The standard allocator, as per [20.4]
oC__gnu_cxx::project1st< _Arg1, _Arg2 >An SGI extension
oC__gnu_cxx::project2nd< _Arg1, _Arg2 >An SGI extension
oC__gnu_cxx::random_condition::always_adjustorAlways enter the condition
oC__gnu_cxx::random_condition::group_adjustorGroup condition
oC__gnu_cxx::random_condition::never_adjustorNever enter the condition
oC__gnu_cxx::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc >
oC__gnu_cxx::rope< _CharT, _Alloc >
oC__gnu_cxx::select1st< _Pair >An SGI extension
oC__gnu_cxx::select2nd< _Pair >An SGI extension
oC__gnu_cxx::slist< _Tp, _Alloc >
oC__gnu_cxx::throw_value_base< _Cond >Class with exception generation control. Intended to be used as a value_type in templatized code
oC__gnu_debug::_After_nth_from< _Iterator >
oC__gnu_debug::_BeforeBeginHelper< _Sequence >
oC__gnu_debug::_Equal_to< _Type >
oC__gnu_debug::_Not_equal_to< _Type >
oC__gnu_debug::_Safe_iterator_baseBasic functionality for a safe iterator
|oC__gnu_debug::_Safe_iterator< _Iterator, _Sequence >Safe iterator wrapper
|\C__gnu_debug::_Safe_local_iterator_baseBasic functionality for a safe iterator
| \C__gnu_debug::_Safe_local_iterator< _Iterator, _Sequence >Safe iterator wrapper
oC__gnu_debug::_Safe_sequence_baseBase class that supports tracking of iterators that reference a sequence
|oC__gnu_debug::_Safe_sequence< _Sequence >Base class for constructing a safe sequence type that tracks iterators that reference it
|oC__gnu_debug::_Safe_unordered_container_baseBase class that supports tracking of local iterators that reference an unordered container
||oC__gnu_debug::_Safe_unordered_container< _Container >Base class for constructing a safe unordered container type that tracks iterators that reference it
||oC__gnu_debug::_Safe_unordered_container< unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > >
|||\Cstd::__debug::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map with safety/checking/debug instrumentation
||oC__gnu_debug::_Safe_unordered_container< unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > >
|||\Cstd::__debug::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap with safety/checking/debug instrumentation
||oC__gnu_debug::_Safe_unordered_container< unordered_multiset< _Value, _Hash, _Pred, _Alloc > >
|||\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 > >
|| \Cstd::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc >Class std::unordered_set with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< basic_string< _CharT, _Traits, _Allocator > >
||\C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >Class std::basic_string with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< deque< _Tp, _Allocator > >
||\Cstd::__debug::deque< _Tp, _Allocator >Class std::deque with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< forward_list< _Tp, _Alloc > >
||\Cstd::__debug::forward_list< _Tp, _Alloc >Class std::forward_list with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< list< _Tp, _Allocator > >
||\Cstd::__debug::list< _Tp, _Allocator >Class std::list with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< map< _Key, _Tp, _Compare, _Allocator > >
||\Cstd::__debug::map< _Key, _Tp, _Compare, _Allocator >Class std::map with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< multimap< _Key, _Tp, _Compare, _Allocator > >
||\Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< multiset< _Key, _Compare, _Allocator > >
||\Cstd::__debug::multiset< _Key, _Compare, _Allocator >Class std::multiset with safety/checking/debug instrumentation
|oC__gnu_debug::_Safe_sequence< set< _Key, _Compare, _Allocator > >
||\Cstd::__debug::set< _Key, _Compare, _Allocator >Class std::set with safety/checking/debug instrumentation
|\C__gnu_debug::_Safe_sequence< vector< _Tp, _Allocator > >
| \Cstd::__debug::vector< _Tp, _Allocator >Class std::vector with safety/checking/debug instrumentation
oC__gnu_parallel::__accumulate_binop_reduct< _BinOp >General reduction, using a binary operator
oC__gnu_parallel::__generic_find_selectorBase class of all __gnu_parallel::__find_template selectors
|oC__gnu_parallel::__adjacent_find_selectorTest predicate on two adjacent elements
|oC__gnu_parallel::__find_first_of_selector< _FIterator >Test predicate on several elements
|oC__gnu_parallel::__find_if_selectorTest predicate on a single element, used for std::find() and std::find_if ()
|\C__gnu_parallel::__mismatch_selectorTest inverted predicate on a single element
oC__gnu_parallel::__generic_for_each_selector< _It >Generic __selector for embarrassingly parallel functions
|oC__gnu_parallel::__accumulate_selector< _It >Std::accumulate() selector
|oC__gnu_parallel::__adjacent_difference_selector< _It >Selector that returns the difference between two adjacent __elements
|oC__gnu_parallel::__count_if_selector< _It, _Diff >Std::count_if () selector
|oC__gnu_parallel::__count_selector< _It, _Diff >Std::count() selector
|oC__gnu_parallel::__fill_selector< _It >Std::fill() selector
|oC__gnu_parallel::__for_each_selector< _It >Std::for_each() selector
|oC__gnu_parallel::__generate_selector< _It >Std::generate() selector
|oC__gnu_parallel::__identity_selector< _It >Selector that just returns the passed iterator
|oC__gnu_parallel::__inner_product_selector< _It, _It2, _Tp >Std::inner_product() selector
|oC__gnu_parallel::__replace_if_selector< _It, _Op, _Tp >Std::replace() selector
|oC__gnu_parallel::__replace_selector< _It, _Tp >Std::replace() selector
|oC__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
oC__gnu_parallel::__max_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
oC__gnu_parallel::__min_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
oC__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned off
oC__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned on
oC__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned off
oC__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned on
oC__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned on
oC__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned off
oC__gnu_parallel::_DRandomShufflingGlobalData< _RAIter >Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
oC__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator >Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
oC__gnu_parallel::_DummyReductReduction function doing nothing
oC__gnu_parallel::_GuardedIterator< _RAIter, _Compare >_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
oC__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory >A triple of iterators. The usual iterator operations are applied to all three child iterators
oC__gnu_parallel::_Job< _DifferenceTp >One __job for a certain thread
oC__gnu_parallel::_LoserTreeBase< _Tp, _Compare >Guarded loser/tournament tree
|oC__gnu_parallel::_LoserTree< __stable, _Tp, _Compare >Stable _LoserTree variant
|\C__gnu_parallel::_LoserTree< false, _Tp, _Compare >Unstable _LoserTree variant
oC__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_LoserInternal representation of a _LoserTree element
oC__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >Base class of _Loser Tree implementation using pointers
|oC__gnu_parallel::_LoserTreePointer< __stable, _Tp, _Compare >Stable _LoserTree implementation
|\C__gnu_parallel::_LoserTreePointer< false, _Tp, _Compare >Unstable _LoserTree implementation
oC__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_LoserInternal representation of _LoserTree __elements
oC__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare >Unguarded loser tree, keeping only pointers to the elements in the tree structure
|oC__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
oC__gnu_parallel::_LoserTreeTraits< _Tp >Traits for determining whether the loser tree should use pointers or copies
oC__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >Base class for unguarded _LoserTree implementation
|oC__gnu_parallel::_LoserTreeUnguarded< __stable, _Tp, _Compare >Stable implementation of unguarded _LoserTree
|\C__gnu_parallel::_LoserTreeUnguarded< false, _Tp, _Compare >Non-Stable implementation of unguarded _LoserTree
oC__gnu_parallel::_NothingFunctor doing nothing
oC__gnu_parallel::_Piece< _DifferenceTp >Subsequence description
oC__gnu_parallel::_PMWMSSortingData< _RAIter >Data accessed by all threads
oC__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp >Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
oC__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp >_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
oC__gnu_parallel::_QSBThreadLocal< _RAIter >Information local to one thread in the parallel quicksort run
oC__gnu_parallel::_RandomNumberRandom number generator, based on the Mersenne twister
oC__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
oC__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >Stable sorting functor
oC__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >Non-__stable sorting functor
oC__gnu_parallel::_SettingsClass _Settings Run-time settings for the parallel mode including all tunable parameters
oC__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator >Split consistently
oC__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >Split by sampling
oC__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >Split by exact splitting
oC__gnu_parallel::find_tagBase class for for std::find() variants
|oC__gnu_parallel::constant_size_blocks_tagSelects the constant block size variant for std::find()
|oC__gnu_parallel::equal_split_tagSelects the equal splitting variant for std::find()
|\C__gnu_parallel::growing_blocks_tagSelects the growing block size variant for std::find()
oC__gnu_parallel::parallel_tagRecommends parallel execution at compile time, optionally using a user-specified number of threads
|oC__gnu_parallel::balanced_quicksort_tagForces parallel sorting using balanced quicksort at compile time
|oC__gnu_parallel::balanced_tagRecommends parallel execution using dynamic load-balancing at compile time
|oC__gnu_parallel::default_parallel_tagRecommends parallel execution using the default parallel algorithm
|oC__gnu_parallel::exact_tagForces parallel merging with exact splitting, at compile time
|oC__gnu_parallel::multiway_mergesort_exact_tagForces parallel sorting using multiway mergesort with exact splitting at compile time
|oC__gnu_parallel::multiway_mergesort_sampling_tagForces parallel sorting using multiway mergesort with splitting by sampling at compile time
|oC__gnu_parallel::multiway_mergesort_tagForces parallel sorting using multiway mergesort at compile time
|oC__gnu_parallel::omp_loop_static_tagRecommends parallel execution using OpenMP static load-balancing at compile time
|oC__gnu_parallel::omp_loop_tagRecommends parallel execution using OpenMP dynamic load-balancing at compile time
|oC__gnu_parallel::quicksort_tagForces parallel sorting using unbalanced quicksort at compile time
|oC__gnu_parallel::sampling_tagForces parallel merging with exact splitting, at compile time
|\C__gnu_parallel::unbalanced_tagRecommends parallel execution using static load-balancing at compile time
oC__gnu_parallel::sequential_tagForces sequential execution at compile time
oC__gnu_pbds::basic_branch< Key, Mapped, Tag, Node_Update, Policy_Tl, _Alloc >
oC__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, Tag, Policy_Tl, _Alloc >
oC__gnu_pbds::basic_invalidation_guarantee
|\C__gnu_pbds::point_invalidation_guarantee
| \C__gnu_pbds::range_invalidation_guarantee
oC__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
oC__gnu_pbds::container_tagBase data structure tag
|oC__gnu_pbds::associative_tagBasic associative-container
||oC__gnu_pbds::basic_branch_tagBasic branch structure
|||oC__gnu_pbds::tree_tagBasic tree structure
||||oC__gnu_pbds::ov_tree_tagOrdered-vector tree
||||oC__gnu_pbds::rb_tree_tagRed-black tree
||||\C__gnu_pbds::splay_tree_tagSplay tree
|||\C__gnu_pbds::trie_tagBasic trie structure
||| \C__gnu_pbds::pat_trie_tagPATRICIA trie
||oC__gnu_pbds::basic_hash_tagBasic hash structure
|||oC__gnu_pbds::cc_hash_tagCollision-chaining hash
|||\C__gnu_pbds::gp_hash_tagGeneral-probing hash
||\C__gnu_pbds::list_update_tagList-update
|oC__gnu_pbds::priority_queue_tagBasic priority-queue
||oC__gnu_pbds::binary_heap_tagBinary-heap (array-based)
||oC__gnu_pbds::binomial_heap_tagBinomial-heap
||oC__gnu_pbds::pairing_heap_tagPairing-heap
||oC__gnu_pbds::rc_binomial_heap_tagRedundant-counter binomial-heap
||\C__gnu_pbds::thin_heap_tagThin heap
|\C__gnu_pbds::sequence_tagBasic sequence
| \C__gnu_pbds::string_tagBasic string container, inclusive of strings, ropes, etc
oC__gnu_pbds::container_traits_base< _Tag >Primary template, container traits base
oC__gnu_pbds::container_traits_base< binary_heap_tag >Specialization, binary heap
oC__gnu_pbds::container_traits_base< binomial_heap_tag >Specialization, binomial heap
oC__gnu_pbds::container_traits_base< cc_hash_tag >Specialization, cc hash
oC__gnu_pbds::container_traits_base< gp_hash_tag >Specialization, gp hash
oC__gnu_pbds::container_traits_base< list_update_tag >Specialization, list update
oC__gnu_pbds::container_traits_base< ov_tree_tag >Specialization, ov tree
oC__gnu_pbds::container_traits_base< pairing_heap_tag >Specialization, pairing heap
oC__gnu_pbds::container_traits_base< pat_trie_tag >Specialization, pat trie
oC__gnu_pbds::container_traits_base< rb_tree_tag >Specialization, rb tree
oC__gnu_pbds::container_traits_base< rc_binomial_heap_tag >Specialization, rc binomial heap
oC__gnu_pbds::container_traits_base< splay_tree_tag >Specialization, splay tree
oC__gnu_pbds::container_traits_base< thin_heap_tag >Specialization, thin heap
oC__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
oC__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
oC__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Node, _Alloc >Binary search tree traits, primary template
oC__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc >Specialization
oC__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
oC__gnu_pbds::detail::branch_policy< Node_CItr, Node_Itr, _Alloc >Primary template, base class for branch structure policies
|oC__gnu_pbds::detail::trie_policy_base< Node_CItr, Node_Itr, _ATraits, _Alloc >Base class for trie policies
||oC__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
oC__gnu_pbds::detail::branch_policy< Node_CItr, Node_CItr, _Alloc >Specialization for const iterators
oC__gnu_pbds::detail::cond_dealtor< Entry, _Alloc >Conditional deallocate constructor argument
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, Tag, Policy_Tl >Dispatch mechanism, primary template for associative types
oC__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type >Specialization for binary_heap
oC__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type >Specialization for binomial_heap
oC__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type >Specialization for pairing_heap
oC__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type >Specialization for rc_binary_heap
oC__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type >Specialization for thin_heap
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl >Specialization colision-chaining hash map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl >Specialization general-probe hash map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl >Specialization for list-update map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl >Specialization ordered-vector tree map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl >Specialization for PATRICIA trie map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl >Specialization for R-B tree map
oC__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl >Specialization splay tree map
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl >Specialization colision-chaining hash set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl >Specialization general-probe hash set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl >Specialization for list-update set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl >Specialization ordered-vector tree set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl >Specialization for PATRICIA trie set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl >Specialization for R-B tree set
oC__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl >Specialization splay tree set
oC__gnu_pbds::detail::default_comb_hash_fnPrimary template, default_comb_hash_fn
oC__gnu_pbds::detail::default_eq_fn< Key >Primary template, default_eq_fn
oC__gnu_pbds::detail::default_hash_fn< Key >Primary template, default_hash_fn
oC__gnu_pbds::detail::default_probe_fn< Comb_Probe_Fn >Primary template, default_probe_fn
oC__gnu_pbds::detail::default_resize_policy< Comb_Hash_Fn >Primary template, default_resize_policy
oC__gnu_pbds::detail::default_trie_access_traits< Key >Primary template, default_trie_access_traits
oC__gnu_pbds::detail::default_trie_access_traits< std::basic_string< Char, Char_Traits, std::allocator< char > > >Partial specialization, default_trie_access_traits
oC__gnu_pbds::detail::default_update_policyDefault update policy
oC__gnu_pbds::detail::dumnode_const_iterator< Key, Data, _Alloc >Constant node iterator
oC__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, No_Throw >Entry compare, primary template
oC__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >Specialization, false
oC__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >::typeCompare plus entry
oC__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, true >Specialization, true
oC__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, No_Throw >Entry predicate primary class template
oC__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, false >Specialization, false
oC__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, true >Specialization, true
oC__gnu_pbds::detail::eq_by_less< Key, Cmp_Fn >Equivalence function
oC__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, Store_Hash >Primary template
|oC__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 >
oC__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, false >Specialization 1 - The client requests that hash values not be stored
oC__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, true >Specialization 2 - The client requests that hash values be stored
oC__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, Hold_Size >Primary template
oC__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, true >Specializations
oC__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, Node_Metadata, _Alloc >Base class for a basic heap
oC__gnu_pbds::detail::left_child_next_sibling_heap_node_< _Value, _Metadata, _Alloc >Node
oC__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
oC__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
oC__gnu_pbds::detail::lu_counter_policy_base< Size_Type >Base class for list-update counter policy
oC__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)
oC__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)
oC__gnu_pbds::detail::no_throw_copies< Key, Mapped >Primary template
oC__gnu_pbds::detail::no_throw_copies< Key, null_type >Specialization
oC__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >::cond_dtor< Size_Type >Conditional destructor
oC__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
oC__gnu_pbds::detail::pat_trie_baseBase 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
oC__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
oC__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::const_iteratorConstant child iterator
|\C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::iteratorChild iterator
oC__gnu_pbds::detail::pat_trie_base::_Metadata< Metadata, _Alloc >Metadata base primary template
oC__gnu_pbds::detail::pat_trie_base::_Metadata< null_type, _Alloc >Specialization for null metadata
oC__gnu_pbds::detail::pat_trie_base::_Node_base< _ATraits, Metadata >Node base
|oC__gnu_pbds::detail::pat_trie_base::_Head< _ATraits, Metadata >Head node for PATRICIA tree
|oC__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
oC__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
oC__gnu_pbds::detail::probe_fn_base< _Alloc >Probe functor base
oC__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 >
oC__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false >
oC__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true >
oC__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false >
oC__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true >
oC__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 >
oC__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false >
oC__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true >
oC__gnu_pbds::detail::ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false >
oC__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)
oC__gnu_pbds::detail::rb_tree_node_< Value_Type, Metadata, _Alloc >Node for Red-Black trees
oC__gnu_pbds::detail::rc< _Node, _Alloc >Redundant binary counter
oC__gnu_pbds::detail::resize_policy< _Tp >Resize policy for binary heap
oC__gnu_pbds::detail::splay_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >Splay tree
oC__gnu_pbds::detail::splay_tree_node_< Value_Type, Metadata, _Alloc >Node for splay tree
oC__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
oC__gnu_pbds::detail::stored_value< _Tv >Stored value
|oC__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
oC__gnu_pbds::detail::synth_access_traits< Type_Traits, Set, _ATraits >Synthetic element access traits
oC__gnu_pbds::detail::tree_metadata_helper< Node_Update, _BTp >Tree metadata helper
oC__gnu_pbds::detail::tree_metadata_helper< Node_Update, false >Specialization, false
oC__gnu_pbds::detail::tree_metadata_helper< Node_Update, true >Specialization, true
oC__gnu_pbds::detail::tree_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >Tree node metadata dispatch
oC__gnu_pbds::detail::tree_traits< Key, Data, Cmp_Fn, Node_Update, Tag, _Alloc >Tree traits class, primary template
oC__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >Tree traits
oC__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >Specialization
oC__gnu_pbds::detail::trie_metadata_helper< Node_Update, _BTp >Trie metadata helper
oC__gnu_pbds::detail::trie_metadata_helper< Node_Update, false >Specialization, false
oC__gnu_pbds::detail::trie_metadata_helper< Node_Update, true >Specialization, true
oC__gnu_pbds::detail::trie_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >Trie node metadata dispatch
oC__gnu_pbds::detail::trie_traits< Key, Data, _ATraits, Node_Update, Tag, _Alloc >Trie traits class, primary template
oC__gnu_pbds::detail::trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc >Specialization
oC__gnu_pbds::detail::trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc >Specialization
oC__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, Store_Hash >Primary template
|oC__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, Store_Hash >Traits for abstract types
||oC__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 >
| oC__gnu_pbds::detail::lu_map< Key, Mapped, Eq_Fn, _Alloc, Update_Policy >List-based (with updates) associative container. Skip to the lu, my darling
| oC__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
oC__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, false >
oC__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, true >
oC__gnu_pbds::detail::type_base< Key, null_type, _Alloc, false >
oC__gnu_pbds::detail::type_base< Key, null_type, _Alloc, true >
oC__gnu_pbds::detail::type_dispatch< Key, Mapped, _Alloc, Store_Hash >Type base dispatch
oC__gnu_pbds::hash_exponential_size_policy< Size_Type >A size policy whose sequence of sizes form an exponential sequence (typically powers of 2
oC__gnu_pbds::hash_prime_size_policyA size policy whose sequence of sizes form a nearly-exponential sequence of primes
oC__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
oC__gnu_pbds::linear_probe_fn< Size_Type >A probe sequence policy using fixed increments
oC__gnu_pbds::list_update< Key, Mapped, Eq_Fn, Update_Policy, _Alloc >
oC__gnu_pbds::lu_move_to_front_policy< _Alloc >
oC__gnu_pbds::null_typeRepresents 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
oC__gnu_pbds::priority_queue< _Tv, Cmp_Fn, Tag, _Alloc >
oC__gnu_pbds::quadratic_probe_fn< Size_Type >A probe sequence policy using square increments
oC__gnu_pbds::sample_probe_fnA sample probe policy
oC__gnu_pbds::sample_range_hashingA sample range-hashing functor
oC__gnu_pbds::sample_ranged_hash_fnA sample ranged-hash functor
oC__gnu_pbds::sample_ranged_probe_fnA sample ranged-probe functor
oC__gnu_pbds::sample_resize_policyA sample resize policy
oC__gnu_pbds::sample_resize_triggerA sample resize trigger policy
oC__gnu_pbds::sample_size_policyA sample size policy
oC__gnu_pbds::sample_tree_node_update< Const_Node_Iter, Node_Iter, Cmp_Fn, _Alloc >A sample node updator
oC__gnu_pbds::sample_trie_access_traitsA sample trie element access traits
oC__gnu_pbds::sample_trie_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >A sample node updator
oC__gnu_pbds::sample_update_policyA sample list-update policy
oC__gnu_pbds::trie_string_access_traits< String, Min_E_Val, Max_E_Val, Reverse, _Alloc >
oC__gnu_pbds::trivial_iterator_tagA trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
oC__gnu_profile::__object_info_baseBase class for a line in the object table
|oC__gnu_profile::__container_size_infoA container size instrumentation line in the object table
||\C__gnu_profile::__container_size_stack_infoA container size instrumentation line in the stack table
|oC__gnu_profile::__hashfunc_infoA hash performance instrumentation line in the object table
||\C__gnu_profile::__hashfunc_stack_infoA hash performance instrumentation line in the stack table
|oC__gnu_profile::__list2vector_infoA list-to-vector instrumentation line in the object table
|oC__gnu_profile::__map2umap_infoA map-to-unordered_map instrumentation line in the object table
||\C__gnu_profile::__map2umap_stack_infoA map-to-unordered_map instrumentation line in the stack table
|\C__gnu_profile::__vector2list_infoA vector-to-list instrumentation line in the object table
| \C__gnu_profile::__vector2list_stack_infoA vector-to-list instrumentation line in the stack table
oC__gnu_profile::__reentrance_guardReentrance guard
oC__gnu_profile::__stack_hashHash function for summary trace using call stack as index
oC__gnu_profile::__stack_info_base< __object_info >Base class for a line in the stack table
oC__gnu_profile::__trace_base< __object_info, __stack_info >Base class for all trace producers
oC__gnu_profile::__warning_dataRepresentation of a warning
oC__gnu_profile::__trace_base< __container_size_info, __container_size_stack_info >
|\C__gnu_profile::__trace_container_sizeContainer size instrumentation trace producer
| oC__gnu_profile::__trace_hashtable_sizeHashtable size instrumentation trace producer
| \C__gnu_profile::__trace_vector_sizeHashtable size instrumentation trace producer
oC__gnu_profile::__trace_base< __hashfunc_info, __hashfunc_stack_info >
|\C__gnu_profile::__trace_hash_funcHash performance instrumentation producer
oC__gnu_profile::__trace_base< __list2slist_info, __list2slist_stack_info >
oC__gnu_profile::__trace_base< __list2vector_info, __list2vector_stack_info >
oC__gnu_profile::__trace_base< __map2umap_info, __map2umap_stack_info >
|\C__gnu_profile::__trace_map2umapMap-to-unordered_map instrumentation producer
oC__gnu_profile::__trace_base< __vector2list_info, __vector2list_stack_info >
|\C__gnu_profile::__trace_vector_to_listVector-to-list instrumentation producer
oC__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >
oCstd::_Deque_base< _StateSeqT, std::allocator< _StateSeqT > >
|\Cstd::deque< _StateSeqT >
oCstd::_Deque_iterator< _Tp, _Tp &, _Tp * >
oCstd::_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
oCstd::_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
oCstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
|\Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
oCstd::__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 >
| oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
| oCstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
| \Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
oCstd::__detail::_Hashtable_ebo_helper< 0, __alloctr_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > >::__type >
|\Cstd::__detail::_Hashtable_alloc< __alloctr_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > >::__type >
| \Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
oCstd::__detail::_Hashtable_ebo_helper< 0, _Equal >
|\Cstd::__detail::_Hashtable_base< _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits >
oCstd::__detail::_Hashtable_ebo_helper< 0, _ExtractKey >
|oCstd::__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
|oCstd::__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
oCstd::__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
oCstd::__detail::_Hashtable_ebo_helper< 0, _NodeAlloc >
|\Cstd::__detail::_Hashtable_alloc< _NodeAlloc >
| oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
| \Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
oCstd::__detail::_Hashtable_ebo_helper< 1, _H1 >
|oCstd::__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
oCstd::__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
oCstd::__detail::_Hashtable_ebo_helper< 2, _H2 >
|oCstd::__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
oCstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
|\Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
oCstd::_List_base< __inp, __rebind_inp >
|\Cstd::list< __inp, __rebind_inp >
oCstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache >
|oCstd::__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
oCstd::__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 >
oCstd::_Maybe_get_result_type< __has_result_type< _Functor >::value, _Functor >
|\Cstd::_Weak_result_type_impl< _Functor >
oCstd::_Maybe_get_result_type< __has_result_type< remove_cv< _Functor >::type >::value, remove_cv< _Functor >::type >
|\Cstd::_Weak_result_type_impl< remove_cv< _Functor >::type >
| \Cstd::_Weak_result_type< _Functor >
oCstd::_Maybe_get_result_type< __has_result_type< remove_cv< _Tp >::type >::value, remove_cv< _Tp >::type >
|\Cstd::_Weak_result_type_impl< remove_cv< _Tp >::type >
| \Cstd::_Weak_result_type< _Tp >
oCstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes...>
|\Cstd::function< _Res(_ArgTypes...)>Primary class template for std::function.Polymorphic function wrapper
oCstd::_Maybe_unary_or_binary_function< _Res, _Class *, _ArgTypes...>
|\Cstd::_Mem_fn< _Res(_Class::*)(_ArgTypes...)>Implementation of mem_fn for member function pointers
oCstd::_Maybe_unary_or_binary_function< _Res, const _Class *, _ArgTypes...>
|\Cstd::_Mem_fn< _Res(_Class::*)(_ArgTypes...) const >Implementation of mem_fn for const member function pointers
oCstd::_Maybe_unary_or_binary_function< _Res, const volatile _Class *, _ArgTypes...>
|\Cstd::_Mem_fn< _Res(_Class::*)(_ArgTypes...) const volatile >Implementation of mem_fn for const volatile member function pointers
oCstd::_Maybe_unary_or_binary_function< _Res, volatile _Class *, _ArgTypes...>
|\Cstd::_Mem_fn< _Res(_Class::*)(_ArgTypes...) volatile >Implementation of mem_fn for volatile member function pointers
oCstd::__detail::_Node_iterator_base< _Value, __cache >
|oCstd::__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
oCstd::_Reference_wrapper_base_impl< __has_argument_type< _Tp >::value, __has_first_argument_type< _Tp >::value &&__has_second_argument_type< _Tp >::value, _Tp >
|\Cstd::_Reference_wrapper_base< _Tp >
oCstd::_Reference_wrapper_base_impl< __has_argument_type< remove_cv< _Tp >::type >::value, __has_first_argument_type< remove_cv< _Tp >::type >::value &&__has_second_argument_type< remove_cv< _Tp >::type >::value, remove_cv< _Tp >::type >
|\Cstd::_Reference_wrapper_base< remove_cv< _Tp >::type >
| \Cstd::reference_wrapper< _Tp >Primary class template for reference_wrapper
oC__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
oCstd::_Tuple_impl< 0, _Elements...>
|oCstd::tuple< _Elements >Primary class template, tuple
|oCstd::tuple< _Bound_args...>
|oCstd::tuple< _Callable, _Args...>
|oCstd::tuple< typename _Pointer::type, _Dp >
|oCstd::tuple< typename _Pointer::type, default_delete< std::vector< bool > > >
|\Cstd::tuple< typename _Pointer::type, default_delete< std::vector< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > > > > >
oCstd::_Tuple_impl< 0, _T1, _T2 >
|\Cstd::tuple< _T1, _T2 >Partial specialization, 2-element tuple. Includes construction and assignment from a pair
oCstd::_Tuple_impl< _Idx+1, _Tail...>
|\Cstd::_Tuple_impl< _Idx, _Head, _Tail...>
oCstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > >
|\Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > >
oCstd::_Vector_base< _CharT, std::allocator< _CharT > >
|\Cstd::vector< _CharT >
oCstd::_Vector_base< _Node *, _Nodeptr_Alloc >
|\Cstd::vector< _Node *, _Nodeptr_Alloc >
oCstd::_Vector_base< _RealType, std::allocator< _RealType > >
|\Cstd::vector< _RealType >
oCstd::_Vector_base< _State< _TraitsT >, std::allocator< _State< _TraitsT > > >
|\Cstd::vector< _State< _TraitsT > >
oCstd::_Vector_base< _StringT, std::allocator< _StringT > >
|\Cstd::vector< _StringT >
oCstd::_Vector_base< block_type, allocator_type >
|\Cstd::vector< block_type, allocator_type >
oCstd::_Vector_base< double, std::allocator< double > >
|\Cstd::vector< double >
oCstd::_Vector_base< int, std::allocator< int > >
|\Cstd::vector< int >
oCstd::_Vector_base< result_type, std::allocator< result_type > >
|\Cstd::vector< result_type >
oCstd::_Vector_base< size_t, std::allocator< size_t > >
|\Cstd::vector< size_t >
oCstd::_Vector_base< std::pair< _StrTransT, _StrTransT >, std::allocator< std::pair< _StrTransT, _StrTransT > > >
|\Cstd::vector< std::pair< _StrTransT, _StrTransT > >
oCstd::_Vector_base< sub_match< _Bi_iter >, _Alloc >
|\Cstd::vector< sub_match< _Bi_iter >, _Alloc >
| oCstd::match_results< _Bi_iter >
| \Cstd::match_results< typename, typename >The results of a match or search operation
oCstd::_Vector_base< sub_match< _BiIter >, _Alloc >
|\Cstd::vector< sub_match< _BiIter >, _Alloc >
oCstd::allocator_traits< _Tp_alloc_type >
|\C__gnu_cxx::__alloc_traits< _Tp_alloc_type >
oC__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 >
oC__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 >
oC__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 >
oC__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 >
oCstd::basic_streambuf< char, char_traits< char > >
oCstd::basic_string< _Ch_type >
oCstd::basic_string< _CharT >
oCstd::basic_string< _CharT, _Traits, _Allocator >
|\C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >Class std::basic_string with safety/checking/debug instrumentation
oCstd::basic_string< char >
oCstd::basic_string< char_type, _Traits, _Alloc >
oC__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
oC__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
oC__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
oC__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
oCstd::binary_function< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool >
oCstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool >
oCstd::binary_function< _Arg1, _Arg2, _Arg1 >
oCstd::binary_function< _Arg1, _Arg2, _Arg2 >
oCstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool >
|\Cstd::binary_negate< _Predicate >One of the negation functors
oCstd::binary_function< _Sp, _Sp, bool >
oCstd::binary_function< _T1 *, _T2, _Res >
oCstd::binary_function< _T1, _T2, _Res >
|\Cstd::_Maybe_unary_or_binary_function< _Res, _T1, _T2 >Derives from binary_function, as appropriate
oCstd::binary_function< _T1, _T2, bool >
|oC__gnu_parallel::_EqualFromLess< _T1, _T2, _Compare >Constructs predicate for equality from strict weak ordering predicate
|oC__gnu_parallel::_EqualTo< _T1, _T2 >Similar to std::equal_to, but allows two different types
|oC__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
oCstd::binary_function< _Tp *, _Arg, _Ret >
|\Cstd::mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
oCstd::binary_function< _Tp, _Arg, _Ret >
|oCstd::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
oCstd::binary_function< _Tp, _Tp, _Tp >
|oCstd::divides< _Tp >One of the math functors
|oCstd::minus< _Tp >One of the math functors
|oCstd::modulus< _Tp >One of the math functors
|oCstd::multiplies< _Tp >One of the math functors
|\Cstd::plus< _Tp >One of the math functors
oCstd::binary_function< _Tp, _Tp, bool >
|oCstd::equal_to< _Tp >One of the comparison functors
|oCstd::greater< _Tp >One of the comparison functors
|oCstd::greater_equal< _Tp >One of the comparison functors
|oCstd::less< _Tp >One of the comparison functors
|oCstd::less_equal< _Tp >One of the comparison functors
|oCstd::logical_and< _Tp >One of the Boolean operations functors
|oCstd::logical_or< _Tp >One of the Boolean operations functors
|\Cstd::not_equal_to< _Tp >One of the comparison functors
oCstd::binary_function< _Tp1, _Tp2, _Result >
|oC__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
oCstd::binary_function< const _T1 *, _T2, _Res >
oCstd::binary_function< const _Tp *, _Arg, _Ret >
|\Cstd::const_mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
oCstd::binary_function< const volatile _T1 *, _T2, _Res >
oCstd::binary_function< rope< _CharT, _Alloc >, rope< _CharT, _Alloc >, rope< _CharT, _Alloc > >
oCstd::binary_function< shared_ptr< _Tp >, shared_ptr< _Tp >, bool >
oCstd::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
oCstd::binary_function< value_type, value_type, bool >
oCstd::binary_function< volatile _T1 *, _T2, _Res >
oCstd::binary_function< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >
oC__gnu_pbds::container_traits_base< Cntnr::container_category >
|\C__gnu_pbds::container_traits< Cntnr >Container traits
oCstd::gamma_distribution< double >
oCstd::gamma_distribution< result_type >
oC__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
oCstd::integral_constant< bool, __big_less< _Left::__hi, _Left::__lo, _Right::__hi, _Right::__lo >::value >
oCstd::integral_constant< bool, __is_abstract(_Tp)>
|\Cstd::is_abstract< _Tp >Is_abstract
oCstd::integral_constant< bool, __is_class(_Tp)>
|\Cstd::is_class< _Tp >Is_class
oCstd::integral_constant< bool, __is_empty(_Tp)>
|\Cstd::is_empty< _Tp >Is_empty
oCstd::integral_constant< bool, __is_enum(_Tp)>
|\Cstd::is_enum< _Tp >Is_enum
oCstd::integral_constant< bool, __is_literal_type(_Tp)>
|\Cstd::is_literal_type< _Tp >Is_literal_type
oCstd::integral_constant< bool, __is_pod(_Tp)>
|\Cstd::is_pod< _Tp >Is_pod
oCstd::integral_constant< bool, __is_polymorphic(_Tp)>
|\Cstd::is_polymorphic< _Tp >Is_polymorphic
oCstd::integral_constant< bool, __is_standard_layout(_Tp)>
|\Cstd::is_standard_layout< _Tp >Is_standard_layout
oCstd::integral_constant< bool, __is_trivial(_Tp)>
|\Cstd::is_trivial< _Tp >Is_trivial
oCstd::integral_constant< bool, __is_union(_Tp)>
|\Cstd::is_union< _Tp >Is_union
oCstd::integral_constant< bool, __uses_allocator_helper< _Tp, _Alloc >::value >
|\Cstd::uses_allocator< typename, typename >Declare uses_allocator so it can be specialized in <queue> etc
oCstd::integral_constant< bool, _R1::num==_R2::num &&_R1::den==_R2::den >
|\Cstd::ratio_equal< _R1, _R2 >Ratio_equal
oCstd::integral_constant< bool, is_convertible< _Alloc, _Tp::allocator_type >::value >
oCstd::integral_constant< bool, is_function< _Tp >::value >
oCstd::integral_constant< bool, noexcept(declval< const _Hash & >()(declval< const _Key & >()))>
oCstd::integral_constant< bool,!_Pp::value >
oCstd::integral_constant< bool,!is_function< _Tp >::value >
oCstd::integral_constant< bool,!is_fundamental< _Tp >::value >
|\Cstd::is_compound< _Tp >Is_compound
oCstd::integral_constant< bool,!ratio_equal< _R1, _R2 >::value >
|\Cstd::ratio_not_equal< _R1, _R2 >Ratio_not_equal
oCstd::integral_constant< bool,(__hi1< __hi2||(__hi1==__hi2 &&__lo1< __lo2))>
oCstd::integral_constant< bool,(is_pointer< _Tp >::value||is_member_pointer< _Tp >::value)>
|\Cstd::__is_location_invariant< _Tp >
oCstd::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. [TR1 3.6.2]
oCstd::integral_constant< int, _Num >
|\Cstd::is_placeholder< _Placeholder< _Num > >
oCstd::integral_constant< intmax_t, __static_abs< _Pn >::value >
oCstd::integral_constant< intmax_t, __static_abs< _Qn >::value >
oCstd::integral_constant< intmax_t, _Pn *__static_sign< _Pn >::value >
oCstd::integral_constant< intmax_t,(_Pn< 0)?-1:1 >
oCstd::integral_constant< remove_cv< decltype(tuple_size< _Tp >::value)>::type, tuple_size< _Tp >::value >
oCstd::integral_constant< size_t, sizeof...(_Types)>
oCstd::integral_constant< std::size_t, 2 >
oCstd::integral_constant< std::size_t, _Nm >
oCstd::integral_constant< std::size_t, sizeof...(_Elements)>
|\Cstd::tuple_size< tuple< _Elements...> >Class tuple_size
oCstd::is_floating_point< _Rep >
|\Cstd::chrono::treat_as_floating_point< _Rep >Treat_as_floating_point
oCstd::iterator< input_iterator_tag, _CharT, _Traits::off_type, _CharT *, _CharT >
|\Cstd::istreambuf_iterator< _CharT, _Traits >Provides input iterator semantics for streambufs
oCstd::iterator< input_iterator_tag, _Tp, _Dist, const _Tp *, const _Tp & >
|\Cstd::istream_iterator< _Tp, _CharT, _Traits, _Dist >Provides input iterator semantics for streams
oCstd::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 >
oCstd::iterator< output_iterator_tag, void, void, void, void >
|oCstd::back_insert_iterator< _Container >Turns assignment into insertion
|oCstd::front_insert_iterator< _Container >Turns assignment into insertion
|oCstd::insert_iterator< _Container >Turns assignment into insertion
|oCstd::ostream_iterator< _Tp, _CharT, _Traits >Provides output iterator semantics for streams
|oCstd::ostreambuf_iterator< _CharT, _Traits >Provides output iterator semantics for streambufs
|\Cstd::raw_storage_iterator< _OutputIterator, _Tp >
oCstd::iterator< std::output_iterator_tag, void, void, void, void >
oCstd::iterator< std::random_access_iterator_tag, _CharT >
oCstd::iterator< std::random_access_iterator_tag, bool >
oC__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, _Alloc::size_type, _Alloc >
|oC__gnu_pbds::detail::binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >Base class for binomial heap
||oC__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 >
oC__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 >
oC__gnu_pbds::detail::lu_counter_policy_base< _Alloc::size_type >
|\C__gnu_pbds::lu_counter_policy< Max_Count, _Alloc >
oCstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
oCstd::normal_distribution< double >
oCstd::normal_distribution< result_type >
oCstd::pair< _Bi_iter, _Bi_iter >
|\Cstd::sub_match< _Bi_iter >
oCstd::pair< _BiIter, _BiIter >
|\Cstd::sub_match< _BiIter >
oCstd::pair< _Iterator1, _Iterator2 >
|\C__gnu_parallel::_IteratorPair< _Iterator1, _Iterator2, _IteratorCategory >A pair of iterators. The usual iterator operations are applied to both child iterators
oCstd::pair< _RAIter, _RAIter >
oCstd::pair< char, _TokenT >
oCstd::pair< char, char >
oCstd::pair< entry_pointer, typename _Alloc::size_type >
oCpoint_const_iterator_Const point-type iterator
|\Cconst_iterator_Const range-type iterator
| \Citerator_Range-type iterator
oCpoint_iterator_Find type iterator
oC__gnu_pbds::detail::rc< typename binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >::node, _Alloc >
oC__gnu_pbds::detail::resize_policy< _Alloc::size_type >
|\C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >
oCstd::scoped_allocator_adaptor< _InnerHead, _InnerTail...>
oCstd::shared_ptr< __detail::_NFA< _Rx_traits > >
oCstd::shared_ptr< _Impl_base >
oCstd::shared_ptr< std::mutex >
oCstd::stack< _StateSeqT >
oCstd::__atomic_base< _IntTp >Base class for atomic integrals
|oCstd::atomic< char >Explicit specialization for char
|oCstd::atomic< char16_t >Explicit specialization for char16_t
|oCstd::atomic< char32_t >Explicit specialization for char32_t
|oCstd::atomic< int >Explicit specialization for int
|oCstd::atomic< long >Explicit specialization for long
|oCstd::atomic< long long >Explicit specialization for long long
|oCstd::atomic< short >Explicit specialization for short
|oCstd::atomic< signed char >Explicit specialization for signed char
|oCstd::atomic< unsigned char >Explicit specialization for unsigned char
|oCstd::atomic< unsigned int >Explicit specialization for unsigned int
|oCstd::atomic< unsigned long >Explicit specialization for unsigned long
|oCstd::atomic< unsigned long long >Explicit specialization for unsigned long long
|oCstd::atomic< unsigned short >Explicit specialization for unsigned short
|\Cstd::atomic< wchar_t >Explicit specialization for wchar_t
oCstd::__atomic_base< _PTp * >Partial specialization for pointer types
oCstd::__atomic_flag_baseBase type for atomic_flag
|\Cstd::atomic_flagAtomic_flag
oCstd::__debug::bitset< _Nb >Class std::bitset with additional safety/checking/debug instrumentation
oCstd::__detail::_BracketMatcher< typename, bool, bool >Matches a character range (bracket expression)
oCstd::__detail::_Compiler< _TraitsT >Builds an NFA from an input iterator interval
oCstd::__detail::_Default_ranged_hashDefault 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
oCstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, __cache_hash_code >
oCstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, false >Specialization
oCstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, true >Specialization
oCstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys >
|oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
|\Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
oCstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >Specialization
oCstd::__detail::_Equality_base
|\Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >Specialization
oCstd::__detail::_Executor< typename, typename, typename, bool >Takes a regex and an input string in and do the matching
oCstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code >
oCstd::__detail::_Hash_node< _Value, _Cache_hash_code >
oCstd::__detail::_Hash_node_base
|\Cstd::__detail::_Hash_node_value_base< _Value >
| oCstd::__detail::_Hash_node< _Value, false >
| \Cstd::__detail::_Hash_node< _Value, true >
oCstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, __use_ebo >
oCstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, false >Specialization not using EBO
oCstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, true >Specialization using EBO
oCstd::__detail::_Hashtable_traits< _Cache_hash_code, _Constant_iterators, _Unique_keys >
oCstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Constant_iterators, _Unique_keys >
|oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
|\Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
oCstd::__detail::_Insert_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
|oCstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false, _Unique_keys >Specialization
|oCstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, false >Specialization
|\Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, true >Specialization
oCstd::__detail::_List_node_baseCommon part of a node in the list
|\Cstd::_List_node< _Tp >An actual node in the list
oCstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code >
oCstd::__detail::_Map_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys >
|oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
|\Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
oCstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >Partial specialization, __unique_keys set to false
oCstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >Partial specialization, __unique_keys set to true
oCstd::__detail::_Mod_range_hashingDefault range hashing function: use division to fold a large number into the range [0, N)
oCstd::__detail::_Node_iterator_base< _Value, _Cache_hash_code >Base class for node iterators
oCstd::__detail::_Prime_rehash_policyDefault value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load factor small enough
oCstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
|oCstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
|oCstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
|\Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
oCstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _Prime_rehash_policy, _Traits >Specialization
oCstd::__detail::_Scanner< _CharT >Scans an input range for regex tokens
oCstd::__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
oCstd::__exception_ptr::exception_ptrAn opaque pointer to an arbitrary exception
oCstd::__has_iterator_category_helper< _Tp >Traits class for iterators
oCstd::__numeric_limits_basePart of std::numeric_limits
|\Cstd::numeric_limits< _Tp >Properties of fundamental types
oCstd::__parallel::_CRandNumber< _MustBeInt >Functor wrapper for std::rand()
oCstd::__profile::bitset< _Nb >Class std::bitset wrapper with performance instrumentation
oCstd::__profile::deque< _Tp, _Allocator >Class std::deque wrapper with performance instrumentation
oCstd::__profile::forward_list< _Tp, _Alloc >Class std::forward_list wrapper with performance instrumentation
oCstd::__profile::list< _Tp, _Allocator >List wrapper with performance instrumentation
oCstd::__profile::map< _Key, _Tp, _Compare, _Allocator >Class std::map wrapper with performance instrumentation
oCstd::__profile::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap wrapper with performance instrumentation
oCstd::__profile::multiset< _Key, _Compare, _Allocator >Class std::multiset wrapper with performance instrumentation
oCstd::__profile::set< _Key, _Compare, _Allocator >Class std::set wrapper with performance instrumentation
oCstd::__profile::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map wrapper with performance instrumentation
oCstd::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap wrapper with performance instrumentation
oCstd::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Unordered_multiset wrapper with performance instrumentation
oCstd::__profile::unordered_set< _Key, _Hash, _Pred, _Alloc >Unordered_set wrapper with performance instrumentation
oCstd::_Base_bitset< _Nw >
oCstd::_Base_bitset< 0 >
oCstd::_Base_bitset< 1 >
oCstd::_Bind< _Signature >Type of the function object returned from bind()
oCstd::_Bind_result< _Result, _Signature >Type of the function object returned from bind<R>()
oCstd::_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
oCstd::_Deque_iterator< _Tp, _Ref, _Ptr >A deque::iterator
oCstd::_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
oCstd::_Enable_default_constructor< _Switch, _Tag >A mixin helper to conditionally enable or disable the default constructor
oCstd::_Enable_destructor< _Switch, _Tag >A mixin helper to conditionally enable or disable the default destructor
oCstd::_Function_baseBase class of all polymorphic function object wrappers
|\Cstd::function< _Res(_ArgTypes...)>Primary class template for std::function.Polymorphic function wrapper
oCstd::_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
oCstd::_Fwd_list_const_iterator< _Tp >A forward_list::const_iterator
oCstd::_Fwd_list_iterator< _Tp >A forward_list::iterator
oCstd::_Fwd_list_node_baseA 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
oCstd::_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
oCstd::_List_const_iterator< _Tp >A list::const_iterator
oCstd::_List_iterator< _Tp >A list::iterator
oCstd::_Maybe_get_result_type< _Has_result_type, _Functor >If we have found a result_type, extract it
oCstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes >
oCstd::_Maybe_wrap_member_pointer< _Tp >
oCstd::_Maybe_wrap_member_pointer< _Tp _Class::* >
oCstd::_Mu< _Arg, _IsBindExp, _IsPlaceholder >
oCstd::_Mu< _Arg, false, false >
oCstd::_Mu< _Arg, false, true >
oCstd::_Mu< _Arg, true, false >
oCstd::_Mu< reference_wrapper< _Tp >, false, false >
oCstd::_Placeholder< _Num >The type of placeholder objects defined by libstdc++
oCstd::_Reference_wrapper_base_impl< _Unary, _Binary, _Tp >
oCstd::_Safe_tuple_element_impl< __i, _Tuple, false >
oCstd::_Sp_ebo_helper< _Nm, _Tp, false >Specialization not using EBO
oCstd::_Sp_ebo_helper< _Nm, _Tp, true >Specialization using EBO
oCstd::_Temporary_buffer< _ForwardIterator, _Tp >
|\C__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp >
oCstd::_Tuple_impl< _Idx, _Elements >
oCstd::_Tuple_impl< _Idx >
oCstd::_V2::condition_variable_anyCondition_variable_any
oCstd::_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
oCstd::_Weak_result_type_impl< _Res(&)(_ArgTypes...)>Retrieve the result type for a function reference
oCstd::_Weak_result_type_impl< _Res(*)(_ArgTypes...)>Retrieve the result type for a function pointer
oCstd::_Weak_result_type_impl< _Res(_ArgTypes...)>Retrieve the result type for a function type
oCstd::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const >Retrieve result type for a const member function pointer
oCstd::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const volatile >Retrieve result type for a const volatile member function pointer
oCstd::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) volatile >Retrieve result type for a volatile member function pointer
oCstd::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...)>Retrieve result type for a member function pointer
oCstd::adopt_lock_tAssume the calling thread has already obtained mutex ownership and manage it
oCstd::allocator< void >Allocator<void> specialization
oCstd::allocator_arg_t[allocator.tag]
oCstd::allocator_traits< _Alloc >Uniform interface to all allocator types
|\C__gnu_cxx::__alloc_traits< _Alloc >Uniform interface to C++98 and C++0x allocators
oCstd::array< _Tp, _Nm >A standard container for storing a fixed size sequence of elements
oCstd::atomic< _Tp >Generic atomic type, primary class template
oCstd::atomic< _Tp * >Partial specialization for pointer types
oCstd::atomic_boolAtomic_bool
|\Cstd::atomic< bool >Explicit specialization for bool
oCstd::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
oCstd::auto_ptr_ref< _Tp1 >
oCstd::basic_istream< _CharT, _Traits >::sentryPerforms setup work for input streams
oCstd::basic_ostream< _CharT, _Traits >::sentryPerforms setup work for output streams
oCstd::basic_regex< typename, typename >
oCstd::basic_streambuf< _CharT, _Traits >The actual work of input and output (interface)
|oC__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>
|oCstd::basic_filebuf< _CharT, encoding_char_traits< _CharT > >
||\C__gnu_cxx::enc_filebuf< _CharT >Class enc_filebuf
|oCstd::basic_filebuf< char_type, traits_type >
|oCstd::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)
oCstd::basic_string< _CharT, _Traits, _Alloc >Managing sequences of characters and character-like objects
oCstd::bernoulli_distributionA Bernoulli random number distribution
oCstd::bernoulli_distribution::param_type
oCstd::binary_function< _Arg1, _Arg2, _Result >
|\Cstd::pointer_to_binary_function< _Arg1, _Arg2, _Result >One of the adaptors for function pointers
oCstd::binomial_distribution< _IntType >A discrete binomial random number distribution
oCstd::binomial_distribution< _IntType >::param_type
oCstd::cauchy_distribution< _RealType >A cauchy_distribution random number distribution
oCstd::cauchy_distribution< _RealType >::param_type
oCstd::char_traits< __gnu_cxx::character< _Value, _Int, _St > >Char_traits<__gnu_cxx::character> specialization
oCstd::char_traits< char >21.1.3.1 char_traits specializations
oCstd::char_traits< wchar_t >21.1.3.2 char_traits specializations
oCstd::chi_squared_distribution< _RealType >A chi_squared_distribution random number distribution
oCstd::chi_squared_distribution< _RealType >::param_type
oCstd::chrono::_V2::steady_clockMonotonic clock
oCstd::chrono::_V2::system_clockSystem clock
oCstd::chrono::duration< _Rep, _Period >Duration
oCstd::chrono::duration_values< _Rep >Duration_values
oCstd::chrono::time_point< _Clock, _Dur >Time_point
oCstd::codecvt_baseEmpty base class for codecvt facet [22.2.1.5]
|oCstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >
||\Cstd::codecvt< _InternT, _ExternT, encoding_state >Codecvt<InternT, _ExternT, encoding_state> specialization
|oCstd::__codecvt_abstract_base< char, char, mbstate_t >
||\Cstd::codecvt< char, char, mbstate_t >Class codecvt<char, char, mbstate_t> specialization
|oCstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >
||\Cstd::codecvt< wchar_t, char, mbstate_t >Class codecvt<wchar_t, char, mbstate_t> specialization
|\Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >Common base for codecvt functions
| \Cstd::codecvt< _InternT, _ExternT, _StateT >Primary class template codecvt.NB: Generic, mostly useless implementation
|  \Cstd::codecvt_byname< _InternT, _ExternT, _StateT >Class codecvt_byname [22.2.1.6]
oCstd::complex< _Tp >
oCstd::complex< double >26.2.3 complex specializations complex<double> specialization
oCstd::complex< float >26.2.3 complex specializations complex<float> specialization
oCstd::complex< long double >26.2.3 complex specializations complex<long double> specialization
oCstd::condition_variableCondition_variable
oCstd::ctype_baseBase class for ctype
|oCstd::__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
|oCstd::__ctype_abstract_base< _CharT >Common base for ctype facet
||oCstd::ctype< char_type >
||\Cstd::ctype< _CharT >Primary class template ctype facet.This template class defines classification and conversion functions for character sets. It wraps cctype functionality. Ctype gets used by streams for many I/O operations
|| \Cstd::ctype_byname< _CharT >Class ctype_byname [22.2.1.2]
|\Cstd::ctype< char >The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well
| \Cstd::ctype_byname< char >22.2.1.4 Class ctype_byname specializations
oCstd::decimal::decimal1283.2.4 Class decimal128
oCstd::decimal::decimal323.2.2 Class decimal32
oCstd::decimal::decimal643.2.3 Class decimal64
oCstd::default_delete< _Tp >Primary template of default_delete, used by unique_ptr
oCstd::default_delete< _Tp[]>Specialization for arrays, default_delete
oCstd::defer_lock_tDo not acquire ownership of the mutex
oCstd::discard_block_engine< _RandomNumberEngine, __p, __r >
oCstd::discrete_distribution< _IntType >A discrete_distribution random number distribution
oCstd::discrete_distribution< _IntType >::param_type
oCstd::enable_shared_from_this< _Tp >Base class allowing use of member function shared_from_this
oCstd::error_categoryError_category
oCstd::error_codeError_code
oCstd::error_conditionError_condition
oCstd::exceptionBase class for all library exceptions
|oC__gnu_cxx::forced_errorThown by exception safety machinery
|oC__gnu_cxx::recursive_init_errorException thrown by __cxa_guard_acquire.6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) while the object is being initialized, the behavior is undefined
|oCstd::bad_allocException possibly thrown by new.bad_alloc (or classes derived from it) is used to report allocation errors from the throwing forms of new
|oCstd::bad_castThrown during incorrect typecasting.If you attempt an invalid dynamic_cast expression, an instance of this class (or something derived from this class) is thrown
|oCstd::bad_exception
|oCstd::bad_function_callException class thrown when class template function's operator() is called with an empty target
|oCstd::bad_typeidThrown when a NULL pointer in a typeid expression is used
|oCstd::bad_weak_ptrException possibly thrown by shared_ptr
|oCstd::ios_base::failureThese are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
|oCstd::logic_errorOne of two subclasses of exception
||oC__gnu_pbds::container_errorBase class for exceptions
|||oC__gnu_pbds::insert_errorAn 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)
|||oC__gnu_pbds::join_errorA join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps
|||\C__gnu_pbds::resize_errorA container cannot be resized
||oCstd::domain_error
||oCstd::future_errorException type thrown by futures
||oCstd::invalid_argument
||oCstd::length_error
||\Cstd::out_of_range
|\Cstd::runtime_errorOne of two subclasses of exception
| oCstd::overflow_error
| oCstd::range_error
| oCstd::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
| oCstd::system_errorThrown to indicate error code of underlying system
| \Cstd::underflow_error
oCstd::exponential_distribution< _RealType >An exponential continuous distribution for random numbers
oCstd::exponential_distribution< _RealType >::param_type
oCstd::extreme_value_distribution< _RealType >A extreme_value_distribution random number distribution
oCstd::extreme_value_distribution< _RealType >::param_type
oCstd::fisher_f_distribution< _RealType >A fisher_f_distribution random number distribution
oCstd::fisher_f_distribution< _RealType >::param_type
oCstd::fpos< _StateT >Class representing stream positions
oCstd::gamma_distribution< _RealType >A gamma continuous distribution for random numbers
oCstd::gamma_distribution< _RealType >::param_type
oCstd::geometric_distribution< _IntType >A discrete geometric random number distribution
oCstd::geometric_distribution< _IntType >::param_type
oCstd::gsliceClass defining multi-dimensional subset of an array
oCstd::gslice_array< _Tp >Reference to multi-dimensional subset of an array
oCstd::hash< _Tp >Primary class template hash
oCstd::hash< __debug::bitset< _Nb > >Std::hash specialization for bitset
oCstd::hash< __debug::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
oCstd::hash< __gnu_cxx::__u16vstring >Std::hash specialization for __u16vstring
oCstd::hash< __gnu_cxx::__u32vstring >Std::hash specialization for __u32vstring
oCstd::hash< __gnu_cxx::__vstring >Std::hash specialization for __vstring
oCstd::hash< __gnu_cxx::__wvstring >Std::hash specialization for __wvstring
oCstd::hash< __profile::bitset< _Nb > >Std::hash specialization for bitset
oCstd::hash< __profile::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
oCstd::hash< __shared_ptr< _Tp, _Lp > >Std::hash specialization for __shared_ptr
oCstd::hash< _Tp * >Partial specializations for pointer types
oCstd::hash< bool >Explicit specialization for bool
oCstd::hash< char >Explicit specialization for char
oCstd::hash< char16_t >Explicit specialization for char16_t
oCstd::hash< char32_t >Explicit specialization for char32_t
oCstd::hash< double >Specialization for double
oCstd::hash< error_code >Std::hash specialization for error_code
oCstd::hash< float >Specialization for float
oCstd::hash< int >Explicit specialization for int
oCstd::hash< long >Explicit specialization for long
oCstd::hash< long double >Specialization for long double
oCstd::hash< long long >Explicit specialization for long long
oCstd::hash< shared_ptr< _Tp > >Std::hash specialization for shared_ptr
oCstd::hash< short >Explicit specialization for short
oCstd::hash< signed char >Explicit specialization for signed char
oCstd::hash< string >Std::hash specialization for string
oCstd::hash< thread::id >Std::hash specialization for thread::id
oCstd::hash< type_index >Std::hash specialization for type_index
oCstd::hash< u16string >Std::hash specialization for u16string
oCstd::hash< u32string >Std::hash specialization for u32string
oCstd::hash< unique_ptr< _Tp, _Dp > >Std::hash specialization for unique_ptr
oCstd::hash< unsigned char >Explicit specialization for unsigned char
oCstd::hash< unsigned int >Explicit specialization for unsigned int
oCstd::hash< unsigned long >Explicit specialization for unsigned long
oCstd::hash< unsigned long long >Explicit specialization for unsigned long long
oCstd::hash< unsigned short >Explicit specialization for unsigned short
oCstd::hash< wchar_t >Explicit specialization for wchar_t
oCstd::hash< wstring >Std::hash specialization for wstring
oCstd::hash<::bitset< _Nb > >Std::hash specialization for bitset
oCstd::hash<::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
oCstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >
oCstd::indirect_array< _Tp >Reference to arbitrary subset of an array
oCstd::initializer_list< _E >Initializer_list
oCstd::input_iterator_tagMarking input iterators
|\Cstd::forward_iterator_tagForward iterators support a superset of input iterator operations
| \Cstd::bidirectional_iterator_tagBidirectional iterators support a superset of forward iterator operations
|  \Cstd::random_access_iterator_tagRandom-access iterators support a superset of bidirectional iterator operations
oCstd::integral_constant< _Tp, __v >Integral_constant
|oCstd::is_array< typename >Is_array
|oCstd::is_bind_expression< _Tp >Determines if the given type _Tp is a function object should be treated as a subexpression when evaluating calls to function objects returned by bind(). [TR1 3.6.1]
|oCstd::is_bind_expression< _Bind< _Signature > >Class template _Bind is always a bind expression
|oCstd::is_bind_expression< _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
|oCstd::is_bind_expression< const _Bind< _Signature > >Class template _Bind is always a bind expression
|oCstd::is_bind_expression< const _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
|oCstd::is_bind_expression< const volatile _Bind< _Signature > >Class template _Bind is always a bind expression
|oCstd::is_bind_expression< const volatile _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
|oCstd::is_bind_expression< volatile _Bind< _Signature > >Class template _Bind is always a bind expression
|oCstd::is_bind_expression< volatile _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
|oCstd::is_const< typename >Is_const
|oCstd::is_error_code_enum< _Tp >Is_error_code_enum
|oCstd::is_error_code_enum< future_errc >Specialization
|oCstd::is_error_condition_enum< _Tp >Is_error_condition_enum
|oCstd::is_function< typename >Is_function
|oCstd::is_integral< _Tp >Is_integral
|oCstd::is_lvalue_reference< typename >Is_lvalue_reference
|oCstd::is_member_function_pointer< _Tp >Is_member_function_pointer
|oCstd::is_member_pointer< typename >Is_member_pointer
|oCstd::is_object< _Tp >Is_object
|oCstd::is_rvalue_reference< typename >Is_rvalue_reference
|oCstd::is_void< _Tp >Is_void
|oCstd::is_volatile< typename >Is_volatile
|\Cstd::uses_allocator< tuple< _Types...>, _Alloc >Partial specialization for tuples
oCstd::ios_baseThe 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)
|oCstd::basic_ios< char, char_traits< char > >
||oCstd::basic_istream< char >
||oCstd::basic_istream< char, char_traits< char > >
|||\Cstd::basic_iostream< char >
||oCstd::basic_ostream< char >
||\Cstd::basic_ostream< char, char_traits< char > >
|| \Cstd::basic_iostream< char >
|\Cstd::basic_ios< _CharT, _Traits >Template class basic_ios, virtual base class for all stream classes
| oCstd::basic_istream< _CharT, _Traits >Template class basic_istream
| |oCstd::basic_ifstream< _CharT, _Traits >Controlling input for files
| |oCstd::basic_iostream< _CharT, _Traits >Template class basic_iostream
| ||oCstd::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
|  oCstd::basic_iostream< _CharT, _Traits >Template class basic_iostream
|  oCstd::basic_ofstream< _CharT, _Traits >Controlling output for files
|  \Cstd::basic_ostringstream< _CharT, _Traits, _Alloc >Controlling output for std::string
oCstd::is_arithmetic< _Tp >Is_arithmetic
oCstd::is_floating_point< _Tp >Is_floating_point
oCstd::is_fundamental< _Tp >Is_fundamental
oCstd::is_member_object_pointer< _Tp >Is_member_object_pointer
oCstd::is_null_pointer< _Tp >Is_null_pointer (LWG 2247)
|\Cstd::__is_nullptr_t< _Tp >__is_nullptr_t (extension)
oCstd::is_pointer< _Tp >Is_pointer
oCstd::is_reference< _Tp >Is_reference
oCstd::is_scalar< _Tp >Is_scalar
oCstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >Common iterator class
oCstd::iterator_traits< _Tp * >Partial specialization for pointer types
oCstd::iterator_traits< const _Tp * >Partial specialization for const pointer types
oCstd::linear_congruential_engine< _UIntType, __a, __c, __m >A model of a linear congruential random number generator
oCstd::localeContainer 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
oCstd::locale::facetLocalization 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
|oCstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >
|oCstd::__codecvt_abstract_base< char, char, mbstate_t >
|oCstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >
|oCstd::__ctype_abstract_base< wchar_t >
|oCstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >Common base for codecvt functions
|oCstd::__ctype_abstract_base< _CharT >Common base for ctype facet
|oCstd::collate< _CharT >Facet for localized string comparison
||\Cstd::collate_byname< _CharT >Class collate_byname [22.2.4.2]
|oCstd::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
|oCstd::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]
|oCstd::money_get< _CharT, _InIter >Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
|oCstd::money_put< _CharT, _OutIter >Primary class template money_put.This facet encapsulates the code to format and output a monetary amount
|oCstd::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]
|oCstd::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
|oCstd::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
|oCstd::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]
|oCstd::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]
oCstd::locale::idFacet 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
oCstd::lock_guard< _Mutex >Scoped lock idiom
oCstd::lognormal_distribution< _RealType >A lognormal_distribution random number distribution
oCstd::lognormal_distribution< _RealType >::param_type
oCstd::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
oCstd::mask_array< _Tp >Reference to selected subset of an array
oCstd::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f >
oCstd::messages_baseMessages 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
oCstd::money_baseMoney 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
oCstd::move_iterator< _Iterator >
oCstd::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
oCstd::multiset< _Key, _Compare, _Alloc >A standard container made up of elements, which can be retrieved in logarithmic time
oCstd::mutexMutex
oCstd::negative_binomial_distribution< _IntType >A negative_binomial_distribution random number distribution
oCstd::negative_binomial_distribution< _IntType >::param_type
oCstd::nested_exceptionException class with exception_ptr data member
oCstd::normal_distribution< _RealType >A normal continuous distribution for random numbers
oCstd::normal_distribution< _RealType >::param_type
oCstd::numeric_limits< bool >Numeric_limits<bool> specialization
oCstd::numeric_limits< char >Numeric_limits<char> specialization
oCstd::numeric_limits< char16_t >Numeric_limits<char16_t> specialization
oCstd::numeric_limits< char32_t >Numeric_limits<char32_t> specialization
oCstd::numeric_limits< double >Numeric_limits<double> specialization
oCstd::numeric_limits< float >Numeric_limits<float> specialization
oCstd::numeric_limits< int >Numeric_limits<int> specialization
oCstd::numeric_limits< long >Numeric_limits<long> specialization
oCstd::numeric_limits< long double >Numeric_limits<long double> specialization
oCstd::numeric_limits< long long >Numeric_limits<long long> specialization
oCstd::numeric_limits< short >Numeric_limits<short> specialization
oCstd::numeric_limits< signed char >Numeric_limits<signed char> specialization
oCstd::numeric_limits< unsigned char >Numeric_limits<unsigned char> specialization
oCstd::numeric_limits< unsigned int >Numeric_limits<unsigned int> specialization
oCstd::numeric_limits< unsigned long >Numeric_limits<unsigned long> specialization
oCstd::numeric_limits< unsigned long long >Numeric_limits<unsigned long long> specialization
oCstd::numeric_limits< unsigned short >Numeric_limits<unsigned short> specialization
oCstd::numeric_limits< wchar_t >Numeric_limits<wchar_t> specialization
oCstd::once_flagOnce_flag
oCstd::output_iterator_tagMarking output iterators
oCstd::owner_less< _Tp >Primary template owner_less
oCstd::owner_less< shared_ptr< _Tp > >Partial specialization of owner_less for shared_ptr
oCstd::owner_less< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
oCstd::pair< _T1, _T2 >Struct holding two objects of arbitrary type
oCstd::piecewise_constant_distribution< _RealType >A piecewise_constant_distribution random number distribution
oCstd::piecewise_constant_distribution< _RealType >::param_type
oCstd::piecewise_construct_tPiecewise_construct_t
oCstd::piecewise_linear_distribution< _RealType >A piecewise_linear_distribution random number distribution
oCstd::piecewise_linear_distribution< _RealType >::param_type
oCstd::pointer_traits< _Ptr >Uniform interface to all pointer-like types
oCstd::pointer_traits< _Tp * >Partial specialization for built-in pointers
oCstd::poisson_distribution< _IntType >A discrete Poisson random number distribution
oCstd::poisson_distribution< _IntType >::param_type
oCstd::priority_queue< _Tp, _Sequence, _Compare >A standard container automatically sorting its contents
oCstd::queue< _Tp, _Sequence >A standard container giving FIFO behavior
oCstd::random_device
oCstd::ratio< _Num, _Den >Provides compile-time rational arithmetic
oCstd::recursive_mutexRecursive_mutex
oCstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >
oCstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >
oCstd::regex_traits< _Ch_type >Describes aspects of a regular expression
oCstd::scoped_allocator_adaptor< _OuterAlloc, _InnerAllocs >Primary class template
oCstd::seed_seqGenerates sequences of seeds for random number generators
oCstd::set< _Key, _Compare, _Alloc >A standard container made up of unique keys, which can be retrieved in logarithmic time
oCstd::shared_ptr< _Tp >A smart pointer with reference-counted copy semantics
oCstd::shuffle_order_engine< _RandomNumberEngine, __k >Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits __w
oCstd::sliceClass defining one-dimensional subset of an array
oCstd::slice_array< _Tp >Reference to one-dimensional subset of an array
oCstd::stack< _Tp, _Sequence >A standard container giving FILO behavior
oCstd::student_t_distribution< _RealType >A student_t_distribution random number distribution
oCstd::student_t_distribution< _RealType >::param_type
oCstd::threadThread
oCstd::thread::idThread::id
oCstd::time_baseTime 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
oCstd::tr2::__dynamic_bitset_base< _WordT, _Alloc >
|\Cstd::tr2::dynamic_bitset< _WordT, _Alloc >The dynamic_bitset class represents a sequence of bits
oCstd::tr2::__reflection_typelist< _Elements >
oCstd::tr2::__reflection_typelist< _First, _Rest...>Partial specialization
oCstd::tr2::__reflection_typelist<>Specialization for an empty typelist
oCstd::tr2::bases< _Tp >Sequence abstraction metafunctions for manipulating a typelist
oCstd::tr2::bool_set
oCstd::tr2::direct_bases< _Tp >Enumerate all the direct base classes of a class. Form of a typelist
oCstd::tr2::dynamic_bitset< _WordT, _Alloc >::reference
oCstd::try_to_lock_tTry to acquire ownership of the mutex without blocking
oCstd::tuple_element< _Int, _Tp >Tuple_element
oCstd::tuple_element< 0, tuple< _Head, _Tail...> >
oCstd::tuple_size< _Tp >Tuple_size
oCstd::type_indexClass 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)
oCstd::type_infoPart of RTTI
oCstd::unary_function< _Arg, _Result >
|oC__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 >An SGI extension
|oC__gnu_cxx::subtractive_rng
|oC__gnu_cxx::unary_compose< _Operation1, _Operation2 >An SGI extension
|\Cstd::pointer_to_unary_function< _Arg, _Result >One of the adaptors for function pointers
oCstd::uniform_int_distribution< _IntType >Uniform discrete distribution for random numbers. A discrete random distribution on the range $[min, max]$ with equal probability throughout the range
oCstd::uniform_int_distribution< _IntType >::param_type
oCstd::uniform_real_distribution< _RealType >Uniform continuous distribution for random numbers
oCstd::uniform_real_distribution< _RealType >::param_type
oCstd::unique_lock< _Mutex >Unique_lock
oCstd::unique_ptr< _Tp, _Dp >20.7.1.2 unique_ptr for single objects
oCstd::unique_ptr< _Tp[], _Dp >20.7.1.3 unique_ptr for array objects with a runtime length
oCstd::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
oCstd::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
oCstd::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
oCstd::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
oCstd::valarray< _Tp >Smart array designed to support numeric processing
oCstd::vector< bool, _Alloc >A specialization of vector for booleans which offers fixed time access to individual elements in any order
oCstd::weak_ptr< _Tp >A smart pointer with weak semantics
oCstd::weibull_distribution< _RealType >A weibull_distribution random number distribution
oCstd::weibull_distribution< _RealType >::param_type
oCstd::tuple_element< __i, _Tuple >
|oCstd::_Safe_tuple_element_impl< __i, _Tuple,(__i< tuple_size< _Tuple >::value)>
||\Cstd::_Safe_tuple_element< __i, _Tuple >
|\Cstd::_Safe_tuple_element_impl< __i, _Tuple, _IsSafe >
oCstd::tuple_element< __i-1, tuple< _Tail...> >
|\Cstd::tuple_element< __i, tuple< _Head, _Tail...> >
oCstd::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
oCstd::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
oCstd::unary_function< _FirstArgumentType, _ResultType >
|\C__gnu_parallel::__binder2nd< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder2nd, but giving the argument types explicitly
oCstd::unary_function< _Functor::argument_type, _Functor::result_type >
oCstd::unary_function< _Operation2::argument_type, _Operation1::result_type >
oCstd::unary_function< _Operation::first_argument_type, _Operation::result_type >
|\Cstd::binder2nd< _Operation >One of the binder functors
oCstd::unary_function< _Operation::second_argument_type, _Operation::result_type >
|\Cstd::binder1st< _Operation >One of the binder functors
oCstd::unary_function< _Pair, _Pair::first_type >
oCstd::unary_function< _Pair, _Pair::second_type >
oCstd::unary_function< _Predicate::argument_type, bool >
|\Cstd::unary_negate< _Predicate >One of the negation functors
oCstd::unary_function< _SecondArgumentType, _ResultType >
|\C__gnu_parallel::__binder1st< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder1st, but giving the argument types explicitly
oCstd::unary_function< _T1 *, _Res >
oCstd::unary_function< _T1, _Res >
|\Cstd::_Maybe_unary_or_binary_function< _Res, _T1 >Derives from unary_function, as appropriate
oCstd::unary_function< _Tp *, _Ret >
|\Cstd::mem_fun_t< _Ret, _Tp >One of the adaptors for member pointers
oCstd::unary_function< _Tp, _Ret >
|oCstd::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
oCstd::unary_function< _Tp, _Tp >
|\Cstd::negate< _Tp >One of the math functors
oCstd::unary_function< _Tp, bool >
|\Cstd::logical_not< _Tp >One of the Boolean operations functors
oCstd::unary_function< _Value, _Value >
oCstd::unary_function< argument_type, bool >
|\C__gnu_parallel::__unary_negate< _Predicate, argument_type >Similar to std::unary_negate, but giving the argument types explicitly
oCstd::unary_function< const _T1 *, _Res >
oCstd::unary_function< const _Tp *, _Ret >
|\Cstd::const_mem_fun_t< _Ret, _Tp >One of the adaptors for member pointers
oCstd::unary_function< const volatile _T1 *, _Res >
oCstd::unary_function< pair< const _Key, _Tp >, pair< const _Key, _Tp >::first_type >
oCstd::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
oCstd::unary_function< unsigned int, unsigned int >
oCstd::unary_function< volatile _T1 *, _Res >
oCstd::unique_ptr< std::vector< bool > >
oCstd::unique_ptr< std::vector< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > > > >
oCstd::valarray< _Dom::value_type >
\Cstd::valarray< size_t >