Namespace List
Here is a list of all documented namespaces with brief descriptions:

__cxxabiv1 |
__forced_unwind | Thrown as part of 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
__ops |
typelist | GNU typelist extensions for public compile-time use
__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)
__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
_Caster |
_Char_types | Mapping from character type to associated types
_ExtPtr_allocator | An example allocator which uses a non-standard pointer type
_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
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
enc_filebuf | Class enc_filebuf
encoding_char_traits | Encoding_char_traits
encoding_state | Extension to use iconv for dealing with character encodings
forced_error | Thrown by utilities for testing exception safety
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
new_allocator | An allocator that uses global new, as per C++03 [20.4.1]
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
rope |
select1st | An SGI extension
select2nd | An SGI extension
slist |
stdio_filebuf | Provides a layer of compatibility for C/POSIX
stdio_sync_filebuf | Provides a layer of compatibility for C
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
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_internal | GNU implemenation details, not for public use or export. Used only when anonymous namespaces cannot be substituted
__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< Char, Char_Traits, std::allocator< char > > > | 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
maybe_null_type | Base class for conditionally defining a static data member
maybe_null_type< Key, null_type, _Alloc, Store_Hash > | Specialization that defines a static data member of type null_type
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
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
rb_tree_node_ | Node for Red-Black trees
rc | Redundant binary counter
rc_binomial_heap |
rebind_traits | Consistent API for accessing allocator-related types
resize_policy | Resize policy for binary heap
select_value_type | Choose value_type to be a key/value pair or just a key
select_value_type< Key, null_type > | Specialization for sets where the key is the value_type
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, _Th, false > | 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
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_sequential | GNU sequential classes for public use
__math_double |
__math_float |
__proposed |
abi | The cross-vendor C++ Application Binary Interface. A namespace alias to __cxxabiv1, but user programs should use the alias 'abi'
simd_abi |
deduce |
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
__variant |
_BracketMatcher | Matches a character range (bracket expression)
_Compiler | Builds an NFA from an input iterator range
_Executor | Takes a regex and an input string and does the matching
_List_node_base | Common part of a node in the list
_List_node_header | The list node header
_Quoted_string | Struct for delimited strings
_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()
__parse_int |
__select_int |
_V2 |
condition_variable_any | Condition_variable_any
error_category |
chrono | ISO C++ 2011 namespace for date and time utilities
_V2 |
steady_clock | Monotonic clock
system_clock | System clock
experimental |
duration | `chrono::duration` represents a distance between two points in time
duration_values | Duration_values
steady_clock | Monotonic clock
system_clock | System clock
time_point | `chrono::time_point` represents a point in time as measured by a clock
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 | Namespace for features defined in ISO Technical Specifications
filesystem |
v1 |
filesystem_error | Exception type thrown by the Filesystem TS library
path | A filesystem path
iterator | An iterator for the components of a path
space_info | Information about free space on a disk
filesystem_error | Exception type thrown by the Filesystem TS library
path | A filesystem path
iterator | An iterator for the components of a path
space_info | Information about free space on a disk
fundamentals_v1 |
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 |
pmr |
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
pmr |
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
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
filesystem | ISO C++ 2017 namespace for File System library
__directory_iterator_proxy | Proxy returned by post-increment on directory iterators
directory_entry | The value type used by directory iterators
directory_iterator | Iterator type for traversing the entries in a single directory
file_status | Information about a file's type and permissions
filesystem_error | Exception type thrown by the Filesystem library
path | A filesystem path
iterator | An iterator for the components of a path
recursive_directory_iterator | Iterator type for recursively traversing a directory hierarchy
space_info | Information about free space on a disk
literals | ISO C++ inline namespace for literal suffixes
chrono_literals |
placeholders | ISO C++ 2011 namespace for std::bind placeholders
pmr |
memory_resource | Class memory_resource
pool_options | Parameters for tuning a pool resource's behaviour
synchronized_pool_resource | A thread-safe memory resource that manages pools of fixed-size blocks
unsynchronized_pool_resource | A non-thread-safe memory resource that manages pools of fixed-size blocks
regex_constants | ISO C++ 2011 namespace for options and flags used with std::regex
rel_ops | The generated relational operators are sequestered here
this_thread | ISO C++ 2011 namespace for interacting with the current thread
tr1 | ISO C++ TR1 entities toplevel namespace is std::tr1
__detail | Implementation details not part of the namespace std::tr1 interface
tr2 | Namespace for non-standard "TR2" extensions
__detail | Implementation details not part of the namespace std::tr2 interface
__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 |
__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
__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 (deprecated extension)
__is_tuple_like_impl< pair< _T1, _T2 > > | Partial specialization for std::pair
__numeric_limits_base | Part of std::numeric_limits
_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
_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
_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
_Mu |
_Mu< _Arg, false, false > |
_Mu< _Arg, false, true > |
_Mu< _Arg, true, false > |
_Mu< reference_wrapper< _Tp >, false, false > |
_Node_handle | Node handle type for maps
_Node_handle< _Value, _Value, _NodeAlloc > | Node handle type for sets
_Node_handle_common | Base class for node handle types of maps and sets
_Node_insert_return | Return type of insert(node_handle&&) on unique maps/sets
_Not_fn | Generalized negator
_Optional_base | Class template that provides copy/move constructors of optional
_Placeholder | The type of placeholder objects defined by libstdc++
_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
add_const | Add_const
add_cv | Add_cv
add_lvalue_reference | Add_lvalue_reference
add_pointer | Add_pointer
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 C++03 [20.4.1]
allocator< void > | Allocator<void> specialization
allocator_traits | Uniform interface to all allocator types
allocator_traits< allocator< _Tp > > | Partial specialization for std::allocator
allocator_traits< allocator< void > > | Explicit specialization for std::allocator<void>
any | A type-safe container of any type
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_any_cast | Exception class thrown by a failed `any_cast`
bad_cast | Thrown during incorrect typecasting
bad_exception |
bad_function_call | Exception class thrown when class template function's operator() is called with an empty target
bad_optional_access | Exception class thrown when a disengaged optional object is dereferenced
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_string_view | A non-owning reference to a string
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
reference |
cauchy_distribution | A cauchy_distribution random number distribution
param_type |
char_traits | Basis for explicit traits specializations
char_traits< __gnu_cxx::character< _Value, _Int, _St > > | 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
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
common_type< chrono::duration< _Rep, _Period > > | Specialization of common_type for one chrono::duration type
common_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > > | Specialization of common_type for two identical chrono::duration types
common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > > |
common_type< chrono::time_point< _Clock, _Duration > > | Specialization of common_type for one chrono::time_point type
common_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > > | Specialization of common_type for two identical chrono::time_point types
common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > > |
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
condition_variable_any | Condition_variable_any
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
ctype< char > | The ctype<char> specialization
ctype< wchar_t > | The ctype<wchar_t> specialization
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 for single objects
default_delete< _Tp[]> | Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
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_category |
error_code |
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
from_chars_result | Result type of std::from_chars
front_insert_iterator | Turns assignment into insertion
function< _Res(_ArgTypes...)> | 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< _Nb > > | Std::hash specialization for bitset
hash< __debug::vector< bool, _Alloc > > | 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< __gnu_debug::basic_string< _CharT > > | Std::hash specialization for __gnu_debug::basic_string
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< error_condition > | Std::hash specialization for error_condition
hash< experimental::optional< _Tp > > | Std::hash partial specialization for experimental::optional
hash< experimental::shared_ptr< _Tp > > | 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< _Nb > > | Std::hash specialization for bitset
hash<::vector< bool, _Alloc > > | 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 |
invoke_result | Std::invoke_result
ios_base | The base of the I/O class hierarchy
failure | These are thrown to indicate problems with io
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_invocable | Std::is_invocable
is_invocable_r | Std::is_invocable_r
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_invocable | Std::is_nothrow_invocable
is_nothrow_invocable_r | Std::is_nothrow_invocable_r
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_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_signed | Is_signed
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_copy_assignable | Is_trivially_copy_assignable
is_trivially_copy_constructible | Is_trivially_copy_constructible
is_trivially_copyable | Is_trivially_copyable
is_trivially_default_constructible | Is_trivially_default_constructible
is_trivially_destructible | Is_trivially_destructible
is_trivially_move_assignable | Is_trivially_move_assignable
is_trivially_move_constructible | Is_trivially_move_constructible
is_union | Is_union
is_unsigned | Is_unsigned
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 | Traits class for iterators
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
facet | Localization functionality base class
id | Facet ID class
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
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
money_get | Primary class template money_get
money_put | Primary class template money_put
moneypunct | Primary class template moneypunct
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
nullopt_t | Tag type to disengage optional objects
num_get | Primary class template num_get
num_put | Primary class template num_put
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
numpunct_byname | Class numpunct_byname [22.2.3.2]
once_flag | Flag type used by std::call_once
optional | Class template for optional values
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 compares either shared_ptr or weak_ptr
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 | Tag type for piecewise construction of std::pair objects
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_greater | Ratio_greater
ratio_greater_equal | Ratio_greater_equal
ratio_less | Ratio_less
ratio_less_equal | Ratio_less_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
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 | An adaptor to recursively pass an allocator to the objects it constructs
scoped_lock | A scoped lock type for multiple lockable objects
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_mutex | The standard shared mutex type
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 reordering random numbers from some base engine
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 | An exception type that includes an `error_code` value
thread | Thread
id | Thread::id
time_base | Time format ordering data
time_get | Primary class template time_get
time_get_byname | Class time_get_byname [22.2.5.2]
time_put | Primary class template time_put
time_put_byname | Class time_put_byname [22.2.5.4]
timed_mutex | Timed_mutex
to_chars_result | Result type of std::to_chars
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, pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
tuple_element< 0, tuple< _Head, _Tail... > > |
tuple_element< 1, pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
tuple_element< __i, tuple< _Head, _Tail... > > |
tuple_element< __i, tuple<> > |
tuple_element< _Int, array< _Tp, _Nm > > | Partial specialization for std::array
tuple_size | Tuple_size
tuple_size< array< _Tp, _Nm > > | Partial specialization for std::array
tuple_size< pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
tuple_size< tuple< _Elements... > > | Class tuple_size
type_index | Class type_index
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 non-owning observer for a pointer owned by a shared_ptr
weibull_distribution | A weibull_distribution random number distribution
param_type |
wstring_convert | String conversions