Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

__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 | GNU extensions for public use
__detail | Implementation details not part of the namespace __gnu_cxx interface
__mini_vector | __mini_vector<> is a stripped down version of the full-fledged std::vector<>
_Bitmap_counter | 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
_Ffit_finder | The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
__alloc_traits | Uniform interface to C++98 and C++11 allocators
__common_pool_policy | Policy for shared __pool objects
__mt_alloc | 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
__mt_alloc_base | Base class for _Tp dependent member functions
__per_type_pool_policy | Policy for individual __pool objects
__pool | Data describing the underlying memory pool, parameterized on threading support
__pool< false > | Specialization for single thread
__pool< true > | Specialization for thread enabled, via gthreads.h
__pool_alloc | Allocator using a memory pool with a single lock
__pool_alloc_base | Base class for __pool_alloc
__pool_base | Base class for pool object
__rc_string_base |
__scoped_lock | Scoped lock idiom
__versa_string | Template class __versa_string.Data structure managing sequences of characters and character-like objects
_Caster |
_Char_types | Mapping from character type to associated types
_ExtPtr_allocator | 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
_Invalid_type |
_Pointer_adapter |
_Relative_pointer_impl | 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
_Relative_pointer_impl< const _Tp > |
_Std_pointer_impl | A storage policy for use with _Pointer_adapter<> which yields a standard pointer
_Unqualified_type |
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
array_allocator | An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
array_allocator_base | Base class
binary_compose | An SGI extension
bitmap_allocator | Bitmap Allocator, primary template
char_traits | Base class used to implement std::char_traits
character | A POD class that serves as a character abstraction class
condition_base | Base struct for condition policy
constant_binary_fun | An SGI extension
constant_unary_fun | An SGI extension
constant_void_fun | An SGI extension
debug_allocator | A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard
enc_filebuf | Class enc_filebuf
encoding_char_traits | Encoding_char_traits
encoding_state | Extension to use iconv for dealing with character encodings
forced_error | Thown by exception safety machinery
free_list | The free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
hash_map |
hash_multimap |
hash_multiset |
hash_set |
limit_condition | Base class for incremental control and throw
always_adjustor | Always enter the condition
limit_adjustor | Enter the nth condition
never_adjustor | Never enter the condition
malloc_allocator | An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
new_allocator | An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard
project1st | An SGI extension
project2nd | An SGI extension
random_condition | Base class for random probability control and throw
always_adjustor | Always enter the condition
group_adjustor | Group condition
never_adjustor | Never enter the condition
rb_tree |
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
rope |
select1st | An SGI extension
select2nd | An SGI extension
slist |
stdio_filebuf | 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>
stdio_sync_filebuf | 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>
subtractive_rng |
temporary_buffer |
throw_allocator_base | 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
throw_allocator_limit | Allocator throwing via limit condition
throw_allocator_random | Allocator throwing via random condition
throw_value_base | Class with exception generation control. Intended to be used as a value_type in templatized code
throw_value_limit | Type throwing via limit condition
throw_value_random | Type throwing via random condition
unary_compose | An SGI extension
__gnu_debug | GNU debug classes for public use
_After_nth_from |
_BeforeBeginHelper |
_Equal_to |
_Not_equal_to |
_Safe_container | Safe class dealing with some allocator dependent operations
_Safe_forward_list | Special iterators swap and invalidation for forward_list because of the before_begin iterator
_Safe_iterator | Safe iterator wrapper
_Safe_iterator_base | Basic functionality for a safe iterator
_Safe_local_iterator | Safe iterator wrapper
_Safe_local_iterator_base | Basic functionality for a safe iterator
_Safe_node_sequence | Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence
_Safe_sequence | Base class for constructing a safe sequence type that tracks iterators that reference it
_Safe_sequence_base | Base class that supports tracking of iterators that reference a sequence
_Safe_unordered_container | Base class for constructing a safe unordered container type that tracks iterators that reference it
_Safe_unordered_container_base | Base class that supports tracking of local iterators that reference an unordered container
_Safe_vector | Base class for Debug Mode vector
_Sequence_traits |
basic_string | Class std::basic_string with safety/checking/debug instrumentation
__gnu_parallel | GNU parallel code for public use
__accumulate_binop_reduct | General reduction, using a binary operator
__accumulate_selector | Std::accumulate() selector
__adjacent_difference_selector | Selector that returns the difference between two adjacent __elements
__adjacent_find_selector | Test predicate on two adjacent elements
__binder1st | Similar to std::binder1st, but giving the argument types explicitly
__binder2nd | Similar to std::binder2nd, but giving the argument types explicitly
__count_if_selector | Std::count_if () selector
__count_selector | Std::count() selector
__fill_selector | Std::fill() selector
__find_first_of_selector | Test predicate on several elements
__find_if_selector | Test predicate on a single element, used for std::find() and std::find_if ()
__for_each_selector | Std::for_each() selector
__generate_selector | Std::generate() selector
__generic_find_selector | Base class of all __gnu_parallel::__find_template selectors
__generic_for_each_selector | Generic __selector for embarrassingly parallel functions
__identity_selector | Selector that just returns the passed iterator
__inner_product_selector | Std::inner_product() selector
__max_element_reduct | Reduction for finding the maximum element, using a comparator
__min_element_reduct | Reduction for finding the maximum element, using a comparator
__mismatch_selector | Test inverted predicate on a single element
__multiway_merge_3_variant_sentinel_switch | Switch for 3-way merging with __sentinels turned off
__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 3-way merging with __sentinels turned on
__multiway_merge_4_variant_sentinel_switch | Switch for 4-way merging with __sentinels turned off
__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 4-way merging with __sentinels turned on
__multiway_merge_k_variant_sentinel_switch | Switch for k-way merging with __sentinels turned on
__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for k-way merging with __sentinels turned off
__replace_if_selector | Std::replace() selector
__replace_selector | Std::replace() selector
__transform1_selector | Std::transform() __selector, one input sequence variant
__transform2_selector | Std::transform() __selector, two input sequences variant
__unary_negate | Similar to std::unary_negate, but giving the argument types explicitly
_DRandomShufflingGlobalData | Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
_DRSSorterPU | Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
_DummyReduct | Reduction function doing nothing
_EqualFromLess | Constructs predicate for equality from strict weak ordering predicate
_EqualTo | Similar to std::equal_to, but allows two different types
_GuardedIterator | _Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
_IteratorPair | A pair of iterators. The usual iterator operations are applied to both child iterators
_IteratorTriple | A triple of iterators. The usual iterator operations are applied to all three child iterators
_Job | One __job for a certain thread
_Less | Similar to std::less, but allows two different types
_Lexicographic | Compare __a pair of types lexicographically, ascending
_LexicographicReverse | Compare __a pair of types lexicographically, descending
_LoserTree | Stable _LoserTree variant
_LoserTree< false, _Tp, _Compare > | Unstable _LoserTree variant
_LoserTreeBase | Guarded loser/tournament tree
_Loser | Internal representation of a _LoserTree element
_LoserTreePointer | Stable _LoserTree implementation
_LoserTreePointer< false, _Tp, _Compare > | Unstable _LoserTree implementation
_LoserTreePointerBase | Base class of _Loser Tree implementation using pointers
_Loser | Internal representation of _LoserTree __elements
_LoserTreePointerUnguarded | Stable unguarded _LoserTree variant storing pointers
_LoserTreePointerUnguarded< false, _Tp, _Compare > | Unstable unguarded _LoserTree variant storing pointers
_LoserTreePointerUnguardedBase | Unguarded loser tree, keeping only pointers to the elements in the tree structure
_LoserTreeTraits | Traits for determining whether the loser tree should use pointers or copies
_LoserTreeUnguarded | Stable implementation of unguarded _LoserTree
_LoserTreeUnguarded< false, _Tp, _Compare > | Non-Stable implementation of unguarded _LoserTree
_LoserTreeUnguardedBase | Base class for unguarded _LoserTree implementation
_Multiplies | Similar to std::multiplies, but allows two different types
_Nothing | Functor doing nothing
_Piece | Subsequence description
_Plus | Similar to std::plus, but allows two different types
_PMWMSSortingData | Data accessed by all threads
_PseudoSequence | Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
_PseudoSequenceIterator | _Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
_QSBThreadLocal | Information local to one thread in the parallel quicksort run
_RandomNumber | Random number generator, based on the Mersenne twister
_RestrictedBoundedConcurrentQueue | 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
_SamplingSorter | Stable sorting functor
_SamplingSorter< false, _RAIter, _StrictWeakOrdering > | Non-__stable sorting functor
_Settings | Class _Settings Run-time settings for the parallel mode including all tunable parameters
_SplitConsistently | Split consistently
_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator > | Split by sampling
_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator > | Split by exact splitting
balanced_quicksort_tag | Forces parallel sorting using balanced quicksort at compile time
balanced_tag | Recommends parallel execution using dynamic load-balancing at compile time
constant_size_blocks_tag | Selects the constant block size variant for std::find()
default_parallel_tag | Recommends parallel execution using the default parallel algorithm
equal_split_tag | Selects the equal splitting variant for std::find()
exact_tag | Forces parallel merging with exact splitting, at compile time
find_tag | Base class for for std::find() variants
growing_blocks_tag | Selects the growing block size variant for std::find()
multiway_mergesort_exact_tag | Forces parallel sorting using multiway mergesort with exact splitting at compile time
multiway_mergesort_sampling_tag | Forces parallel sorting using multiway mergesort with splitting by sampling at compile time
multiway_mergesort_tag | Forces parallel sorting using multiway mergesort at compile time
omp_loop_static_tag | Recommends parallel execution using OpenMP static load-balancing at compile time
omp_loop_tag | Recommends parallel execution using OpenMP dynamic load-balancing at compile time
parallel_tag | Recommends parallel execution at compile time, optionally using a user-specified number of threads
quicksort_tag | Forces parallel sorting using unbalanced quicksort at compile time
sampling_tag | Forces parallel merging with exact splitting, at compile time
sequential_tag | Forces sequential execution at compile time
unbalanced_tag | Recommends parallel execution using static load-balancing at compile time
__gnu_pbds | GNU extensions for policy-based data structures for public use
detail |
bin_search_tree_const_it_ | Const iterator
bin_search_tree_const_node_it_ | Const node iterator
bin_search_tree_it_ | Iterator
bin_search_tree_node_it_ | Node iterator
bin_search_tree_traits | Binary search tree traits, primary template
bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc > | Specialization
binary_heap |
binary_heap_const_iterator_ | Const point-type iterator
binary_heap_point_const_iterator_ | Const point-type iterator
binomial_heap |
binomial_heap_base | Base class for binomial heap
branch_policy | Primary template, base class for branch structure policies
branch_policy< Node_CItr, Node_CItr, _Alloc > | Specialization for const iterators
cc_ht_map |
cond_dealtor | Conditional deallocate constructor argument
container_base_dispatch | Dispatch mechanism, primary template for associative types
container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type > | Specialization for binary_heap
container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type > | Specialization for binomial_heap
container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type > | Specialization for pairing_heap
container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type > | Specialization for rc_binary_heap
container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type > | Specialization for thin_heap
container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl > | Specialization colision-chaining hash map
container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash map
container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update map
container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree map
container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie map
container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree map
container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree map
container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl > | Specialization colision-chaining hash set
container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash set
container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update set
container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree set
container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie set
container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree set
container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree set
default_comb_hash_fn | Primary template, default_comb_hash_fn
default_eq_fn | Primary template, default_eq_fn
default_hash_fn | Primary template, default_hash_fn
default_probe_fn | Primary template, default_probe_fn
default_resize_policy | Primary template, default_resize_policy
default_trie_access_traits | Primary template, default_trie_access_traits
default_trie_access_traits< std::basic_string | Partial specialization, default_trie_access_traits
default_update_policy | Default update policy
dumnode_const_iterator | Constant node iterator
entry_cmp | Entry compare, primary template
entry_cmp< _VTp, Cmp_Fn, _Alloc, false > | Specialization, false
type | Compare plus entry
entry_cmp< _VTp, Cmp_Fn, _Alloc, true > | Specialization, true
entry_pred | Entry predicate primary class template
entry_pred< _VTp, Pred, _Alloc, false > | Specialization, false
entry_pred< _VTp, Pred, _Alloc, true > | Specialization, true
eq_by_less | Equivalence function
gp_ht_map |
hash_eq_fn | Primary template
hash_eq_fn< Key, Eq_Fn, _Alloc, false > | Specialization 1 - The client requests that hash values not be stored
hash_eq_fn< Key, Eq_Fn, _Alloc, true > | Specialization 2 - The client requests that hash values be stored
hash_load_check_resize_trigger_size_base | Primary template
hash_load_check_resize_trigger_size_base< Size_Type, true > | Specializations
left_child_next_sibling_heap | Base class for a basic heap
left_child_next_sibling_heap_const_iterator_ | Const point-type iterator
left_child_next_sibling_heap_node_ | Node
left_child_next_sibling_heap_node_point_const_iterator_ | Const point-type iterator
lu_counter_metadata | A list-update metadata type that moves elements to the front of the list based on the counter algorithm
lu_counter_policy_base | Base class for list-update counter policy
lu_map | List-based (with updates) associative container. Skip to the lu, my darling
mask_based_range_hashing | Range hashing policy
mod_based_range_hashing | Mod based range hashing
no_throw_copies | Primary template
no_throw_copies< Key, null_type > | Specialization
ov_tree_map | Ordered-vector tree associative-container
cond_dtor | Conditional destructor
ov_tree_node_const_it_ | Const node reference
ov_tree_node_it_ | Node reference
pairing_heap |
pat_trie_base | Base type for PATRICIA trees
_CIter | Const iterator
_Head | Head node for PATRICIA tree
_Inode | Internal node type, PATRICIA tree
const_iterator | Constant child iterator
iterator | Child iterator
_Iter | Iterator
_Leaf | Leaf node for PATRICIA tree
_Metadata | Metadata base primary template
_Metadata< null_type, _Alloc > | Specialization for null metadata
_Node_base | Node base
_Node_citer | Node const iterator
_Node_iter | Node iterator
pat_trie_map | 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
probe_fn_base | Probe functor base
ranged_hash_fn | Primary template
ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false > |
ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true > |
ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false > |
ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true > |
ranged_probe_fn | Primary template
ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false > |
ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true > |
ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false > |
rb_tree_map | Red-Black tree.This implementation uses an idea from the SGI STL (using a header node which is needed for efficient iteration)
rb_tree_node_ | Node for Red-Black trees
rc | Redundant binary counter
rc_binomial_heap |
resize_policy | Resize policy for binary heap
splay_tree_map | Splay tree
splay_tree_node_ | Node for splay tree
stored_data | Primary template for representation of stored data. Two types of data can be stored: value and hash
stored_data< _Tv, null_type > | Specialization for representation of stored data of just value type
stored_hash | Stored hash
stored_value | Stored value
synth_access_traits | Synthetic element access traits
thin_heap |
tree_metadata_helper | Tree metadata helper
tree_metadata_helper< Node_Update, false > | Specialization, false
tree_metadata_helper< Node_Update, true > | Specialization, true
tree_node_metadata_dispatch | Tree node metadata dispatch
tree_traits | Tree traits class, primary template
tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Tree traits
tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization
tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization
tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Specialization
tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization
tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization
trie_metadata_helper | Trie metadata helper
trie_metadata_helper< Node_Update, false > | Specialization, false
trie_metadata_helper< Node_Update, true > | Specialization, true
trie_node_metadata_dispatch | Trie node metadata dispatch
trie_policy_base | Base class for trie policies
trie_traits | Trie traits class, primary template
trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization
trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization
type_base | Primary template
type_base< Key, Mapped, _Alloc, false > |
type_base< Key, Mapped, _Alloc, true > |
type_base< Key, null_type, _Alloc, false > |
type_base< Key, null_type, _Alloc, true > |
type_dispatch | Type base dispatch
types_traits | Traits for abstract types
associative_tag | Basic associative-container
basic_branch |
basic_branch_tag | Basic branch structure
basic_hash_table |
basic_hash_tag | Basic hash structure
basic_invalidation_guarantee |
binary_heap_tag | Binary-heap (array-based)
binomial_heap_tag | Binomial-heap
cc_hash_max_collision_check_resize_trigger | A resize trigger policy based on collision checks. It keeps the simulated load factor lower than some given load factor
cc_hash_table |
cc_hash_tag | Collision-chaining hash
container_error | Base class for exceptions
container_tag | Base data structure tag
container_traits | Container traits
container_traits_base | Primary template, container traits base
container_traits_base< binary_heap_tag > | Specialization, binary heap
container_traits_base< binomial_heap_tag > | Specialization, binomial heap
container_traits_base< cc_hash_tag > | Specialization, cc hash
container_traits_base< gp_hash_tag > | Specialization, gp hash
container_traits_base< list_update_tag > | Specialization, list update
container_traits_base< ov_tree_tag > | Specialization, ov tree
container_traits_base< pairing_heap_tag > | Specialization, pairing heap
container_traits_base< pat_trie_tag > | Specialization, pat trie
container_traits_base< rb_tree_tag > | Specialization, rb tree
container_traits_base< rc_binomial_heap_tag > | Specialization, rc binomial heap
container_traits_base< splay_tree_tag > | Specialization, splay tree
container_traits_base< thin_heap_tag > | Specialization, thin heap
direct_mask_range_hashing | A mask range-hashing class (uses a bitmask)
direct_mod_range_hashing | A mod range-hashing class (uses the modulo function)
gp_hash_table |
gp_hash_tag | General-probing hash
hash_exponential_size_policy | A size policy whose sequence of sizes form an exponential sequence (typically powers of 2
hash_load_check_resize_trigger | A resize trigger policy based on a load check. It keeps the load factor between some load factors load_min and load_max
hash_prime_size_policy | A size policy whose sequence of sizes form a nearly-exponential sequence of primes
hash_standard_resize_policy | A resize policy which delegates operations to size and trigger policies
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)
join_error | A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps
linear_probe_fn | A probe sequence policy using fixed increments
list_update |
list_update_tag | List-update
lu_counter_policy |
lu_move_to_front_policy |
null_node_update | A null node updator, indicating that no node updates are required
null_type | Represents no type, or absence of type, for template tricks
ov_tree_tag | Ordered-vector tree
pairing_heap_tag | Pairing-heap
pat_trie_tag | PATRICIA trie
point_invalidation_guarantee |
priority_queue |
priority_queue_tag | Basic priority-queue
quadratic_probe_fn | A probe sequence policy using square increments
range_invalidation_guarantee |
rb_tree_tag | Red-black tree
rc_binomial_heap_tag | Redundant-counter binomial-heap
resize_error | A container cannot be resized
sample_probe_fn | A sample probe policy
sample_range_hashing | A sample range-hashing functor
sample_ranged_hash_fn | A sample ranged-hash functor
sample_ranged_probe_fn | A sample ranged-probe functor
sample_resize_policy | A sample resize policy
sample_resize_trigger | A sample resize trigger policy
sample_size_policy | A sample size policy
sample_tree_node_update | A sample node updator
sample_trie_access_traits | A sample trie element access traits
sample_trie_node_update | A sample node updator
sample_update_policy | A sample list-update policy
sequence_tag | Basic sequence
splay_tree_tag | Splay tree
string_tag | Basic string container, inclusive of strings, ropes, etc
thin_heap_tag | Thin heap
tree |
tree_order_statistics_node_update | Functor updating ranks of entrees
tree_tag | Basic tree structure
trie |
trie_order_statistics_node_update | Functor updating ranks of entrees
trie_prefix_search_node_update | A node updator that allows tries to be searched for the range of values that match a certain prefix
trie_string_access_traits |
trie_tag | Basic trie structure
trivial_iterator_tag | A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
__gnu_profile | GNU profile code for public use
__container_size_info | A container size instrumentation line in the object table
__container_size_stack_info | A container size instrumentation line in the stack table
__hashfunc_info | A hash performance instrumentation line in the object table
__hashfunc_stack_info | A hash performance instrumentation line in the stack table
__list2vector_info | A list-to-vector instrumentation line in the object table
__map2umap_info | A map-to-unordered_map instrumentation line in the object table
__map2umap_stack_info | A map-to-unordered_map instrumentation line in the stack table
__object_info_base | Base class for a line in the object table
__reentrance_guard | Reentrance guard
__stack_hash | Hash function for summary trace using call stack as index
__trace_base | Base class for all trace producers
__trace_container_size | Container size instrumentation trace producer
__trace_hash_func | Hash performance instrumentation producer
__trace_hashtable_size | Hashtable size instrumentation trace producer
__trace_map2umap | Map-to-unordered_map instrumentation producer
__trace_vector_size | Hashtable size instrumentation trace producer
__trace_vector_to_list | Vector-to-list instrumentation producer
__vector2list_info | A vector-to-list instrumentation line in the object table
__vector2list_stack_info | A vector-to-list instrumentation line in the stack table
__warning_data | Representation of a warning
std | ISO C++ entities toplevel namespace is std
__debug | GNU debug code, replaces standard behavior with debug behavior
bitset | Class std::bitset with additional safety/checking/debug instrumentation
deque | Class std::deque with safety/checking/debug instrumentation
forward_list | Class std::forward_list with safety/checking/debug instrumentation
list | Class std::list with safety/checking/debug instrumentation
map | Class std::map with safety/checking/debug instrumentation
multimap | Class std::multimap with safety/checking/debug instrumentation
multiset | Class std::multiset with safety/checking/debug instrumentation
set | Class std::set with safety/checking/debug instrumentation
unordered_map | Class std::unordered_map with safety/checking/debug instrumentation
unordered_multimap | Class std::unordered_multimap with safety/checking/debug instrumentation
unordered_multiset | Class std::unordered_multiset with safety/checking/debug instrumentation
unordered_set | Class std::unordered_set with safety/checking/debug instrumentation
vector | Class std::vector with safety/checking/debug instrumentation
__detail | Implementation details not part of the namespace std interface
_BracketMatcher | Matches a character range (bracket expression)
_Compiler | Builds an NFA from an input iterator range
_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
_Equal_helper |
_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, false > | Specialization
_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, true > | Specialization
_Equality |
_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Specialization
_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Specialization
_Equality_base |
_Executor | Takes a regex and an input string and does the matching
_Hash_code_base |
_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
_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
_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
_Hash_node |
_Hash_node< _Value, false > |
_Hash_node< _Value, true > |
_Hash_node_base |
_Hash_node_value_base |
_Hashtable_alloc |
_Hashtable_base |
_Hashtable_ebo_helper |
_Hashtable_ebo_helper< _Nm, _Tp, false > | Specialization not using EBO
_Hashtable_ebo_helper< _Nm, _Tp, true > | Specialization using EBO
_Hashtable_traits |
_Insert |
_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Specialization
_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Specialization
_Insert_base |
_List_node_base | Common part of a node in the list
_List_node_header | The list node header
_Local_const_iterator | Local const_iterators
_Local_iterator | Local iterators
_Local_iterator_base |
_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, true > | Partial specialization used when nodes contain a cached hash code
_Map_base |
_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false > | Partial specialization, __unique_keys set to false
_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true > | Partial specialization, __unique_keys set to true
_Mask_range_hashing | Range hashing function assuming that second arg is a power of 2
_Mod_range_hashing | Default range hashing function: use division to fold a large number into the range [0, N)
_Node_const_iterator | Node const_iterators, used to iterate through all the hashtable
_Node_iterator | Node iterators, used to iterate through all the hashtable
_Node_iterator_base | Base class for node iterators
_Power2_rehash_policy | Rehash policy providing power of 2 bucket numbers. Avoids modulo operations
_Prime_rehash_policy | Default value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load factor small enough
_Quoted_string | Struct for delimited strings
_Rehash_base |
_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
_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, std::true_type > | Specialization when rehash policy provide load factor management
_Scanner | Scans an input range for regex tokens
_StateSeq | Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction
__exception_ptr |
exception_ptr | An opaque pointer to an arbitrary exception
__parallel | GNU parallel code, replaces standard behavior with parallel behavior
_CRandNumber | Functor wrapper for std::rand()
__profile | GNU profile code, replaces standard behavior with profile behavior
bitset | Class std::bitset wrapper with performance instrumentation, none at the moment
deque | Class std::deque wrapper with performance instrumentation
forward_list | Class std::forward_list wrapper with performance instrumentation
list | List wrapper with performance instrumentation
map | Class std::map wrapper with performance instrumentation
multimap | Class std::multimap wrapper with performance instrumentation
multiset | Class std::multiset wrapper with performance instrumentation
set | Class std::set wrapper with performance instrumentation
unordered_map | Class std::unordered_map wrapper with performance instrumentation
unordered_multimap | Class std::unordered_multimap wrapper with performance instrumentation
unordered_multiset | Unordered_multiset wrapper with performance instrumentation
unordered_set | Unordered_set wrapper with performance instrumentation
_V2 |
condition_variable_any | Condition_variable_any
error_category | Error_category
chrono | ISO C++ 2011 entities sub-namespace for time and date
_V2 |
steady_clock | Monotonic clock
system_clock | System clock
duration | Duration
duration_values | Duration_values
time_point | Time_point
treat_as_floating_point | Treat_as_floating_point
decimal | ISO/IEC TR 24733 Decimal floating-point arithmetic
decimal128 | 3.2.4 Class decimal128
decimal32 | 3.2.2 Class decimal32
decimal64 | 3.2.3 Class decimal64
experimental |
filesystem |
v1 |
path | A filesystem path
iterator | An iterator for the components of a path
fundamentals_v1 |
_Has_addressof | Trait that detects the presence of an overloaded unary operator&
_Optional_base | Class template that holds the necessary state for Optional values and that has the responsibility for construction and the special members
_Optional_base< _Tp, false > | Partial specialization that is exactly identical to the primary template save for not providing a destructor, to fulfill triviality requirements
any | A type-safe container of any type
bad_any_cast | Exception class thrown by a failed `any_cast`
bad_optional_access | Exception class thrown when a disengaged optional object is dereferenced
basic_string_view | A non-owning reference to a string
in_place_t | Tag type for in-place construction
nullopt_t | Tag type to disengage optional objects
optional | Class template for optional values
fundamentals_v2 |
ostream_joiner | Output iterator that inserts a delimiter between elements
owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr
owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr
propagate_const | Const-propagating wrapper
tr1 | ISO C++ TR1 entities toplevel namespace is std::tr1
tr2 | ISO C++ TR2 entities toplevel namespace is std::tr2
__dynamic_bitset_base |
__reflection_typelist |
__reflection_typelist< _First, _Rest... > | Partial specialization
__reflection_typelist<> | Specialization for an empty typelist
bases | Sequence abstraction metafunctions for manipulating a typelist
bool_set |
direct_bases | Enumerate all the direct base classes of a class. Form of a typelist
dynamic_bitset | The dynamic_bitset class represents a sequence of bits
reference |
__add_pointer_helper | Add_pointer
__allocated_ptr | Non-standard RAII type for managing pointers obtained from allocators
__atomic_base | Base class for atomic integrals
__atomic_base< _PTp * > | Partial specialization for pointer types
__atomic_flag_base | Base type for atomic_flag
__basic_future | Common implementation for future and shared_future
__codecvt_abstract_base | Common base for codecvt functions
__ctype_abstract_base | Common base for ctype facet
__detector | Implementation of the detection idiom (negative case)
__detector< _Default, __void_t< _Op< _Args... > >, _Op, _Args... > | Implementation of the detection idiom (positive case)
__future_base | Base class and enclosing scope
_Result | A result object that has storage for an object of type _Res
_Result< _Res & > | Partial specialization for reference types
_Result< void > | Explicit specialization for void
_Result_alloc | A result object that uses an allocator
_Result_base | Base class for results
__is_location_invariant |
__is_nullptr_t | __is_nullptr_t (extension)
__is_trivially_copy_assignable_impl | Is_trivially_copy_assignable
__is_trivially_copy_constructible_impl | Is_trivially_copy_constructible
__is_trivially_move_assignable_impl | Is_trivially_move_assignable
__is_trivially_move_constructible_impl | Is_trivially_move_constructible
__is_tuple_like_impl< std::pair | Partial specialization for std::pair
__iterator_traits | Traits class for iterators
__numeric_limits_base | Part of std::numeric_limits
__shared_mutex_cv | A shared mutex type implemented using std::condition_variable
_Base_bitset |
_Base_bitset< 0 > |
_Base_bitset< 1 > |
_Bind | Type of the function object returned from bind()
_Bind_result | Type of the function object returned from bind<R>()
_Deque_base |
_Deque_iterator | A deque::iterator
_Enable_copy_move | A mixin helper to conditionally enable or disable the copy/move special members
_Enable_default_constructor | A mixin helper to conditionally enable or disable the default constructor
_Enable_destructor | A mixin helper to conditionally enable or disable the default destructor
_Enable_special_members | A mixin helper to conditionally enable or disable the special members
_Function_base | Base class of all polymorphic function object wrappers
_Fwd_list_base | Base class for forward_list
_Fwd_list_const_iterator | A forward_list::const_iterator
_Fwd_list_iterator | A forward_list::iterator
_Fwd_list_node | 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
_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
_Hashtable |
_List_base | See bits/stl_deque.h's _Deque_base for an explanation
_List_const_iterator | A list::const_iterator
_List_iterator | A list::iterator
_List_node | An actual node in the list
_Maybe_get_result_type | If we have found a result_type, extract it
_Maybe_unary_or_binary_function |
_Maybe_unary_or_binary_function< _Res, _T1 > | Derives from `unary_function`, as appropriate
_Maybe_unary_or_binary_function< _Res, _T1, _T2 > | Derives from `binary_function`, as appropriate
_Mu |
_Mu< _Arg, false, false > |
_Mu< _Arg, false, true > |
_Mu< _Arg, true, false > |
_Mu< reference_wrapper< _Tp >, false, false > |
_Not_fn | Generalized negator
_Placeholder | The type of placeholder objects defined by libstdc++
_Reference_wrapper_base |
_Sp_ebo_helper< _Nm, _Tp, false > | Specialization not using EBO
_Sp_ebo_helper< _Nm, _Tp, true > | Specialization using EBO
_Temporary_buffer |
_Tuple_impl |
_Tuple_impl< _Idx, _Head, _Tail... > |
_Vector_base | See bits/stl_deque.h's _Deque_base for an explanation
_Weak_result_type |
_Weak_result_type_impl |
_Weak_result_type_impl< _Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL > | Retrieve the result type for a function pointer
_Weak_result_type_impl< _Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL > | Retrieve the result type for a varargs function pointer
_Weak_result_type_impl< _Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL > | Retrieve the result type for a function type
_Weak_result_type_impl< _Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL > | Retrieve the result type for a varargs function type
add_const | Add_const
add_cv | Add_cv
add_lvalue_reference | Add_lvalue_reference
add_rvalue_reference | Add_rvalue_reference
add_volatile | Add_volatile
adopt_lock_t | Assume the calling thread has already obtained mutex ownership and manage it
aligned_storage | Alignment type
aligned_union | Provide aligned storage for types
alignment_of | Alignment_of
allocator | The standard allocator, as per [20.4]
allocator< void > | Allocator<void> specialization
allocator_arg_t | [allocator.tag]
allocator_traits | Uniform interface to all allocator types
allocator_traits< allocator< _Tp > > | Partial specialization for std::allocator
array | A standard container for storing a fixed size sequence of elements
atomic | Generic atomic type, primary class template
atomic< _Tp * > | Partial specialization for pointer types
atomic< bool > | Atomic<bool>
atomic< char > | Explicit specialization for char
atomic< char16_t > | Explicit specialization for char16_t
atomic< char32_t > | Explicit specialization for char32_t
atomic< int > | Explicit specialization for int
atomic< long > | Explicit specialization for long
atomic< long long > | Explicit specialization for long long
atomic< short > | Explicit specialization for short
atomic< signed char > | Explicit specialization for signed char
atomic< unsigned char > | Explicit specialization for unsigned char
atomic< unsigned int > | Explicit specialization for unsigned int
atomic< unsigned long > | Explicit specialization for unsigned long
atomic< unsigned long long > | Explicit specialization for unsigned long long
atomic< unsigned short > | Explicit specialization for unsigned short
atomic< wchar_t > | Explicit specialization for wchar_t
atomic_flag | Atomic_flag
auto_ptr | A simple smart pointer providing strict ownership semantics
auto_ptr_ref |
back_insert_iterator | Turns assignment into insertion
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`
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
bad_exception |
bad_function_call | Exception class thrown when class template function's operator() is called with an empty target
bad_typeid | Thrown when a NULL pointer in a `typeid` expression is used
bad_weak_ptr | Exception possibly thrown by `shared_ptr`
basic_filebuf | The actual work of input and output (for files)
basic_fstream | Controlling input and output for files
basic_ifstream | Controlling input for files
basic_ios | Template class basic_ios, virtual base class for all stream classes
basic_iostream | Template class basic_iostream
basic_istream | Template class basic_istream
sentry | Performs setup work for input streams
basic_istringstream | Controlling input for std::string
basic_ofstream | Controlling output for files
basic_ostream | Template class basic_ostream
sentry | Performs setup work for output streams
basic_ostringstream | Controlling output for std::string
basic_regex |
basic_streambuf | The actual work of input and output (interface)
basic_string | Managing sequences of characters and character-like objects
basic_stringbuf | The actual work of input and output (for std::string)
basic_stringstream | Controlling input and output for std::string
bernoulli_distribution | A Bernoulli random number distribution
param_type |
bidirectional_iterator_tag | Bidirectional iterators support a superset of forward iterator operations
binary_function |
binary_negate | One of the negation functors
binder1st | One of the binder functors
binder2nd | One of the binder functors
binomial_distribution | A discrete binomial random number distribution
param_type |
bitset | 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.)
reference |
cauchy_distribution | A cauchy_distribution random number distribution
param_type |
char_traits | Basis for explicit traits specializations
char_traits< __gnu_cxx::character | Char_traits<__gnu_cxx::character> specialization
char_traits< char > | 21.1.3.1 char_traits specializations
char_traits< wchar_t > | 21.1.3.2 char_traits specializations
chi_squared_distribution | A chi_squared_distribution random number distribution
param_type |
codecvt | Primary class template codecvt.NB: Generic, mostly useless implementation
codecvt< _InternT, _ExternT, encoding_state > | Codecvt<InternT, _ExternT, encoding_state> specialization
codecvt< char, char, mbstate_t > | Class codecvt<char, char, mbstate_t> specialization
codecvt< char16_t, char, mbstate_t > | Class codecvt<char16_t, char, mbstate_t> specialization
codecvt< char32_t, char, mbstate_t > | Class codecvt<char32_t, char, mbstate_t> specialization
codecvt< wchar_t, char, mbstate_t > | Class codecvt<wchar_t, char, mbstate_t> specialization
codecvt_base | Empty base class for codecvt facet [22.2.1.5]
codecvt_byname | Class codecvt_byname [22.2.1.6]
collate | Facet for localized string comparison
collate_byname | Class collate_byname [22.2.4.2]
common_type | Common_type
complex |
complex< double > | 26.2.3 complex specializations complex<double> specialization
complex< float > | 26.2.3 complex specializations complex<float> specialization
complex< long double > | 26.2.3 complex specializations complex<long double> specialization
condition_variable | Condition_variable
conditional | Define a member typedef `type` to one of two argument types
const_mem_fun1_ref_t | One of the adaptors for member pointers
const_mem_fun1_t | One of the adaptors for member pointers
const_mem_fun_ref_t | One of the adaptors for member pointers
const_mem_fun_t | One of the adaptors for member pointers
ctype | 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
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
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
ctype_base | Base class for ctype
ctype_byname | Class ctype_byname [22.2.1.2]
ctype_byname< char > | 22.2.1.4 Class ctype_byname specializations
decay | Decay
default_delete | Primary template of default_delete, used by unique_ptr
default_delete< _Tp[]> | Specialization for arrays, default_delete
defer_lock_t | Do not acquire ownership of the mutex
deque | A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
discard_block_engine |
discrete_distribution | A discrete_distribution random number distribution
param_type |
divides | One of the math functors
divides< void > | One of the math functors
domain_error |
enable_if | Define a member typedef `type` only if a boolean constant is true
enable_shared_from_this | Base class allowing use of member function shared_from_this
equal_to | One of the comparison functors
equal_to< void > | One of the comparison functors
error_code | Error_code
error_condition | Error_condition
exception | Base class for all library exceptions
exponential_distribution | An exponential continuous distribution for random numbers
param_type |
extent | Extent
extreme_value_distribution | A extreme_value_distribution random number distribution
param_type |
fisher_f_distribution | A fisher_f_distribution random number distribution
param_type |
forward_iterator_tag | Forward iterators support a superset of input iterator operations
forward_list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
fpos | Class representing stream positions
front_insert_iterator | Turns assignment into insertion
function< _Res(_ArgTypes...)> | Primary class template for std::function.Polymorphic function wrapper
future | Primary template for future
future< _Res & > | Partial specialization for future<R&>
future< void > | Explicit specialization for future<void>
future_error | Exception type thrown by futures
gamma_distribution | A gamma continuous distribution for random numbers
param_type |
geometric_distribution | A discrete geometric random number distribution
param_type |
greater | One of the comparison functors
greater< void > | One of the comparison functors
greater_equal | One of the comparison functors
greater_equal< void > | One of the comparison functors
gslice | Class defining multi-dimensional subset of an array
gslice_array | Reference to multi-dimensional subset of an array
has_virtual_destructor | Has_virtual_destructor
hash | Primary class template hash
hash< __debug::bitset | Std::hash specialization for bitset
hash< __debug::vector | Std::hash specialization for vector<bool>
hash< __gnu_cxx::__u16vstring > | Std::hash specialization for __u16vstring
hash< __gnu_cxx::__u32vstring > | Std::hash specialization for __u32vstring
hash< __gnu_cxx::__vstring > | Std::hash specialization for __vstring
hash< __gnu_cxx::__wvstring > | Std::hash specialization for __wvstring
hash< __gnu_cxx::throw_value_limit > | Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
hash< __gnu_cxx::throw_value_random > | Explicit specialization of std::hash for __gnu_cxx::throw_value_random
hash< __profile::bitset | Std::hash specialization for bitset
hash< __profile::vector | Std::hash specialization for vector<bool>
hash< __shared_ptr< _Tp, _Lp > > | Std::hash specialization for __shared_ptr
hash< _Tp * > | Partial specializations for pointer types
hash< bool > | Explicit specialization for bool
hash< char > | Explicit specialization for char
hash< char16_t > | Explicit specialization for char16_t
hash< char32_t > | Explicit specialization for char32_t
hash< double > | Specialization for double
hash< error_code > | Std::hash specialization for error_code
hash< experimental::shared_ptr | Std::hash specialization for shared_ptr
hash< float > | Specialization for float
hash< int > | Explicit specialization for int
hash< long > | Explicit specialization for long
hash< long double > | Specialization for long double
hash< long long > | Explicit specialization for long long
hash< shared_ptr< _Tp > > | Std::hash specialization for shared_ptr
hash< short > | Explicit specialization for short
hash< signed char > | Explicit specialization for signed char
hash< string > | Std::hash specialization for string
hash< thread::id > | Std::hash specialization for thread::id
hash< type_index > | Std::hash specialization for type_index
hash< u16string > | Std::hash specialization for u16string
hash< u32string > | Std::hash specialization for u32string
hash< unique_ptr< _Tp, _Dp > > | Std::hash specialization for unique_ptr
hash< unsigned char > | Explicit specialization for unsigned char
hash< unsigned int > | Explicit specialization for unsigned int
hash< unsigned long > | Explicit specialization for unsigned long
hash< unsigned long long > | Explicit specialization for unsigned long long
hash< unsigned short > | Explicit specialization for unsigned short
hash< wchar_t > | Explicit specialization for wchar_t
hash< wstring > | Std::hash specialization for wstring
hash<::bitset | Std::hash specialization for bitset
hash<::vector | Std::hash specialization for vector<bool>
independent_bits_engine |
indirect_array | Reference to arbitrary subset of an array
initializer_list | Initializer_list
input_iterator_tag | Marking input iterators
insert_iterator | Turns assignment into insertion
integer_sequence | Class template integer_sequence
integral_constant | Integral_constant
invalid_argument |
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)
failure | These are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
is_abstract | Is_abstract
is_arithmetic | Is_arithmetic
is_array | Is_array
is_assignable | Is_assignable
is_base_of | Is_base_of
is_bind_expression | 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()
is_bind_expression< _Bind< _Signature > > | Class template _Bind is always a bind expression
is_bind_expression< _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
is_bind_expression< const _Bind< _Signature > > | Class template _Bind is always a bind expression
is_bind_expression< const _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
is_bind_expression< const volatile _Bind< _Signature > > | Class template _Bind is always a bind expression
is_bind_expression< const volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
is_bind_expression< volatile _Bind< _Signature > > | Class template _Bind is always a bind expression
is_bind_expression< volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
is_class | Is_class
is_compound | Is_compound
is_const | Is_const
is_constructible | Is_constructible
is_convertible | Is_convertible
is_copy_assignable | Is_copy_assignable
is_copy_constructible | Is_copy_constructible
is_default_constructible | Is_default_constructible
is_destructible | Is_destructible
is_empty | Is_empty
is_enum | Is_enum
is_error_code_enum | Is_error_code_enum
is_error_code_enum< future_errc > | Specialization
is_error_condition_enum | Is_error_condition_enum
is_final | Is_final
is_floating_point | Is_floating_point
is_function | Is_function
is_fundamental | Is_fundamental
is_integral | Is_integral
is_literal_type | Is_literal_type
is_lvalue_reference | Is_lvalue_reference
is_member_function_pointer | Is_member_function_pointer
is_member_object_pointer | Is_member_object_pointer
is_member_pointer | Is_member_pointer
is_move_assignable | Is_move_assignable
is_move_constructible | Is_move_constructible
is_nothrow_assignable | Is_nothrow_assignable
is_nothrow_constructible | Is_nothrow_constructible
is_nothrow_copy_assignable | Is_nothrow_copy_assignable
is_nothrow_copy_constructible | Is_nothrow_copy_constructible
is_nothrow_default_constructible | Is_nothrow_default_constructible
is_nothrow_destructible | Is_nothrow_destructible
is_nothrow_move_assignable | Is_nothrow_move_assignable
is_nothrow_move_constructible | Is_nothrow_move_constructible
is_nothrow_swappable | Is_nothrow_swappable
is_nothrow_swappable_with | Is_nothrow_swappable_with
is_null_pointer | Is_null_pointer (LWG 2247)
is_object | Is_object
is_placeholder | Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is
is_placeholder< _Placeholder< _Num > > |
is_pod | Is_pod
is_pointer | Is_pointer
is_polymorphic | Is_polymorphic
is_reference | Is_reference
is_rvalue_reference | Is_rvalue_reference
is_same | Is_same
is_scalar | Is_scalar
is_standard_layout | Is_standard_layout
is_swappable | Metafunctions used for detecting swappable types: p0185r1
is_swappable_with | Is_swappable_with
is_trivial | Is_trivial
is_trivially_assignable | Is_trivially_assignable
is_trivially_constructible | Is_trivially_constructible
is_trivially_default_constructible | Is_trivially_default_constructible
is_trivially_destructible | Is_trivially_destructible
is_union | Is_union
is_void | Is_void
is_volatile | Is_volatile
istream_iterator | Provides input iterator semantics for streams
istreambuf_iterator | Provides input iterator semantics for streambufs
iterator | Common iterator class
iterator_traits< _Tp * > | Partial specialization for pointer types
iterator_traits< const _Tp * > | Partial specialization for const pointer types
length_error |
less | One of the comparison functors
less< void > | One of the comparison functors
less_equal | One of the comparison functors
less_equal< void > | One of the comparison functors
linear_congruential_engine | A model of a linear congruential random number generator
list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
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
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
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
lock_guard | A simple scoped lock type
logic_error | One of two subclasses of exception
logical_and | One of the Boolean operations functors
logical_and< void > | One of the Boolean operations functors
logical_not | One of the Boolean operations functors
logical_not< void > | One of the Boolean operations functors
logical_or | One of the Boolean operations functors
logical_or< void > | One of the Boolean operations functors
lognormal_distribution | A lognormal_distribution random number distribution
param_type |
make_signed | Make_signed
make_unsigned | Make_unsigned
map | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
mask_array | Reference to selected subset of an array
match_results | The results of a match or search operation
mem_fun1_ref_t | One of the adaptors for member pointers
mem_fun1_t | One of the adaptors for member pointers
mem_fun_ref_t | One of the adaptors for member pointers
mem_fun_t | One of the adaptors for member pointers
mersenne_twister_engine |
messages | 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
messages_base | Messages facet base class providing catalog typedef
messages_byname | Class messages_byname [22.2.7.2]
minus | One of the math functors
minus< void > | One of the math functors
modulus | One of the math functors
modulus< void > | One of the math functors
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
money_get | Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
money_put | Primary class template money_put.This facet encapsulates the code to format and output a monetary amount
moneypunct | Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
moneypunct_byname | Class moneypunct_byname [22.2.6.4]
move_iterator |
multimap | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
multiplies | One of the math functors
multiplies< void > | One of the math functors
multiset | A standard container made up of elements, which can be retrieved in logarithmic time
mutex | The standard mutex type
negate | One of the math functors
negate< void > | One of the math functors
negative_binomial_distribution | A negative_binomial_distribution random number distribution
param_type |
nested_exception | Exception class with exception_ptr data member
normal_distribution | A normal continuous distribution for random numbers
param_type |
not_equal_to | One of the comparison functors
not_equal_to< void > | One of the comparison functors
num_get | 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
num_put | 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
numeric_limits | Properties of fundamental types
numeric_limits< bool > | Numeric_limits<bool> specialization
numeric_limits< char > | Numeric_limits<char> specialization
numeric_limits< char16_t > | Numeric_limits<char16_t> specialization
numeric_limits< char32_t > | Numeric_limits<char32_t> specialization
numeric_limits< double > | Numeric_limits<double> specialization
numeric_limits< float > | Numeric_limits<float> specialization
numeric_limits< int > | Numeric_limits<int> specialization
numeric_limits< long > | Numeric_limits<long> specialization
numeric_limits< long double > | Numeric_limits<long double> specialization
numeric_limits< long long > | Numeric_limits<long long> specialization
numeric_limits< short > | Numeric_limits<short> specialization
numeric_limits< signed char > | Numeric_limits<signed char> specialization
numeric_limits< unsigned char > | Numeric_limits<unsigned char> specialization
numeric_limits< unsigned int > | Numeric_limits<unsigned int> specialization
numeric_limits< unsigned long > | Numeric_limits<unsigned long> specialization
numeric_limits< unsigned long long > | Numeric_limits<unsigned long long> specialization
numeric_limits< unsigned short > | Numeric_limits<unsigned short> specialization
numeric_limits< wchar_t > | Numeric_limits<wchar_t> specialization
numpunct | 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
numpunct_byname | Class numpunct_byname [22.2.3.2]
once_flag | Once_flag
ostream_iterator | Provides output iterator semantics for streams
ostreambuf_iterator | Provides output iterator semantics for streambufs
out_of_range |
output_iterator_tag | Marking output iterators
overflow_error |
owner_less | Primary template owner_less
owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr
owner_less< void > | Void specialization of owner_less
owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr
packaged_task< _Res(_ArgTypes...)> | Packaged_task
pair | Struct holding two objects of arbitrary type
piecewise_constant_distribution | A piecewise_constant_distribution random number distribution
param_type |
piecewise_construct_t | Piecewise_construct_t
piecewise_linear_distribution | A piecewise_linear_distribution random number distribution
param_type |
plus | One of the math functors
pointer_to_binary_function | One of the adaptors for function pointers
pointer_to_unary_function | One of the adaptors for function pointers
pointer_traits | Uniform interface to all pointer-like types
pointer_traits< _Tp * > | Partial specialization for built-in pointers
poisson_distribution | A discrete Poisson random number distribution
param_type |
priority_queue | A standard container automatically sorting its contents
promise | Primary template for promise
promise< _Res & > | Partial specialization for promise<R&>
promise< void > | Explicit specialization for promise<void>
queue | A standard container giving FIFO behavior
random_access_iterator_tag | Random-access iterators support a superset of bidirectional iterator operations
random_device |
range_error |
rank | Rank
ratio | Provides compile-time rational arithmetic
ratio_equal | Ratio_equal
ratio_not_equal | Ratio_not_equal
raw_storage_iterator |
recursive_mutex | The standard recursive mutex type
recursive_timed_mutex | Recursive_timed_mutex
reference_wrapper | Primary class template for reference_wrapper
regex_error | A regular expression exception class.The regular expression library throws objects of this class on error
regex_iterator |
regex_token_iterator |
regex_traits | Describes aspects of a regular expression
remove_all_extents | Remove_all_extents
remove_const | Remove_const
remove_cv | Remove_cv
remove_extent | Remove_extent
remove_pointer | Remove_pointer
remove_reference | Remove_reference
remove_volatile | Remove_volatile
result_of | Result_of
reverse_iterator |
runtime_error | One of two subclasses of exception
scoped_allocator_adaptor | Primary class template
seed_seq | Generates sequences of seeds for random number generators
set | A standard container made up of unique keys, which can be retrieved in logarithmic time
shared_future | Primary template for shared_future
shared_future< _Res & > | Partial specialization for shared_future<R&>
shared_future< void > | Explicit specialization for shared_future<void>
shared_lock | Shared_lock
shared_ptr | A smart pointer with reference-counted copy semantics
shared_timed_mutex | The standard shared timed mutex type
shuffle_order_engine | Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits `__k`
slice | Class defining one-dimensional subset of an array
slice_array | Reference to one-dimensional subset of an array
stack | A standard container giving FILO behavior
student_t_distribution | A student_t_distribution random number distribution
param_type |
sub_match |
subtract_with_carry_engine | The Marsaglia-Zaman generator
system_error | Thrown to indicate error code of underlying system
thread | Thread
id | Thread::id
time_base | Time format ordering data.This class provides an enum representing different orderings of time: day, month, and year
time_get | 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
time_get_byname | Class time_get_byname [22.2.5.2]
time_put | Primary class template time_put.This facet encapsulates the code to format and output dates and times according to formats used by strftime()
time_put_byname | Class time_put_byname [22.2.5.4]
timed_mutex | Timed_mutex
try_to_lock_t | Try to acquire ownership of the mutex without blocking
tuple | Primary class template, tuple
tuple< _T1, _T2 > | Partial specialization, 2-element tuple. Includes construction and assignment from a pair
tuple_element | Tuple_element
tuple_element< 0, std::pair | Partial specialization for std::pair
tuple_element< 0, tuple< _Head, _Tail... > > |
tuple_element< 1, std::pair | Partial specialization for std::pair
tuple_element< __i, tuple< _Head, _Tail... > > |
tuple_element< __i, tuple<> > |
tuple_element< _Int, ::array | Partial specialization for std::array
tuple_element< _Int, std::__debug::array | Tuple_element
tuple_size | Tuple_size
tuple_size< std::__debug::array | Tuple_size
tuple_size< std::pair | Partial specialization for std::pair
tuple_size< tuple< _Elements... > > | Class tuple_size
tuple_size<::array | Partial specialization for std::array
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)
type_info | Part of RTTI
unary_function |
unary_negate | One of the negation functors
underflow_error |
underlying_type | The underlying type of an enum
uniform_int_distribution | Uniform discrete distribution for random numbers. A discrete random distribution on the range with equal probability throughout the range
param_type |
uniform_real_distribution | Uniform continuous distribution for random numbers
param_type |
unique_lock | A movable scoped lock type
unique_ptr | 20.7.1.2 unique_ptr for single objects
unique_ptr< _Tp[], _Dp > | 20.7.1.3 unique_ptr for array objects with a runtime length
unordered_map | A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys
unordered_multimap | A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
unordered_multiset | A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
unordered_set | A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
uses_allocator | Declare uses_allocator so it can be specialized in <queue> etc
uses_allocator< tuple< _Types... >, _Alloc > | Partial specialization for tuples
valarray | Smart array designed to support numeric processing
vector | A standard container which offers fixed time access to individual elements in any order
vector< bool, _Alloc > | A specialization of vector for booleans which offers fixed time access to individual elements in any order
wbuffer_convert | Buffer conversions
weak_ptr | A smart pointer with weak semantics
weibull_distribution | A weibull_distribution random number distribution
param_type |
wstring_convert | String conversions
const_iterator_ | Const range-type iterator
iterator_ | Range-type iterator
point_const_iterator_ | Const point-type iterator
point_iterator_ | Find type iterator