Class Hierarchy

Go to the graphical class hierarchy

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

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