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

__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
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
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
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
new_allocator | An allocator that uses global new, as per [20.4]
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 |
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
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
__gnu_sequential | GNU sequential classes for public use
abi | The cross-vendor C++ Application Binary Interface. A namespace alias to __cxxabiv1, but user programs should use the alias 'abi'
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
__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
chrono | ISO C++ 2011 entities sub-namespace for time and date
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
placeholders | ISO C++11 entities sub-namespace for functional
regex_constants | ISO C++-0x entities sub namespace for regex
rel_ops | The generated relational operators are sequestered here
this_thread | ISO C++ 2011 entities sub-namespace for thread. 30.3.2 Namespace this_thread
tr1 | ISO C++ TR1 entities toplevel namespace is std::tr1
__detail | Implementation details not part of the namespace std::tr1 interface
tr2 | ISO C++ TR2 entities toplevel namespace is std::tr2
__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 |
__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< _T1, _T2 > > | 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_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_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
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
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
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_category | Error_category
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
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< __profile::bitset< _Nb > > | Std::hash specialization for bitset
hash< __profile::vector< bool, _Alloc > > | 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< _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 |
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_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
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
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 | 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
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
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
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< _Tp1, _Tp2 > > | Partial specialization for std::pair
tuple_element< 0, tuple< _Head, _Tail... > > |
tuple_element< 1, std::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_element< _Int, std::__debug::array< _Tp, _Nm > > | Tuple_element
tuple_size | Tuple_size
tuple_size< std::__debug::array< _Tp, _Nm > > | Tuple_size
tuple_size< std::pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
tuple_size< tuple< _Elements... > > | Class tuple_size
tuple_size<::array< _Tp, _Nm > > | Partial specialization for std::array
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 smart pointer with weak semantics
weibull_distribution | A weibull_distribution random number distribution
param_type |
wstring_convert | String conversions