Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
__cxxabiv1::__forced_unwindThrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >Policy for shared __pool objects
__gnu_cxx::__detail::__mini_vector< _Tp >__mini_vector<> is a stripped down version of the full-fledged std::vector<>
__gnu_cxx::__detail::_Bitmap_counter< _Tp >The bitmap counter which acts as the bitmap manipulator, and manages the bit-manipulation functions and the searching and identification functions on the bit-map
__gnu_cxx::__detail::_Ffit_finder< _Tp >The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
__gnu_cxx::__mt_alloc< _Tp, _Poolp >This is a fixed size (power of 2) allocator which - when compiled with thread support - will maintain one freelist per size per thread plus a global one. Steps are taken to limit the per thread freelist sizes (by returning excess back to the global list).Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.html
__gnu_cxx::__mt_alloc_base< _Tp >Base class for _Tp dependent member functions
__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread >Policy for individual __pool objects
__gnu_cxx::__pool< false >Specialization for single thread
__gnu_cxx::__pool< true >Specialization for thread enabled, via gthreads.h
__gnu_cxx::__pool_alloc< _Tp >Allocator using a memory pool with a single lock
__gnu_cxx::__pool_alloc_baseBase class for __pool_alloc
__gnu_cxx::__pool_baseBase class for pool object
__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >
__gnu_cxx::__scoped_lockScoped lock idiom
__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >Template class __versa_string.Data structure managing sequences of characters and character-like objects
__gnu_cxx::_Caster< _ToType >
__gnu_cxx::_Char_types< _CharT >Mapping from character type to associated types
__gnu_cxx::_ExtPtr_allocator< _Tp >An example allocator which uses a non-standard pointer type.This allocator specifies that containers use a 'relative pointer' as it's pointer type. (See ext/pointer.h) Memory allocation in this example is still performed using std::allocator
__gnu_cxx::_Invalid_type
__gnu_cxx::_Pointer_adapter< _Storage_policy >
__gnu_cxx::_Relative_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset value which is relative to its own address
__gnu_cxx::_Relative_pointer_impl< const _Tp >
__gnu_cxx::_Std_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which yields a standard pointer
__gnu_cxx::_Unqualified_type< _Tp >
__gnu_cxx::annotate_baseBase class for checking address and label information about allocations. Create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size
__gnu_cxx::array_allocator< _Tp, _Array >An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
__gnu_cxx::array_allocator_base< _Tp >Base class
__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 >An SGI extension
__gnu_cxx::bitmap_allocator< _Tp >Bitmap Allocator, primary template
__gnu_cxx::char_traits< _CharT >Base class used to implement std::char_traits
__gnu_cxx::character< V, I, S >A POD class that serves as a character abstraction class
__gnu_cxx::condition_baseBase struct for condition policy
__gnu_cxx::constant_binary_fun< _Result, _Arg1, _Arg2 >An SGI extension
__gnu_cxx::constant_unary_fun< _Result, _Argument >An SGI extension
__gnu_cxx::constant_void_fun< _Result >An SGI extension
__gnu_cxx::debug_allocator< _Alloc >A meta-allocator with debugging bits, as per [20.4].This is precisely the allocator defined in the C++ Standard.

  • all allocation calls operator new
  • all deallocation calls operator delete
__gnu_cxx::enc_filebuf< _CharT >Class enc_filebuf
__gnu_cxx::encoding_char_traits< _CharT >Encoding_char_traits
__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
__gnu_cxx::forced_errorThown by exception safety machinery
__gnu_cxx::free_listThe free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
__gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
__gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
__gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc >
__gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc >
__gnu_cxx::limit_conditionBase class for incremental control and throw
__gnu_cxx::limit_condition::always_adjustorAlways enter the condition
__gnu_cxx::limit_condition::limit_adjustorEnter the nth condition
__gnu_cxx::limit_condition::never_adjustorNever enter the condition
__gnu_cxx::malloc_allocator< _Tp >An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard.

  • all allocation calls malloc
  • all deallocation calls free
__gnu_cxx::new_allocator< _Tp >An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard.

  • all allocation calls operator new
  • all deallocation calls operator delete
__gnu_cxx::project1st< _Arg1, _Arg2 >An SGI extension
__gnu_cxx::project2nd< _Arg1, _Arg2 >An SGI extension
__gnu_cxx::random_conditionBase class for random probability control and throw
__gnu_cxx::random_condition::always_adjustorAlways enter the condition
__gnu_cxx::random_condition::group_adjustorGroup condition
__gnu_cxx::random_condition::never_adjustorNever enter the condition
__gnu_cxx::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc >
__gnu_cxx::recursive_init_errorException thrown by __cxa_guard_acquire.6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) while the object is being initialized, the behavior is undefined
__gnu_cxx::rope< _CharT, _Alloc >
__gnu_cxx::select1st< _Pair >An SGI extension
__gnu_cxx::select2nd< _Pair >An SGI extension
__gnu_cxx::slist< _Tp, _Alloc >
__gnu_cxx::stdio_filebuf< _CharT, _Traits >Provides a layer of compatibility for C/POSIX.This GNU extension provides extensions for working with standard C FILE*'s and POSIX file descriptors. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
__gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >Provides a layer of compatibility for C.This GNU extension provides extensions for working with standard C FILE*'s. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
__gnu_cxx::subtractive_rng
__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp >
__gnu_cxx::throw_allocator_base< _Tp, _Cond >Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code.Note: Deallocate not allowed to throw
__gnu_cxx::throw_allocator_limit< _Tp >Allocator throwing via limit condition
__gnu_cxx::throw_allocator_random< _Tp >Allocator throwing via random condition
__gnu_cxx::throw_value_base< _Cond >Class with exception generation control. Intended to be used as a value_type in templatized code
__gnu_cxx::throw_value_limitType throwing via limit condition
__gnu_cxx::throw_value_randomType throwing via random condition
__gnu_cxx::unary_compose< _Operation1, _Operation2 >An SGI extension
__gnu_debug::_After_nth_from< _Iterator >
__gnu_debug::_BeforeBeginHelper< _Sequence >
__gnu_debug::_Equal_to< _Type >
__gnu_debug::_Not_equal_to< _Type >
__gnu_debug::_Safe_iterator< _Iterator, _Sequence >Safe iterator wrapper
__gnu_debug::_Safe_iterator_baseBasic functionality for a safe iterator
__gnu_debug::_Safe_sequence< _Sequence >Base class for constructing a safe sequence type that tracks iterators that reference it
__gnu_debug::_Safe_sequence_baseBase class that supports tracking of iterators that reference a sequence
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >Class std::basic_string with safety/checking/debug instrumentation
__gnu_parallel::__accumulate_binop_reduct< _BinOp >General reduction, using a binary operator
__gnu_parallel::__accumulate_selector< _It >Std::accumulate() selector
__gnu_parallel::__adjacent_difference_selector< _It >Selector that returns the difference between two adjacent __elements
__gnu_parallel::__adjacent_find_selectorTest predicate on two adjacent elements
__gnu_parallel::__binder1st< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder1st, but giving the argument types explicitly
__gnu_parallel::__binder2nd< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder2nd, but giving the argument types explicitly
__gnu_parallel::__count_if_selector< _It, _Diff >Std::count_if () selector
__gnu_parallel::__count_selector< _It, _Diff >Std::count() selector
__gnu_parallel::__fill_selector< _It >Std::fill() selector
__gnu_parallel::__find_first_of_selector< _FIterator >Test predicate on several elements
__gnu_parallel::__find_if_selectorTest predicate on a single element, used for std::find() and std::find_if ()
__gnu_parallel::__for_each_selector< _It >Std::for_each() selector
__gnu_parallel::__generate_selector< _It >Std::generate() selector
__gnu_parallel::__generic_find_selectorBase class of all __gnu_parallel::__find_template selectors
__gnu_parallel::__generic_for_each_selector< _It >Generic __selector for embarrassingly parallel functions
__gnu_parallel::__identity_selector< _It >Selector that just returns the passed iterator
__gnu_parallel::__inner_product_selector< _It, _It2, _Tp >Std::inner_product() selector
__gnu_parallel::__max_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
__gnu_parallel::__min_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
__gnu_parallel::__mismatch_selectorTest inverted predicate on a single element
__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned off
__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned off
__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned off
__gnu_parallel::__replace_if_selector< _It, _Op, _Tp >Std::replace() selector
__gnu_parallel::__replace_selector< _It, _Tp >Std::replace() selector
__gnu_parallel::__transform1_selector< _It >Std::transform() __selector, one input sequence variant
__gnu_parallel::__transform2_selector< _It >Std::transform() __selector, two input sequences variant
__gnu_parallel::__unary_negate< _Predicate, argument_type >Similar to std::unary_negate, but giving the argument types explicitly
__gnu_parallel::_DRandomShufflingGlobalData< _RAIter >Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator >Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
__gnu_parallel::_DummyReductReduction function doing nothing
__gnu_parallel::_EqualFromLess< _T1, _T2, _Compare >Constructs predicate for equality from strict weak ordering predicate
__gnu_parallel::_EqualTo< _T1, _T2 >Similar to std::equal_to, but allows two different types
__gnu_parallel::_GuardedIterator< _RAIter, _Compare >_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
__gnu_parallel::_IteratorPair< _Iterator1, _Iterator2, _IteratorCategory >A pair of iterators. The usual iterator operations are applied to both child iterators
__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory >A triple of iterators. The usual iterator operations are applied to all three child iterators
__gnu_parallel::_Job< _DifferenceTp >One __job for a certain thread
__gnu_parallel::_Less< _T1, _T2 >Similar to std::less, but allows two different types
__gnu_parallel::_Lexicographic< _T1, _T2, _Compare >Compare __a pair of types lexicographically, ascending
__gnu_parallel::_LexicographicReverse< _T1, _T2, _Compare >Compare __a pair of types lexicographically, descending
__gnu_parallel::_LoserTree< __stable, _Tp, _Compare >Stable _LoserTree variant
__gnu_parallel::_LoserTree< false, _Tp, _Compare >Unstable _LoserTree variant
__gnu_parallel::_LoserTreeBase< _Tp, _Compare >Guarded loser/tournament tree
__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_LoserInternal representation of a _LoserTree element
__gnu_parallel::_LoserTreePointer< __stable, _Tp, _Compare >Stable _LoserTree implementation
__gnu_parallel::_LoserTreePointer< false, _Tp, _Compare >Unstable _LoserTree implementation
__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >Base class of _Loser Tree implementation using pointers
__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_LoserInternal representation of _LoserTree __elements
__gnu_parallel::_LoserTreePointerUnguarded< __stable, _Tp, _Compare >Stable unguarded _LoserTree variant storing pointers
__gnu_parallel::_LoserTreePointerUnguarded< false, _Tp, _Compare >Unstable unguarded _LoserTree variant storing pointers
__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare >Unguarded loser tree, keeping only pointers to the elements in the tree structure
__gnu_parallel::_LoserTreeTraits< _Tp >Traits for determining whether the loser tree should use pointers or copies
__gnu_parallel::_LoserTreeUnguarded< __stable, _Tp, _Compare >Stable implementation of unguarded _LoserTree
__gnu_parallel::_LoserTreeUnguarded< false, _Tp, _Compare >Non-Stable implementation of unguarded _LoserTree
__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >Base class for unguarded _LoserTree implementation
__gnu_parallel::_Multiplies< _Tp1, _Tp2, _Result >Similar to std::multiplies, but allows two different types
__gnu_parallel::_NothingFunctor doing nothing
__gnu_parallel::_Piece< _DifferenceTp >Subsequence description
__gnu_parallel::_Plus< _Tp1, _Tp2, _Result >Similar to std::plus, but allows two different types
__gnu_parallel::_PMWMSSortingData< _RAIter >Data accessed by all threads
__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp >Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp >_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
__gnu_parallel::_QSBThreadLocal< _RAIter >Information local to one thread in the parallel quicksort run
__gnu_parallel::_RandomNumberRandom number generator, based on the Mersenne twister
__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided. Calling them would not make sense in a concurrent setting
__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >Stable sorting functor
__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >Non-__stable sorting functor
__gnu_parallel::_SettingsClass _Settings /// Run-time settings for the parallel mode including all tunable parameters
__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator >Split consistently
__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >Split by sampling
__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >Split by exact splitting
__gnu_parallel::balanced_quicksort_tagForces parallel sorting using balanced quicksort at compile time
__gnu_parallel::balanced_tagRecommends parallel execution using dynamic load-balancing at compile time
__gnu_parallel::constant_size_blocks_tagSelects the constant block size variant for std::find()
__gnu_parallel::default_parallel_tagRecommends parallel execution using the default parallel algorithm
__gnu_parallel::equal_split_tagSelects the equal splitting variant for std::find()
__gnu_parallel::exact_tagForces parallel merging with exact splitting, at compile time
__gnu_parallel::find_tagBase class for for std::find() variants
__gnu_parallel::growing_blocks_tagSelects the growing block size variant for std::find()
__gnu_parallel::multiway_mergesort_exact_tagForces parallel sorting using multiway mergesort with exact splitting at compile time
__gnu_parallel::multiway_mergesort_sampling_tagForces parallel sorting using multiway mergesort with splitting by sampling at compile time
__gnu_parallel::multiway_mergesort_tagForces parallel sorting using multiway mergesort at compile time
__gnu_parallel::omp_loop_static_tagRecommends parallel execution using OpenMP static load-balancing at compile time
__gnu_parallel::omp_loop_tagRecommends parallel execution using OpenMP dynamic load-balancing at compile time
__gnu_parallel::parallel_tagRecommends parallel execution at compile time, optionally using a user-specified number of threads
__gnu_parallel::quicksort_tagForces parallel sorting using unbalanced quicksort at compile time
__gnu_parallel::sampling_tagForces parallel merging with exact splitting, at compile time
__gnu_parallel::sequential_tagForces sequential execution at compile time
__gnu_parallel::unbalanced_tagRecommends parallel execution using static load-balancing at compile time
__gnu_pbds::associative_container_tagBasic associative-container
__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, Tag, Policy_TL, Allocator >An abstract basic hash-based associative container
__gnu_pbds::basic_hash_tagBasic hash
__gnu_pbds::basic_tree< Key, Mapped, Tag, Node_Update, Policy_Tl, Allocator >An abstract basic tree-like (tree, trie) associative container
__gnu_pbds::basic_tree_tagBasic tree
__gnu_pbds::binary_heap_tagBinary-heap (array-based)
__gnu_pbds::binomial_heap_tagBinomial-heap
__gnu_pbds::cc_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Hash_Fn, Resize_Policy, Store_Hash, Allocator >A concrete collision-chaining hash-based associative container
__gnu_pbds::cc_hash_tagCollision-chaining hash
__gnu_pbds::container_base< Key, Mapped, Tag, Policy_Tl, Allocator >An abstract basic associative container
__gnu_pbds::container_tagBase data structure tag
__gnu_pbds::container_traits< Cntnr >Container_traits
__gnu_pbds::detail::value_type_base< Key, Mapped, Allocator, false >
__gnu_pbds::detail::value_type_base< Key, Mapped, Allocator, true >
__gnu_pbds::detail::value_type_base< Key, null_mapped_type, Allocator, false >
__gnu_pbds::detail::value_type_base< Key, null_mapped_type, Allocator, true >
__gnu_pbds::gp_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Probe_Fn, Probe_Fn, Resize_Policy, Store_Hash, Allocator >A concrete general-probing hash-based associative container
__gnu_pbds::gp_hash_tagGeneral-probing hash
__gnu_pbds::list_update< Key, Mapped, Eq_Fn, Update_Policy, Allocator >A list-update based associative container
__gnu_pbds::list_update_tagList-update
__gnu_pbds::null_mapped_typeA mapped-policy indicating that an associative container is a set
__gnu_pbds::ov_tree_tagOrdered-vector tree
__gnu_pbds::pairing_heap_tagPairing-heap
__gnu_pbds::pat_trie_tagPATRICIA trie
__gnu_pbds::priority_queue_tagBasic priority-queue
__gnu_pbds::rb_tree_tagRed-black tree
__gnu_pbds::rc_binomial_heap_tagRedundant-counter binomial-heap
__gnu_pbds::sequence_tagBasic sequence
__gnu_pbds::splay_tree_tagSplay tree
__gnu_pbds::string_tagBasic string container, inclusive of strings, ropes, etc
__gnu_pbds::thin_heap_tagThin heap
__gnu_pbds::tree< Key, Mapped, Cmp_Fn, Tag, Node_Update, Allocator >A concrete basic tree-based associative container
__gnu_pbds::tree_tagTree
__gnu_pbds::trie< Key, Mapped, E_Access_Traits, Tag, Node_Update, Allocator >A concrete basic trie-based associative container
__gnu_pbds::trie_tagTrie
__gnu_profile::__container_size_infoA container size instrumentation line in the object table
__gnu_profile::__container_size_stack_infoA container size instrumentation line in the stack table
__gnu_profile::__hashfunc_infoA hash performance instrumentation line in the object table
__gnu_profile::__hashfunc_stack_infoA hash performance instrumentation line in the stack table
__gnu_profile::__list2vector_infoA list-to-vector instrumentation line in the object table
__gnu_profile::__map2umap_infoA map-to-unordered_map instrumentation line in the object table
__gnu_profile::__map2umap_stack_infoA map-to-unordered_map instrumentation line in the stack table
__gnu_profile::__object_info_baseBase class for a line in the object table
__gnu_profile::__reentrance_guardReentrance guard
__gnu_profile::__stack_hashHash function for summary trace using call stack as index
__gnu_profile::__stack_info_base< __object_info >Base class for a line in the stack table
__gnu_profile::__trace_base< __object_info, __stack_info >Base class for all trace producers
__gnu_profile::__trace_container_sizeContainer size instrumentation trace producer
__gnu_profile::__trace_hash_funcHash performance instrumentation producer
__gnu_profile::__trace_hashtable_sizeHashtable size instrumentation trace producer
__gnu_profile::__trace_map2umapMap-to-unordered_map instrumentation producer
__gnu_profile::__trace_vector_sizeHashtable size instrumentation trace producer
__gnu_profile::__trace_vector_to_listVector-to-list instrumentation producer
__gnu_profile::__vector2list_infoA vector-to-list instrumentation line in the object table
__gnu_profile::__vector2list_stack_infoA vector-to-list instrumentation line in the stack table
__gnu_profile::__warning_dataRepresentation of a warning
std::__atomic0::__atomic_base< _ITp >Base class for atomic integrals
std::__atomic0::__atomic_base< _PTp * >Partial specialization for pointer types
std::__atomic0::atomic_flagAtomic_flag
std::__atomic2::__atomic_base< _ITp >Base class for atomic integrals
std::__atomic2::__atomic_base< _PTp * >Partial specialization for pointer types
std::__atomic2::atomic_flagAtomic_flag
std::__atomic_flag_baseBase type for atomic_flag
std::__basic_future< _Res >Common implementation for future and shared_future
std::__codecvt_abstract_base< _InternT, _ExternT, _StateT >Common base for codecvt functions
std::__ctype_abstract_base< _CharT >Common base for ctype facet
std::__debug::bitset< _Nb >Class std::bitset with additional safety/checking/debug instrumentation
std::__debug::deque< _Tp, _Allocator >Class std::deque with safety/checking/debug instrumentation
std::__debug::forward_list< _Tp, _Alloc >Class std::forward_list with safety/checking/debug instrumentation
std::__debug::list< _Tp, _Allocator >Class std::list with safety/checking/debug instrumentation
std::__debug::map< _Key, _Tp, _Compare, _Allocator >Class std::map with safety/checking/debug instrumentation
std::__debug::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap with safety/checking/debug instrumentation
std::__debug::multiset< _Key, _Compare, _Allocator >Class std::multiset with safety/checking/debug instrumentation
std::__debug::set< _Key, _Compare, _Allocator >Class std::set with safety/checking/debug instrumentation
std::__debug::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map with safety/checking/debug instrumentation
std::__debug::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap with safety/checking/debug instrumentation
std::__debug::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Class std::unordered_multiset with safety/checking/debug instrumentation
std::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc >Class std::unordered_set with safety/checking/debug instrumentation
std::__debug::vector< _Tp, _Allocator >Class std::vector with safety/checking/debug instrumentation
std::__declval_protector< _Tp >Declval
std::__detail::_List_node_baseCommon part of a node in the list
std::__exception_ptr::exception_ptrAn opaque pointer to an arbitrary exception
std::__future_baseBase class and enclosing scope
std::__future_base::_Ptr< _Res >A unique_ptr based on the instantiating type
std::__future_base::_Result< _Res >Result
std::__future_base::_Result< _Res & >Partial specialization for reference types
std::__future_base::_Result< void >Explicit specialization for void
std::__future_base::_Result_alloc< _Res, _Alloc >Result_alloc
std::__future_base::_Result_baseBase class for results
std::__future_base::_StateShared state between a promise and one or more associated futures
std::__has_iterator_category_helper< _Tp >Traits class for iterators
std::__is_location_invariant< _Tp >
std::__is_member_pointer_helper< _Tp >Is_member_pointer
std::__numeric_limits_basePart of std::numeric_limits
std::__parallel::_CRandNumber< _MustBeInt >Functor wrapper for std::rand()
std::__profile::bitset< _Nb >Class std::bitset wrapper with performance instrumentation
std::__profile::deque< _Tp, _Allocator >Class std::deque wrapper with performance instrumentation
std::__profile::forward_list< _Tp, _Alloc >Class std::forward_list wrapper with performance instrumentation
std::__profile::list< _Tp, _Allocator >List wrapper with performance instrumentation
std::__profile::map< _Key, _Tp, _Compare, _Allocator >Class std::map wrapper with performance instrumentation
std::__profile::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap wrapper with performance instrumentation
std::__profile::multiset< _Key, _Compare, _Allocator >Class std::multiset wrapper with performance instrumentation
std::__profile::set< _Key, _Compare, _Allocator >Class std::set wrapper with performance instrumentation
std::__profile::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map wrapper with performance instrumentation
std::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap wrapper with performance instrumentation
std::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Unordered_multiset wrapper with performance instrumentation
std::__profile::unordered_set< _Key, _Hash, _Pred, _Alloc >Unordered_set wrapper with performance instrumentation
std::_Base_bitset< _Nw >
std::_Base_bitset< 0 >
std::_Base_bitset< 1 >
std::_Build_index_tuple< _Num >Builds an _Index_tuple<0, 1, 2, ..., _Num-1>
std::_Deque_base< _Tp, _Alloc >
std::_Deque_iterator< _Tp, _Ref, _Ptr >A deque::iterator
std::_Derives_from_binary_function< _Tp >Determines if the type _Tp derives from binary_function
std::_Derives_from_unary_function< _Tp >Determines if the type _Tp derives from unary_function
std::_Function_baseBase class of all polymorphic function object wrappers
std::_Function_to_function_pointer< _Tp, _IsFunctionType >Turns a function type into a function pointer type
std::_Fwd_list_base< _Tp, _Alloc >Base class for forward_list
std::_Fwd_list_const_iterator< _Tp >A forward_list::const_iterator
std::_Fwd_list_iterator< _Tp >A forward_list::iterator
std::_Fwd_list_node< _Tp >A helper node class for forward_list. This is just a linked list with a data value in each node. There is a sorting utility method
std::_Fwd_list_node_baseA helper basic node class for forward_list. This is just a linked list with nothing inside it. There are purely list shuffling utility methods here
std::_Index_tuple< _Indexes >
std::_List_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
std::_List_const_iterator< _Tp >A list::const_iterator
std::_List_iterator< _Tp >A list::iterator
std::_List_node< _Tp >An actual node in the list
std::_Maybe_get_result_type< _Has_result_type, _Functor >If we have found a result_type, extract it
std::_Maybe_unary_or_binary_function< _Res, _ArgTypes >
std::_Maybe_unary_or_binary_function< _Res, _T1 >Derives from unary_function, as appropriate
std::_Maybe_unary_or_binary_function< _Res, _T1, _T2 >Derives from binary_function, as appropriate
std::_Maybe_wrap_member_pointer< _Tp >
std::_Maybe_wrap_member_pointer< _Tp _Class::* >
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...) const >Implementation of mem_fn for const member function pointers
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...) const volatile >Implementation of mem_fn for const volatile member function pointers
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...) volatile >Implementation of mem_fn for volatile member function pointers
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...)>Implementation of mem_fn for member function pointers
std::_Mu< _Arg, false, false >
std::_Mu< _Arg, false, true >
std::_Mu< _Arg, true, false >
std::_Mu< reference_wrapper< _Tp >, false, false >
std::_Placeholder< _Num >The type of placeholder objects defined by libstdc++
std::_Reference_wrapper_base< _Tp >
std::_Safe_tuple_element< __i, _Tuple >
std::_Safe_tuple_element_impl< __i, _Tuple, _IsSafe >
std::_Safe_tuple_element_impl< __i, _Tuple, false >
std::_Temporary_buffer< _ForwardIterator, _Tp >
std::_Tuple_impl< _Idx >
std::_Tuple_impl< _Idx, _Head, _Tail...>
std::_Vector_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
std::_Weak_result_type< _Functor >
std::_Weak_result_type_impl< _Functor >
std::_Weak_result_type_impl< _Res(&)(_ArgTypes...)>Retrieve the result type for a function reference
std::_Weak_result_type_impl< _Res(*)(_ArgTypes...)>Retrieve the result type for a function pointer
std::_Weak_result_type_impl< _Res(_ArgTypes...)>Retrieve the result type for a function type
std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const >Retrieve result type for a const member function pointer
std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const volatile >Retrieve result type for a const volatile member function pointer
std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) volatile >Retrieve result type for a volatile member function pointer
std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...)>Retrieve result type for a member function pointer
std::add_const< _Tp >Add_const
std::add_cv< _Tp >Add_cv
std::add_lvalue_reference< _Tp >Add_lvalue_reference
std::add_pointer< _Tp >Add_pointer
std::add_rvalue_reference< _Tp >Add_rvalue_reference
std::add_volatile< _Tp >Add_volatile
std::adopt_lock_tAssume the calling thread has already obtained mutex ownership /// and manage it
std::aligned_storage< _Len, _Align >Alignment type
std::alignment_of< _Tp >Alignment_of
std::allocator< _Tp >The standard allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
std::allocator< void >Allocator<void> specialization
std::allocator_arg_t[allocator.tag]
std::array< _Tp, _Nm >A standard container for storing a fixed size sequence of elements
std::atomic< _Tp >Atomic /// 29.4.3, Generic atomic type, primary class template
std::atomic< _Tp * >Partial specialization for pointer types
std::atomic< bool >Explicit specialization for bool
std::atomic< char >Explicit specialization for char
std::atomic< char16_t >Explicit specialization for char16_t
std::atomic< char32_t >Explicit specialization for char32_t
std::atomic< int >Explicit specialization for int
std::atomic< long >Explicit specialization for long
std::atomic< long long >Explicit specialization for long long
std::atomic< short >Explicit specialization for short
std::atomic< signed char >Explicit specialization for signed char
std::atomic< unsigned char >Explicit specialization for unsigned char
std::atomic< unsigned int >Explicit specialization for unsigned int
std::atomic< unsigned long >Explicit specialization for unsigned long
std::atomic< unsigned long long >Explicit specialization for unsigned long long
std::atomic< unsigned short >Explicit specialization for unsigned short
std::atomic< wchar_t >Explicit specialization for wchar_t
std::atomic_boolAtomic_bool
std::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
std::auto_ptr_ref< _Tp1 >
std::back_insert_iterator< _Container >Turns assignment into insertion
std::bad_allocException possibly thrown by new.bad_alloc (or classes derived from it) is used to report allocation errors from the throwing forms of new
std::bad_castThrown during incorrect typecasting.If you attempt an invalid dynamic_cast expression, an instance of this class (or something derived from this class) is thrown
std::bad_exception
std::bad_function_callException class thrown when class template function's operator() is called with an empty target
std::bad_typeidThrown when a NULL pointer in a typeid expression is used
std::bad_weak_ptrException possibly thrown by shared_ptr
std::basic_filebuf< _CharT, _Traits >The actual work of input and output (for files).This class associates both its input and output sequence with an external disk file, and maintains a joint file position for both sequences. Many of its semantics are described in terms of similar behavior in the Standard C Library's FILE streams
std::basic_fstream< _CharT, _Traits >Controlling input and output for files.This class supports reading from and writing to named files, using the inherited functions from std::basic_iostream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as sb
std::basic_ifstream< _CharT, _Traits >Controlling input for files.This class supports reading from named files, using the inherited functions from std::basic_istream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as sb
std::basic_ios< _CharT, _Traits >Virtual base class for all stream classes.Most of the member functions called dispatched on stream objects (e.g., std::cout.foo(bar);) are consolidated in this class
std::basic_iostream< _CharT, _Traits >Merging istream and ostream capabilities.This class multiply inherits from the input and output stream classes simply to provide a single interface
std::basic_istream< _CharT, _Traits >Controlling input.This is the base class for all input streams. It provides text formatting of all builtin types, and communicates with any class derived from basic_streambuf to do the actual input
std::basic_istream< _CharT, _Traits >::sentryPerforms setup work for input streams
std::basic_istringstream< _CharT, _Traits, _Alloc >Controlling input for std::string.This class supports reading from objects of type std::basic_string, using the inherited functions from std::basic_istream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as sb
std::basic_ofstream< _CharT, _Traits >Controlling output for files.This class supports reading from named files, using the inherited functions from std::basic_ostream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as sb
std::basic_ostream< _CharT, _Traits >Controlling output.This is the base class for all output streams. It provides text formatting of all builtin types, and communicates with any class derived from basic_streambuf to do the actual output
std::basic_ostream< _CharT, _Traits >::sentryPerforms setup work for output streams
std::basic_ostringstream< _CharT, _Traits, _Alloc >Controlling output for std::string.This class supports writing to objects of type std::basic_string, using the inherited functions from std::basic_ostream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as sb
std::basic_regex< _Ch_type, _Rx_traits >
std::basic_streambuf< _CharT, _Traits >The actual work of input and output (interface).This is a base class. Derived stream buffers each control a pair of character sequences: one for input, and one for output
std::basic_string< _CharT, _Traits, _Alloc >Managing sequences of characters and character-like objects
std::basic_stringbuf< _CharT, _Traits, _Alloc >The actual work of input and output (for std::string).This class associates either or both of its input and output sequences with a sequence of characters, which can be initialized from, or made available as, a std::basic_string. (Paraphrased from [27.7.1]/1.)
std::basic_stringstream< _CharT, _Traits, _Alloc >Controlling input and output for std::string.This class supports reading from and writing to objects of type std::basic_string, using the inherited functions from std::basic_iostream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as sb
std::bernoulli_distributionA Bernoulli random number distribution
std::bernoulli_distribution::param_type
std::bidirectional_iterator_tagBidirectional iterators support a superset of forward iterator /// operations
std::binary_function< _Arg1, _Arg2, _Result >
std::binary_negate< _Predicate >One of the negation functors
std::binder1st< _Operation >One of the binder functors
std::binder2nd< _Operation >One of the binder functors
std::binomial_distribution< _IntType >A discrete binomial random number distribution
std::binomial_distribution< _IntType >::param_type
std::bitset< _Nb >The bitset class represents a fixed-size sequence of bits
std::bitset< _Nb >::reference
std::cauchy_distribution< _RealType >A cauchy_distribution random number distribution
std::cauchy_distribution< _RealType >::param_type
std::char_traits< _CharT >Basis for explicit traits specializations
std::char_traits< __gnu_cxx::character< V, I, S > >Char_traits<__gnu_cxx::character> specialization
std::char_traits< char >21.1.3.1 char_traits specializations
std::char_traits< wchar_t >21.1.3.2 char_traits specializations
std::chi_squared_distribution< _RealType >A chi_squared_distribution random number distribution
std::chi_squared_distribution< _RealType >::param_type
std::chrono::duration< _Rep, _Period >Duration
std::chrono::duration_values< _Rep >Duration_values
std::chrono::system_clockSystem_clock
std::chrono::time_point< _Clock, _Dur >Time_point
std::chrono::treat_as_floating_point< _Rep >Treat_as_floating_point
std::codecvt< _InternT, _ExternT, _StateT >Primary class template codecvt.NB: Generic, mostly useless implementation
std::codecvt< _InternT, _ExternT, encoding_state >Codecvt<InternT, _ExternT, encoding_state> specialization
std::codecvt< char, char, mbstate_t >Class codecvt<char, char, mbstate_t> specialization
std::codecvt< wchar_t, char, mbstate_t >Class codecvt<wchar_t, char, mbstate_t> specialization
std::codecvt_baseEmpty base class for codecvt facet [22.2.1.5]
std::codecvt_byname< _InternT, _ExternT, _StateT >Class codecvt_byname [22.2.1.6]
std::collate< _CharT >Facet for localized string comparison
std::collate_byname< _CharT >Class collate_byname [22.2.4.2]
std::complex< _Tp >
std::condition_variableCondition_variable
std::condition_variable_anyCondition_variable_any
std::conditional< _Cond, _Iftrue, _Iffalse >Conditional
std::const_mem_fun1_ref_t< _Ret, _Tp, _Arg >One of the adaptors for member /// pointers
std::const_mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member /// pointers
std::const_mem_fun_ref_t< _Ret, _Tp >One of the adaptors for member /// pointers
std::const_mem_fun_t< _Ret, _Tp >One of the adaptors for member /// pointers
std::ctype< _CharT >Primary class template ctype facet.This template class defines classification and conversion functions for character sets. It wraps cctype functionality. Ctype gets used by streams for many I/O operations
std::ctype< char >The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well
std::ctype< wchar_t >The ctype<wchar_t> specialization.This class defines classification and conversion functions for the wchar_t type. It gets used by wchar_t streams for many I/O operations. The wchar_t specialization provides a number of optimizations as well
std::ctype_baseBase class for ctype
std::ctype_byname< _CharT >Class ctype_byname [22.2.1.2]
std::ctype_byname< char >22.2.1.4 Class ctype_byname specializations
std::decay< _Tp >Decay
std::decimal::decimal1283.2.4 Class decimal128
std::decimal::decimal323.2.2 Class decimal32
std::decimal::decimal643.2.3 Class decimal64
std::default_delete< _Tp >Primary template, default_delete
std::default_delete< _Tp[]>Specialization, default_delete
std::defer_lock_tDo not acquire ownership of the mutex
std::deque< _Tp, _Alloc >A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
std::discard_block_engine< _RandomNumberEngine, __p, __r >
std::discrete_distribution< _IntType >A discrete_distribution random number distribution
std::discrete_distribution< _IntType >::param_type
std::divides< _Tp >One of the math functors
std::domain_error
std::enable_if< bool, _Tp >Enable_if
std::enable_shared_from_this< _Tp >Base class allowing use of member function shared_from_this
std::equal_to< _Tp >One of the comparison functors
std::error_categoryError_category
std::error_codeError_code
std::error_conditionError_condition
std::exceptionBase class for all library exceptions
std::exponential_distribution< _RealType >An exponential continuous distribution for random numbers
std::exponential_distribution< _RealType >::param_type
std::extent< typename, _Uint >Extent
std::extreme_value_distribution< _RealType >A extreme_value_distribution random number distribution
std::extreme_value_distribution< _RealType >::param_type
std::fisher_f_distribution< _RealType >A fisher_f_distribution random number distribution
std::fisher_f_distribution< _RealType >::param_type
std::forward_iterator_tagForward iterators support a superset of input iterator operations
std::forward_list< _Tp, _Alloc >A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
std::fpos< _StateT >Class representing stream positions
std::front_insert_iterator< _Container >Turns assignment into insertion
std::function< _Res(_ArgTypes...)>Primary class template for std::function.Polymorphic function wrapper
std::future< _Res >Primary template for future
std::future< _Res & >Partial specialization for future<R&>
std::future< void >Explicit specialization for future<void>
std::future_errorException type thrown by futures
std::gamma_distribution< _RealType >A gamma continuous distribution for random numbers
std::gamma_distribution< _RealType >::param_type
std::geometric_distribution< _IntType >A discrete geometric random number distribution
std::geometric_distribution< _IntType >::param_type
std::greater< _Tp >One of the comparison functors
std::greater_equal< _Tp >One of the comparison functors
std::gsliceClass defining multi-dimensional subset of an array
std::gslice_array< _Tp >Reference to multi-dimensional subset of an array
std::has_nothrow_copy_assign< _Tp >Has_nothrow_copy_assign
std::has_nothrow_copy_constructor< _Tp >Has_nothrow_copy_constructor
std::has_nothrow_default_constructor< _Tp >Has_nothrow_default_constructor
std::has_trivial_copy_assign< _Tp >Has_trivial_copy_assign
std::has_trivial_copy_constructor< _Tp >Has_trivial_copy_constructor
std::has_trivial_default_constructor< _Tp >Has_trivial_default_constructor
std::has_trivial_destructor< _Tp >Has_trivial_destructor
std::has_virtual_destructor< _Tp >Has_virtual_destructor
std::hash< _Tp >Primary class template hash
std::hash< __debug::bitset< _Nb > >Std::hash specialization for bitset
std::hash< __debug::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
std::hash< __gnu_cxx::__u16vstring >Std::hash specialization for __u16vstring
std::hash< __gnu_cxx::__u32vstring >Std::hash specialization for __u32vstring
std::hash< __gnu_cxx::__vstring >Std::hash specialization for __vstring
std::hash< __gnu_cxx::__wvstring >Std::hash specialization for __wvstring
std::hash< __gnu_cxx::throw_value_limit >Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hash< __gnu_cxx::throw_value_random >Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hash< __profile::bitset< _Nb > >Std::hash specialization for bitset
std::hash< __profile::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
std::hash< __shared_ptr< _Tp, _Lp > >Std::hash specialization for __shared_ptr
std::hash< _Tp * >Partial specializations for pointer types
std::hash< error_code >Std::hash specialization for error_code
std::hash< shared_ptr< _Tp > >Std::hash specialization for shared_ptr
std::hash< string >Std::hash specialization for string
std::hash< thread::id >Std::hash specialization for thread::id
std::hash< type_index >Std::hash specialization for type_index
std::hash< u16string >Std::hash specialization for u16string
std::hash< u32string >Std::hash specialization for u32string
std::hash< unique_ptr< _Tp, _Dp > >Std::hash specialization for unique_ptr
std::hash< wstring >Std::hash specialization for wstring
std::hash<::bitset< _Nb > >Std::hash specialization for bitset
std::hash<::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >
std::indirect_array< _Tp >Reference to arbitrary subset of an array
std::initializer_list< _E >Initializer_list
std::input_iterator_tagMarking input iterators
std::insert_iterator< _Container >Turns assignment into insertion
std::integral_constant< _Tp, __v >Integral_constant
std::invalid_argument
std::ios_baseThe base of the I/O class hierarchy.This class defines everything that can be defined about I/O that does not depend on the type of characters being input or output. Most people will only see ios_base when they need to specify the full name of the various I/O flags (e.g., the openmodes)
std::ios_base::failureThese are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
std::is_abstract< _Tp >Is_abstract
std::is_arithmetic< _Tp >Is_arithmetic
std::is_array< typename >Is_array
std::is_base_of< _Base, _Derived >Is_base_of
std::is_bind_expression< _Tp >Determines if the given type _Tp is a function object should be treated as a subexpression when evaluating calls to function objects returned by bind(). [TR1 3.6.1]
std::is_bind_expression< _Bind< _Signature > >Class template _Bind is always a bind expression
std::is_bind_expression< _Bind_result< _Result, _Signature > >Class template _Bind is always a bind expression
std::is_class< _Tp >Is_class
std::is_compound< _Tp >Is_compound
std::is_const< typename >Is_const
std::is_constructible< _Tp, _Args >Is_constructible
std::is_convertible< _From, _To >Is_convertible
std::is_empty< _Tp >Is_empty
std::is_enum< _Tp >Is_enum
std::is_error_code_enum< _Tp >Is_error_code_enum
std::is_error_code_enum< future_errc >Specialization
std::is_error_condition_enum< _Tp >Is_error_condition_enum
std::is_explicitly_convertible< _From, _To >Is_explicitly_convertible
std::is_floating_point< _Tp >Is_floating_point
std::is_function< typename >Is_function
std::is_fundamental< _Tp >Is_fundamental
std::is_integral< _Tp >Is_integral
std::is_literal_type< _Tp >Is_literal_type
std::is_lvalue_reference< typename >Is_lvalue_reference
std::is_member_function_pointer< _Tp >Is_member_function_pointer
std::is_member_object_pointer< _Tp >Is_member_object_pointer
std::is_nothrow_constructible< _Tp, _Args >Is_nothrow_constructible
std::is_object< _Tp >Is_object
std::is_placeholder< _Tp >Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
std::is_placeholder< _Placeholder< _Num > >
std::is_pod< _Tp >Is_pod
std::is_pointer< _Tp >Is_pointer
std::is_polymorphic< _Tp >Is_polymorphic
std::is_reference< _Tp >Is_reference
std::is_rvalue_reference< typename >Is_rvalue_reference
std::is_same< typename, typename >Is_same
std::is_scalar< _Tp >Is_scalar
std::is_signed< _Tp >Is_signed
std::is_standard_layout< _Tp >Is_standard_layout
std::is_trivial< _Tp >Is_trivial
std::is_union< _Tp >Is_union
std::is_unsigned< _Tp >Is_unsigned
std::is_void< _Tp >Is_void
std::is_volatile< typename >Is_volatile
std::istream_iterator< _Tp, _CharT, _Traits, _Dist >Provides input iterator semantics for streams
std::istreambuf_iterator< _CharT, _Traits >Provides input iterator semantics for streambufs
std::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >Common iterator class
std::iterator_traits< _Tp * >Partial specialization for pointer types
std::iterator_traits< const _Tp * >Partial specialization for const pointer types
std::length_error
std::less< _Tp >One of the comparison functors
std::less_equal< _Tp >One of the comparison functors
std::linear_congruential_engine< _UIntType, __a, __c, __m >A model of a linear congruential random number generator
std::list< _Tp, _Alloc >A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
std::localeContainer class for localization functionality.The locale class is first a class wrapper for C library locales. It is also an extensible container for user-defined localization. A locale is a collection of facets that implement various localization features such as money, time, and number printing
std::locale::facetLocalization functionality base class.The facet class is the base class for a localization feature, such as money, time, and number printing. It provides common support for facets and reference management
std::locale::idFacet ID class.The ID class provides facets with an index used to identify them. Every facet class must define a public static member locale::id, or be derived from a facet that provides this member, otherwise the facet cannot be used in a locale. The locale::id ensures that each class type gets a unique identifier
std::lock_guard< _Mutex >Scoped lock idiom
std::logic_errorOne of two subclasses of exception
std::logical_and< _Tp >One of the Boolean operations functors
std::logical_not< _Tp >One of the Boolean operations functors
std::logical_or< _Tp >One of the Boolean operations functors
std::lognormal_distribution< _RealType >A lognormal_distribution random number distribution
std::lognormal_distribution< _RealType >::param_type
std::make_signed< _Tp >Make_signed
std::make_unsigned< _Tp >Make_unsigned
std::map< _Key, _Tp, _Compare, _Alloc >A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::mask_array< _Tp >Reference to selected subset of an array
std::match_results< _Bi_iter, _Allocator >The results of a match or search operation
std::mem_fun1_ref_t< _Ret, _Tp, _Arg >One of the adaptors for member /// pointers
std::mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member /// pointers
std::mem_fun_ref_t< _Ret, _Tp >One of the adaptors for member /// pointers
std::mem_fun_t< _Ret, _Tp >One of the adaptors for member /// pointers
std::messages< _CharT >Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined
std::messages_baseMessages facet base class providing catalog typedef
std::messages_byname< _CharT >Class messages_byname [22.2.7.2]
std::minus< _Tp >One of the math functors
std::modulus< _Tp >One of the math functors
std::money_baseMoney format ordering data.This class contains an ordered array of 4 fields to represent the pattern for formatting a money amount. Each field may contain one entry from the part enum. symbol, sign, and value must be present and the remaining field must contain either none or space
std::money_get< _CharT, _InIter >Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
std::money_put< _CharT, _OutIter >Primary class template money_put.This facet encapsulates the code to format and output a monetary amount
std::moneypunct< _CharT, _Intl >Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
std::moneypunct_byname< _CharT, _Intl >Class moneypunct_byname [22.2.6.4]
std::move_iterator< _Iterator >
std::multimap< _Key, _Tp, _Compare, _Alloc >A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::multiplies< _Tp >One of the math functors
std::multiset< _Key, _Compare, _Alloc >A standard container made up of elements, which can be retrieved in logarithmic time
std::mutexMutex
std::negate< _Tp >One of the math functors
std::negative_binomial_distribution< _IntType >A negative_binomial_distribution random number distribution
std::negative_binomial_distribution< _IntType >::param_type
std::nested_exceptionException class with exception_ptr data member
std::normal_distribution< _RealType >A normal continuous distribution for random numbers
std::normal_distribution< _RealType >::param_type
std::not_equal_to< _Tp >One of the comparison functors
std::num_get< _CharT, _InIter >Primary class template num_get.This facet encapsulates the code to parse and return a number from a string. It is used by the istream numeric extraction operators
std::num_put< _CharT, _OutIter >Primary class template num_put.This facet encapsulates the code to convert a number to a string. It is used by the ostream numeric insertion operators
std::numeric_limits< _Tp >Properties of fundamental types
std::numeric_limits< bool >Numeric_limits<bool> specialization
std::numeric_limits< char >Numeric_limits<char> specialization
std::numeric_limits< char16_t >Numeric_limits<char16_t> specialization
std::numeric_limits< char32_t >Numeric_limits<char32_t> specialization
std::numeric_limits< double >Numeric_limits<double> specialization
std::numeric_limits< float >Numeric_limits<float> specialization
std::numeric_limits< int >Numeric_limits<int> specialization
std::numeric_limits< long >Numeric_limits<long> specialization
std::numeric_limits< long double >Numeric_limits<long double> specialization
std::numeric_limits< long long >Numeric_limits<long long> specialization
std::numeric_limits< short >Numeric_limits<short> specialization
std::numeric_limits< signed char >Numeric_limits<signed char> specialization
std::numeric_limits< unsigned char >Numeric_limits<unsigned char> specialization
std::numeric_limits< unsigned int >Numeric_limits<unsigned int> specialization
std::numeric_limits< unsigned long >Numeric_limits<unsigned long> specialization
std::numeric_limits< unsigned long long >Numeric_limits<unsigned long long> specialization
std::numeric_limits< unsigned short >Numeric_limits<unsigned short> specialization
std::numeric_limits< wchar_t >Numeric_limits<wchar_t> specialization
std::numpunct< _CharT >Primary class template numpunct.This facet stores several pieces of information related to printing and scanning numbers, such as the decimal point character. It takes a template parameter specifying the char type. The numpunct facet is used by streams for many I/O operations involving numbers
std::numpunct_byname< _CharT >Class numpunct_byname [22.2.3.2]
std::once_flagOnce_flag
std::ostream_iterator< _Tp, _CharT, _Traits >Provides output iterator semantics for streams
std::ostreambuf_iterator< _CharT, _Traits >Provides output iterator semantics for streambufs
std::out_of_range
std::output_iterator_tagMarking output iterators
std::overflow_error
std::owner_less< shared_ptr< _Tp > >Partial specialization of owner_less for shared_ptr
std::owner_less< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
std::packaged_task< _Res(_ArgTypes...)>Packaged_task
std::pair< _T1, _T2 >Struct holding two objects of arbitrary type
std::piecewise_constant_distribution< _RealType >A piecewise_constant_distribution random number distribution
std::piecewise_constant_distribution< _RealType >::param_type
std::piecewise_construct_tPiecewise_construct_t
std::piecewise_linear_distribution< _RealType >A piecewise_linear_distribution random number distribution
std::piecewise_linear_distribution< _RealType >::param_type
std::plus< _Tp >One of the math functors
std::pointer_to_binary_function< _Arg1, _Arg2, _Result >One of the adaptors for function pointers
std::pointer_to_unary_function< _Arg, _Result >One of the adaptors for function pointers
std::poisson_distribution< _IntType >A discrete Poisson random number distribution
std::poisson_distribution< _IntType >::param_type
std::priority_queue< _Tp, _Sequence, _Compare >A standard container automatically sorting its contents
std::promise< _Res >Primary template for promise
std::promise< _Res & >Partial specialization for promise<R&>
std::promise< void >Explicit specialization for promise<void>
std::queue< _Tp, _Sequence >A standard container giving FIFO behavior
std::random_access_iterator_tagRandom-access iterators support a superset of bidirectional /// iterator operations
std::random_device
std::range_error
std::rank< typename >Rank
std::ratio< _Num, _Den >Provides compile-time rational arithmetic
std::ratio_add< _R1, _R2 >Ratio_add
std::ratio_divide< _R1, _R2 >Ratio_divide
std::ratio_equal< _R1, _R2 >Ratio_equal
std::ratio_multiply< _R1, _R2 >Ratio_multiply
std::ratio_not_equal< _R1, _R2 >Ratio_not_equal
std::ratio_subtract< _R1, _R2 >Ratio_subtract
std::raw_storage_iterator< _OutputIterator, _Tp >
std::recursive_mutexRecursive_mutex
std::recursive_timed_mutexRecursive_timed_mutex
std::reference_wrapper< _Tp >Primary class template for reference_wrapper
std::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
std::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >
std::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >
std::regex_traits< _Ch_type >Describes aspects of a regular expression
std::remove_all_extents< _Tp >Remove_all_extents
std::remove_const< _Tp >Remove_const
std::remove_cv< _Tp >Remove_cv
std::remove_extent< _Tp >Remove_extent
std::remove_pointer< _Tp >Remove_pointer
std::remove_reference< _Tp >Remove_reference
std::remove_volatile< _Tp >Remove_volatile
std::reverse_iterator< _Iterator >
std::runtime_errorOne of two subclasses of exception
std::seed_seqGenerates sequences of seeds for random number generators
std::set< _Key, _Compare, _Alloc >A standard container made up of unique keys, which can be retrieved in logarithmic time
std::shared_future< _Res >Primary template for shared_future
std::shared_future< _Res & >Partial specialization for shared_future<R&>
std::shared_future< void >Explicit specialization for shared_future<void>
std::shared_ptr< _Tp >A smart pointer with reference-counted copy semantics
std::shuffle_order_engine< _RandomNumberEngine, __k >Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits __w
std::sliceClass defining one-dimensional subset of an array
std::slice_array< _Tp >Reference to one-dimensional subset of an array
std::stack< _Tp, _Sequence >A standard container giving FILO behavior
std::student_t_distribution< _RealType >A student_t_distribution random number distribution
std::student_t_distribution< _RealType >::param_type
std::sub_match< _BiIter >
std::system_errorThrown to indicate error code of underlying system
std::threadThread
std::thread::idThread::id
std::time_baseTime format ordering data.This class provides an enum representing different orderings of time: day, month, and year
std::time_get< _CharT, _InIter >Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators
std::time_get_byname< _CharT, _InIter >Class time_get_byname [22.2.5.2]
std::time_put< _CharT, _OutIter >Primary class template time_put.This facet encapsulates the code to format and output dates and times according to formats used by strftime()
std::time_put_byname< _CharT, _OutIter >Class time_put_byname [22.2.5.4]
std::timed_mutexTimed_mutex
std::try_to_lock_tTry to acquire ownership of the mutex without blocking
std::tuple< _Elements >Tuple
std::tuple< _T1 >Tuple (1-element)
std::tuple< _T1, _T2 >Tuple (2-element), with construction and assignment from a pair
std::tuple_element< 0, tuple< _Head, _Tail...> >
std::tuple_element< __i, tuple< _Head, _Tail...> >
std::tuple_size< tuple< _Elements...> >Class tuple_size
std::type_indexThe class type_index provides a simple wrapper for type_info which can be used as an index type in associative containers (23.6) and in unordered associative containers (23.7)
std::type_infoPart of RTTI
std::unary_function< _Arg, _Result >
std::unary_negate< _Predicate >One of the negation functors
std::underflow_error
std::uniform_int_distribution< _IntType >Uniform discrete distribution for random numbers. A discrete random distribution on the range $[min, max]$ with equal probability throughout the range
std::uniform_int_distribution< _IntType >::param_type
std::uniform_real_distribution< _RealType >Uniform continuous distribution for random numbers
std::uniform_real_distribution< _RealType >::param_type
std::unique_lock< _Mutex >Unique_lock
std::unique_ptr< _Tp, _Dp >20.7.12.2 unique_ptr for single objects
std::unique_ptr< _Tp[], _Dp >20.7.12.3 unique_ptr for array objects with a runtime length
std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys
std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
std::unordered_set< _Value, _Hash, _Pred, _Alloc >A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
std::uses_allocator< _Tp, _Alloc >[allocator.uses.trait]
std::valarray< _Tp >Smart array designed to support numeric processing
std::vector< _Tp, _Alloc >A standard container which offers fixed time access to individual elements in any order
std::vector< bool, _Alloc >A specialization of vector for booleans which offers fixed time access to individual elements in any order
std::weak_ptr< _Tp >A smart pointer with weak semantics
std::weibull_distribution< _RealType >A weibull_distribution random number distribution
std::weibull_distribution< _RealType >::param_type