libstdc++
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 C__cxxabiv1::__forced_unwindThrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
 C__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >Policy for shared __pool objects
 C__gnu_cxx::__detail::__mini_vector< _Tp >__mini_vector<> is a stripped down version of the full-fledged std::vector<>
 C__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
 C__gnu_cxx::__mt_alloc_base< _Tp >Base class for _Tp dependent member functions
 C__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread >Policy for individual __pool objects
 C__gnu_cxx::__pool< _Thread >Data describing the underlying memory pool, parameterized on threading support
 C__gnu_cxx::__pool_alloc_baseBase class for __pool_alloc
 C__gnu_cxx::__pool_baseBase class for pool object
 C__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >
 C__gnu_cxx::__scoped_lockScoped lock idiom
 C__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >Template class __versa_string.Data structure managing sequences of characters and character-like objects
 C__gnu_cxx::_Caster< _ToType >
 C__gnu_cxx::_Char_types< _CharT >Mapping from character type to associated types
 C__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
 C__gnu_cxx::_Invalid_type
 C__gnu_cxx::_Pointer_adapter< _Storage_policy >
 C__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
 C__gnu_cxx::_Relative_pointer_impl< const _Tp >
 C__gnu_cxx::_Std_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which yields a standard pointer
 C__gnu_cxx::_Unqualified_type< _Tp >
 C__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
 C__gnu_cxx::array_allocator_base< _Tp >Base class
 C__gnu_cxx::char_traits< _CharT >Base class used to implement std::char_traits
 C__gnu_cxx::character< V, I, S >A POD class that serves as a character abstraction class
 C__gnu_cxx::condition_baseBase struct for condition policy
 C__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
 C__gnu_cxx::enc_filebuf< _CharT >Class enc_filebuf
 C__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
 C__gnu_cxx::forced_errorThown by exception safety machinery
 C__gnu_cxx::free_listThe free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
 C__gnu_cxx::limit_condition::always_adjustorAlways enter the condition
 C__gnu_cxx::limit_condition::limit_adjustorEnter the nth condition
 C__gnu_cxx::limit_condition::never_adjustorNever enter the condition
 C__gnu_cxx::malloc_allocator< _Tp >An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
 C__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
 C__gnu_cxx::random_condition::always_adjustorAlways enter the condition
 C__gnu_cxx::random_condition::group_adjustorGroup condition
 C__gnu_cxx::random_condition::never_adjustorNever enter the condition
 C__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
 C__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>
 C__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>
 C__gnu_cxx::throw_value_base< _Cond >Class with exception generation control. Intended to be used as a value_type in templatized code
 C__gnu_debug::_After_nth_from< _Iterator >
 C__gnu_debug::_BeforeBeginHelper< _Sequence >
 C__gnu_debug::_Equal_to< _Type >
 C__gnu_debug::_Not_equal_to< _Type >
 C__gnu_debug::_Safe_iterator_baseBasic functionality for a safe iterator
 C__gnu_debug::_Safe_sequence_baseBase class that supports tracking of iterators that reference a sequence
 C__gnu_parallel::__accumulate_binop_reduct< _BinOp >General reduction, using a binary operator
 C__gnu_parallel::__generic_find_selectorBase class of all __gnu_parallel::__find_template selectors
 C__gnu_parallel::__generic_for_each_selector< _It >Generic __selector for embarrassingly parallel functions
 C__gnu_parallel::__max_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::__min_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned off
 C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned off
 C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned off
 C__gnu_parallel::_DRandomShufflingGlobalData< _RAIter >Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
 C__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator >Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
 C__gnu_parallel::_DummyReductReduction function doing nothing
 C__gnu_parallel::_GuardedIterator< _RAIter, _Compare >_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
 C__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory >A triple of iterators. The usual iterator operations are applied to all three child iterators
 C__gnu_parallel::_Job< _DifferenceTp >One __job for a certain thread
 C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >Guarded loser/tournament tree
 C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_LoserInternal representation of a _LoserTree element
 C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >Base class of _Loser Tree implementation using pointers
 C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_LoserInternal representation of _LoserTree __elements
 C__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare >Unguarded loser tree, keeping only pointers to the elements in the tree structure
 C__gnu_parallel::_LoserTreeTraits< _Tp >Traits for determining whether the loser tree should use pointers or copies
 C__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >Base class for unguarded _LoserTree implementation
 C__gnu_parallel::_NothingFunctor doing nothing
 C__gnu_parallel::_Piece< _DifferenceTp >Subsequence description
 C__gnu_parallel::_PMWMSSortingData< _RAIter >Data accessed by all threads
 C__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp >Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
 C__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp >_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
 C__gnu_parallel::_QSBThreadLocal< _RAIter >Information local to one thread in the parallel quicksort run
 C__gnu_parallel::_RandomNumberRandom number generator, based on the Mersenne twister
 C__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
 C__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >Stable sorting functor
 C__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >Non-__stable sorting functor
 C__gnu_parallel::_SettingsClass _Settings Run-time settings for the parallel mode including all tunable parameters
 C__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator >Split consistently
 C__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >Split by sampling
 C__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >Split by exact splitting
 C__gnu_parallel::find_tagBase class for for std::find() variants
 C__gnu_parallel::parallel_tagRecommends parallel execution at compile time, optionally using a user-specified number of threads
 C__gnu_parallel::sequential_tagForces sequential execution at compile time
 C__gnu_pbds::container_base< Key, Mapped, Tag, Policy_Tl, Allocator >An abstract basic associative container
 C__gnu_pbds::container_tagBase data structure tag
 C__gnu_pbds::container_traits_base< Tag >Base traits type for containers
 C__gnu_pbds::detail::value_type_base< Key, Mapped, Allocator, false >
 C__gnu_pbds::detail::value_type_base< Key, Mapped, Allocator, true >
 C__gnu_pbds::detail::value_type_base< Key, null_mapped_type, Allocator, false >
 C__gnu_pbds::detail::value_type_base< Key, null_mapped_type, Allocator, true >
 C__gnu_pbds::null_mapped_typeA mapped-policy indicating that an associative container is a set
 C__gnu_profile::__object_info_baseBase class for a line in the object table
 C__gnu_profile::__reentrance_guardReentrance guard
 C__gnu_profile::__stack_hashHash function for summary trace using call stack as index
 C__gnu_profile::__stack_info_base< __object_info >Base class for a line in the stack table
 C__gnu_profile::__trace_base< __object_info, __stack_info >Base class for all trace producers
 C__gnu_profile::__warning_dataRepresentation of a warning
 Cstd::__iterator_traits< _Iterator >
 Cstd::__iterator_traits< _Tp >
 C__gnu_profile::__trace_base< __container_size_info, __container_size_stack_info >
 C__gnu_profile::__trace_base< __hashfunc_info, __hashfunc_stack_info >
 C__gnu_profile::__trace_base< __list2slist_info, __list2slist_stack_info >
 C__gnu_profile::__trace_base< __list2vector_info, __list2vector_stack_info >
 C__gnu_profile::__trace_base< __map2umap_info, __map2umap_stack_info >
 C__gnu_profile::__trace_base< __vector2list_info, __vector2list_stack_info >
 C__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >
 Cstd::_Deque_iterator< _Tp, _Tp &, _Tp * >
 C__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
 Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > >
 Cstd::_Vector_base< _Node *, _Nodeptr_Alloc >
 Cstd::_Vector_base< _RealType, std::allocator< _RealType > >
 Cstd::_Vector_base< _State, std::allocator< _State > >
 Cstd::_Vector_base< _StateSeq, std::allocator< _StateSeq > >
 Cstd::_Vector_base< double, std::allocator< double > >
 Cstd::_Vector_base< int, std::allocator< int > >
 Cstd::_Vector_base< result_type, std::allocator< result_type > >
 Cstd::_Vector_base< sub_match< _Bi_iter >, _Allocator >
 Cstd::allocator< value_type >
 Cstd::basic_string< _CharT >
 Cstd::basic_string< char >
 Cstd::binary_function< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool >
 Cstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool >
 Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool >
 Cstd::binary_function< _Sp, _Sp, bool >
 Cstd::binary_function< _T1, _T2, bool >
 Cstd::binary_function< _Tp *, _Arg, _Ret >
 Cstd::binary_function< _Tp, _Arg, _Ret >
 Cstd::binary_function< _Tp, _Tp, _Tp >
 Cstd::binary_function< _Tp, _Tp, bool >
 Cstd::binary_function< _Tp1, _Tp2, _Result >
 Cstd::binary_function< const _Tp *, _Arg, _Ret >
 Cstd::binary_function< shared_ptr< _Tp >, shared_ptr< _Tp >, bool >
 Cstd::binary_function< std::pair< _T1, _T2 >, std::pair< _T1, _T2 >, bool >
 Cstd::binary_function< value_type, value_type, bool >
 Cstd::binary_function< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >
 C__gnu_pbds::container_base< Key, Mapped, cc_hash_tag, __gnu_cxx::typelist::append< __gnu_cxx::typelist::create4< Hash_Fn, Eq_Fn, Resize_Policy, detail::integral_constant< int, Store_Hash > >::type, __gnu_cxx::typelist::create1< Comb_Hash_Fn >::type >::type, Allocator >
 C__gnu_pbds::container_base< Key, Mapped, gp_hash_tag, __gnu_cxx::typelist::append< __gnu_cxx::typelist::create4< Hash_Fn, Eq_Fn, Resize_Policy, detail::integral_constant< int, Store_Hash > >::type, __gnu_cxx::typelist::create2< Comb_Probe_Fn, Probe_Fn >::type >::type, Allocator >
 C__gnu_pbds::container_base< Key, Mapped, list_update_tag, __gnu_cxx::typelist::create2< Eq_Fn, Update_Policy >::type, Allocator >
 C__gnu_pbds::container_base< Key, Mapped, Tag, __gnu_cxx::typelist::append< __gnu_cxx::typelist::create4< Hash_Fn, Eq_Fn, Resize_Policy, detail::integral_constant< int, Store_Hash > >::type, Policy_TL >::type, Allocator >
 C__gnu_pbds::container_base< Key, Mapped, Tag, __gnu_cxx::typelist::create2< Cmp_Fn, detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Tag, Allocator > >::type, Allocator >
 C__gnu_pbds::container_base< Key, Mapped, Tag, __gnu_cxx::typelist::create2< E_Access_Traits, detail::trie_traits< Key, Mapped, E_Access_Traits, Node_Update, Tag, Allocator > >::type, Allocator >
 C__gnu_pbds::container_traits_base< Cntnr::container_category >
 Cstd::gamma_distribution< double >
 Cstd::gamma_distribution< result_type >
 Cstd::iterator< input_iterator_tag, _CharT, _Traits::off_type, _CharT *, _CharT & >
 Cstd::iterator< input_iterator_tag, _Tp, _Dist, const _Tp *, const _Tp & >
 Cstd::iterator< iterator_traits< _Iterator >::iterator_category, iterator_traits< _Iterator >::value_type, iterator_traits< _Iterator >::difference_type, iterator_traits< _Iterator >::pointer, iterator_traits< _Iterator >::reference >
 Cstd::iterator< output_iterator_tag, void, void, void, void >
 Cstd::iterator< std::random_access_iterator_tag, bool >
 Cstd::normal_distribution< double >
 Cstd::normal_distribution< result_type >
 Cstd::pair< _BiIter, _BiIter >
 Cstd::pair< _Iterator1, _Iterator2 >
 Cstd::pair< _RAIter, _RAIter >
 Cstd::set< _StateIdT >
 Cstd::shared_ptr< _Automaton >
 Cstd::shared_ptr< _Nfa >
 Cstd::stack< _StateSeq, std::vector< _StateSeq > >
 Cstd::__atomic0::__atomic_base< _ITp >Base class for atomic integrals
 Cstd::__atomic0::__atomic_base< _PTp * >Partial specialization for pointer types
 Cstd::__atomic2::__atomic_base< _ITp >Base class for atomic integrals
 Cstd::__atomic2::__atomic_base< _PTp * >Partial specialization for pointer types
 Cstd::__atomic_flag_baseBase type for atomic_flag
 Cstd::__detail::_List_node_baseCommon part of a node in the list
 Cstd::__exception_ptr::exception_ptrAn opaque pointer to an arbitrary exception
 Cstd::__iterator_traits< _Iterator, bool >Traits class for iterators
 Cstd::__parallel::_CRandNumber< _MustBeInt >Functor wrapper for std::rand()
 Cstd::__profile::map< _Key, _Tp, _Compare, _Allocator >Class std::map wrapper with performance instrumentation
 Cstd::__profile::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap wrapper with performance instrumentation
 Cstd::__profile::multiset< _Key, _Compare, _Allocator >Class std::multiset wrapper with performance instrumentation
 Cstd::__profile::set< _Key, _Compare, _Allocator >Class std::set wrapper with performance instrumentation
 Cstd::_Deque_base< _Tp, _Alloc >
 Cstd::_Deque_iterator< _Tp, _Ref, _Ptr >A deque::iterator
 Cstd::_Fwd_list_base< _Tp, _Alloc >Base class for forward_list
 Cstd::_Fwd_list_const_iterator< _Tp >A forward_list::const_iterator
 Cstd::_Fwd_list_iterator< _Tp >A forward_list::iterator
 Cstd::_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
 Cstd::_List_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
 Cstd::_List_const_iterator< _Tp >A list::const_iterator
 Cstd::_List_iterator< _Tp >A list::iterator
 Cstd::_Temporary_buffer< _ForwardIterator, _Tp >
 Cstd::_Vector_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
 Cstd::allocator< _Tp >The standard allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
 Cstd::allocator< void >Allocator<void> specialization
 Cstd::allocator_arg_t[allocator.tag]
 Cstd::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
 Cstd::auto_ptr_ref< _Tp1 >
 Cstd::bad_weak_ptrException possibly thrown by shared_ptr
 Cstd::basic_regex< _Ch_type, _Rx_traits >
 Cstd::basic_string< _CharT, _Traits, _Alloc >Managing sequences of characters and character-like objects
 Cstd::bernoulli_distributionA Bernoulli random number distribution
 Cstd::bernoulli_distribution::param_type
 Cstd::binary_function< _Arg1, _Arg2, _Result >
 Cstd::binomial_distribution< _IntType >A discrete binomial random number distribution
 Cstd::binomial_distribution< _IntType >::param_type
 Cstd::cauchy_distribution< _RealType >A cauchy_distribution random number distribution
 Cstd::cauchy_distribution< _RealType >::param_type
 Cstd::char_traits< __gnu_cxx::character< V, I, S > >Char_traits<__gnu_cxx::character> specialization
 Cstd::char_traits< char >21.1.3.1 char_traits specializations
 Cstd::char_traits< wchar_t >21.1.3.2 char_traits specializations
 Cstd::chi_squared_distribution< _RealType >A chi_squared_distribution random number distribution
 Cstd::chi_squared_distribution< _RealType >::param_type
 Cstd::codecvt_baseEmpty base class for codecvt facet [22.2.1.5]
 Cstd::ctype_baseBase class for ctype
 Cstd::default_delete< _Tp >Primary template, default_delete
 Cstd::default_delete< _Tp[]>Specialization, default_delete
 Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >
 Cstd::discrete_distribution< _IntType >A discrete_distribution random number distribution
 Cstd::discrete_distribution< _IntType >::param_type
 Cstd::enable_shared_from_this< _Tp >Base class allowing use of member function shared_from_this
 Cstd::exponential_distribution< _RealType >An exponential continuous distribution for random numbers
 Cstd::exponential_distribution< _RealType >::param_type
 Cstd::extreme_value_distribution< _RealType >A extreme_value_distribution random number distribution
 Cstd::extreme_value_distribution< _RealType >::param_type
 Cstd::fisher_f_distribution< _RealType >A fisher_f_distribution random number distribution
 Cstd::fisher_f_distribution< _RealType >::param_type
 Cstd::fpos< _StateT >Class representing stream positions
 Cstd::gamma_distribution< _RealType >A gamma continuous distribution for random numbers
 Cstd::gamma_distribution< _RealType >::param_type
 Cstd::geometric_distribution< _IntType >A discrete geometric random number distribution
 Cstd::geometric_distribution< _IntType >::param_type
 Cstd::gsliceClass defining multi-dimensional subset of an array
 Cstd::gslice_array< _Tp >Reference to multi-dimensional subset of an array
 Cstd::hash< _Tp >Primary class template hash
 Cstd::hash< __gnu_cxx::__u16vstring >Std::hash specialization for __u16vstring
 Cstd::hash< __gnu_cxx::__u32vstring >Std::hash specialization for __u32vstring
 Cstd::hash< __gnu_cxx::__vstring >Std::hash specialization for __vstring
 Cstd::hash< __gnu_cxx::__wvstring >Std::hash specialization for __wvstring
 Cstd::hash< _Tp * >Partial specializations for pointer types
 Cstd::hash< string >Std::hash specialization for string
 Cstd::hash< u16string >Std::hash specialization for u16string
 Cstd::hash< u32string >Std::hash specialization for u32string
 Cstd::hash< wstring >Std::hash specialization for wstring
 Cstd::hash<::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
 Cstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >
 Cstd::indirect_array< _Tp >Reference to arbitrary subset of an array
 Cstd::input_iterator_tagMarking input iterators
 Cstd::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)
 Cstd::ios_base::failureThese are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
 Cstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >Common iterator class
 Cstd::iterator_traits< _Tp * >Partial specialization for pointer types
 Cstd::iterator_traits< const _Tp * >Partial specialization for const pointer types
 Cstd::linear_congruential_engine< _UIntType, __a, __c, __m >A model of a linear congruential random number generator
 Cstd::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
 Cstd::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
 Cstd::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
 Cstd::lognormal_distribution< _RealType >A lognormal_distribution random number distribution
 Cstd::lognormal_distribution< _RealType >::param_type
 Cstd::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
 Cstd::mask_array< _Tp >Reference to selected subset of an array
 Cstd::messages_baseMessages facet base class providing catalog typedef
 Cstd::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
 Cstd::move_iterator< _Iterator >
 Cstd::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
 Cstd::multiset< _Key, _Compare, _Alloc >A standard container made up of elements, which can be retrieved in logarithmic time
 Cstd::negative_binomial_distribution< _IntType >A negative_binomial_distribution random number distribution
 Cstd::negative_binomial_distribution< _IntType >::param_type
 Cstd::nested_exceptionException class with exception_ptr data member
 Cstd::normal_distribution< _RealType >A normal continuous distribution for random numbers
 Cstd::normal_distribution< _RealType >::param_type
 Cstd::output_iterator_tagMarking output iterators
 Cstd::owner_less< _Tp >Primary template owner_less
 Cstd::owner_less< shared_ptr< _Tp > >Partial specialization of owner_less for shared_ptr
 Cstd::owner_less< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
 Cstd::pair< _T1, _T2 >Struct holding two objects of arbitrary type
 Cstd::piecewise_constant_distribution< _RealType >A piecewise_constant_distribution random number distribution
 Cstd::piecewise_constant_distribution< _RealType >::param_type
 Cstd::piecewise_construct_tPiecewise_construct_t
 Cstd::piecewise_linear_distribution< _RealType >A piecewise_linear_distribution random number distribution
 Cstd::piecewise_linear_distribution< _RealType >::param_type
 Cstd::poisson_distribution< _IntType >A discrete Poisson random number distribution
 Cstd::poisson_distribution< _IntType >::param_type
 Cstd::priority_queue< _Tp, _Sequence, _Compare >A standard container automatically sorting its contents
 Cstd::queue< _Tp, _Sequence >A standard container giving FIFO behavior
 Cstd::random_device
 Cstd::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
 Cstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_traits< _Ch_type >Describes aspects of a regular expression
 Cstd::seed_seqGenerates sequences of seeds for random number generators
 Cstd::set< _Key, _Compare, _Alloc >A standard container made up of unique keys, which can be retrieved in logarithmic time
 Cstd::shared_ptr< _Tp >A smart pointer with reference-counted copy semantics
 Cstd::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
 Cstd::sliceClass defining one-dimensional subset of an array
 Cstd::slice_array< _Tp >Reference to one-dimensional subset of an array
 Cstd::stack< _Tp, _Sequence >A standard container giving FILO behavior
 Cstd::student_t_distribution< _RealType >A student_t_distribution random number distribution
 Cstd::student_t_distribution< _RealType >::param_type
 Cstd::time_baseTime format ordering data.This class provides an enum representing different orderings of time: day, month, and year
 Cstd::unary_function< _Arg, _Result >
 Cstd::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
 Cstd::uniform_int_distribution< _IntType >::param_type
 Cstd::uniform_real_distribution< _RealType >Uniform continuous distribution for random numbers
 Cstd::uniform_real_distribution< _RealType >::param_type
 Cstd::unique_ptr< _Tp, _Dp >20.7.12.2 unique_ptr for single objects
 Cstd::unique_ptr< _Tp[], _Dp >20.7.12.3 unique_ptr for array objects with a runtime length
 Cstd::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
 Cstd::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
 Cstd::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
 Cstd::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
 Cstd::uses_allocator< _Tp, _Alloc >[allocator.uses.trait]
 Cstd::vector< bool, _Alloc >A specialization of vector for booleans which offers fixed time access to individual elements in any order
 Cstd::weak_ptr< _Tp >A smart pointer with weak semantics
 Cstd::weibull_distribution< _RealType >A weibull_distribution random number distribution
 Cstd::weibull_distribution< _RealType >::param_type
 Cstd::unary_function< __gnu_cxx::throw_value_limit, size_t >
 Cstd::unary_function< __gnu_cxx::throw_value_random, size_t >
 Cstd::unary_function< __shared_ptr< _Tp, _Lp >, size_t >
 Cstd::unary_function< _FirstArgumentType, _ResultType >
 Cstd::unary_function< _Functor::argument_type, _Functor::result_type >
 Cstd::unary_function< _Operation::first_argument_type, _Operation::result_type >
 Cstd::unary_function< _Operation::second_argument_type, _Operation::result_type >
 Cstd::unary_function< _Pair, _Pair::first_type >
 Cstd::unary_function< _Pair, _Pair::second_type >
 Cstd::unary_function< _Predicate::argument_type, bool >
 Cstd::unary_function< _SecondArgumentType, _ResultType >
 Cstd::unary_function< _Tp *, _Ret >
 Cstd::unary_function< _Tp, _Ret >
 Cstd::unary_function< _Tp, _Tp >
 Cstd::unary_function< _Tp, bool >
 Cstd::unary_function< argument_type, bool >
 Cstd::unary_function< const _Tp *, _Ret >
 Cstd::unary_function< shared_ptr< _Tp >, size_t >
 Cstd::unary_function< std::pair< _Tp, _Tp >, bool >
 Cstd::unary_function< unique_ptr< _Tp, _Dp >, size_t >