libstdc++
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 C__atomic0::atomic_address29.4.2, address types
 C__atomic0::atomic_boolAtomic_bool
 C__atomic0::atomic_flagAtomic_flag
 C__atomic2::atomic_address29.4.2, address types
 C__atomic2::atomic_boolAtomic_bool
 C__atomic2::atomic_flagAtomic_flag
 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 >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::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::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_exception_errorThown by throw_allocator
 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::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::stdio_filebuf< _CharT, _Traits >Provides a layer of compatibility for C/POSIX
 C__gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >Class stdio_sync_filebuf
 C__gnu_cxx::throw_allocator_baseBase class
 C__gnu_debug::__is_same< _Type1, _Type2 >
 C__gnu_debug::_After_nth_from< _Iterator >
 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::_SettingsClass _Settings Run-time settings for the parallel mode, including all tunable parameters
 C__gnu_parallel::accumulate_binop_reduct< BinOp >General reduction, using a binary operator
 C__gnu_parallel::DRandomShufflingGlobalData< RandomAccessIterator >Data known to every thread participating in __gnu_parallel::parallel_random_shuffle()
 C__gnu_parallel::DRSSorterPU< RandomAccessIterator, RandomNumberGenerator >Local data for a thread participating in __gnu_parallel::parallel_random_shuffle()
 C__gnu_parallel::dummy_reductReduction function doing nothing
 C__gnu_parallel::find_tagBase class for for std::find() variants
 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::guarded_iterator< RandomAccessIterator, Comparator >Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
 C__gnu_parallel::iterator_triple< 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::loser_tree_traits< T >Traits for determining whether the loser tree should use pointers or copies
 C__gnu_parallel::LoserTreeBase< T, Comparator >Guarded loser/tournament tree
 C__gnu_parallel::LoserTreeBase< T, Comparator >::LoserInternal representation of a LoserTree element
 C__gnu_parallel::LoserTreePointerBase< T, Comparator >Base class of Loser Tree implementation using pointers
 C__gnu_parallel::LoserTreePointerBase< T, Comparator >::LoserInternal representation of LoserTree elements
 C__gnu_parallel::LoserTreePointerUnguardedBase< T, Comparator >Unguarded loser tree, keeping only pointers to the elements in the tree structure
 C__gnu_parallel::LoserTreeUnguardedBase< T, Comparator >Base class for unguarded LoserTree implementation
 C__gnu_parallel::max_element_reduct< Comp, It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::min_element_reduct< Comp, It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::multiway_merge_3_variant_sentinel_switch< sentinels, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for 3-way merging with sentinels turned off
 C__gnu_parallel::multiway_merge_3_variant_sentinel_switch< true, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for 3-way merging with sentinels turned on
 C__gnu_parallel::multiway_merge_4_variant_sentinel_switch< sentinels, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for 4-way merging with sentinels turned off
 C__gnu_parallel::multiway_merge_4_variant_sentinel_switch< true, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for 4-way merging with sentinels turned on
 C__gnu_parallel::multiway_merge_k_variant_sentinel_switch< sentinels, stable, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for k-way merging with sentinels turned on
 C__gnu_parallel::multiway_merge_k_variant_sentinel_switch< false, stable, RandomAccessIteratorIterator, RandomAccessIterator3, _DifferenceTp, Comparator >Switch for k-way merging with sentinels turned off
 C__gnu_parallel::nothingFunctor doing nothing
 C__gnu_parallel::parallel_tagRecommends parallel execution at compile time, optionally using a user-specified number of threads
 C__gnu_parallel::Piece< _DifferenceTp >Subsequence description
 C__gnu_parallel::PMWMSSortingData< RandomAccessIterator >Data accessed by all threads
 C__gnu_parallel::pseudo_sequence< T, _DifferenceTp >Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
 C__gnu_parallel::pseudo_sequence_iterator< T, _DifferenceTp >Iterator associated with __gnu_parallel::pseudo_sequence. If features the usual random-access iterator functionality
 C__gnu_parallel::QSBThreadLocal< RandomAccessIterator >Information local to one thread in the parallel quicksort run
 C__gnu_parallel::random_numberRandom number generator, based on the Mersenne twister
 C__gnu_parallel::RestrictedBoundedConcurrentQueue< T >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::sampling_sorter< stable, RandomAccessIterator, StrictWeakOrdering >Stable sorting functor
 C__gnu_parallel::sampling_sorter< false, RandomAccessIterator, StrictWeakOrdering >Non-stable sorting functor
 C__gnu_parallel::sequential_tagForces sequential execution at compile time
 C__gnu_parallel::split_consistently< exact, RandomAccessIterator, Comparator, SortingPlacesIterator >Split consistently
 C__gnu_parallel::split_consistently< false, RandomAccessIterator, Comparator, SortingPlacesIterator >Split by sampling
 C__gnu_parallel::split_consistently< true, RandomAccessIterator, Comparator, SortingPlacesIterator >Split by exact splitting
 C__gnu_parallel::void_functor< _ValueTp >Functor that does nothing
 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_cxx::__detail::_Bitmap_counter< _Alloc_block * >
 Cstd::_Deque_iterator< _Tp, _Tp &, _Tp * >
 Cstd::_Fwd_list_node_base< _Tp_alloc_type >
 Cstd::_Vector_base< __gnu_parallel::Piece< difference_type >, std::allocator< __gnu_parallel::Piece< difference_type > > >
 Cstd::_Vector_base< _Node *, _Nodeptr_Alloc >
 Cstd::basic_string< char >
 Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, 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, _Tp1 >
 Cstd::binary_function< const _Tp *, _Arg, _Ret >
 Cstd::binary_function< std::pair< T1, T2 >, std::pair< T1, T2 >, bool >
 Cstd::binary_function< T1, T2, bool >
 Cstd::binary_function< value_type, value_type, bool >
 C__gnu_pbds::container_traits_base< Cntnr::container_category >
 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::iterator_traits< _Tp >
 Cstd::pair< Iterator1, Iterator2 >
 Cstd::pair< RandomAccessIterator, RandomAccessIterator >
 C__gnu_parallel::RestrictedBoundedConcurrentQueue< pair< RandomAccessIterator, RandomAccessIterator > >
 Cstd::__parallel::c_rand_number< must_be_int >Functor wrapper for std::rand()
 Cstd::_Deque_base< _Tp, _Alloc >
 Cstd::_Deque_iterator< _Tp, _Ref, _Ptr >A deque::iterator
 Cstd::_Fnv_hash< size_t >Dummy generic implementation (for sizeof(size_t) != 4, 8)
 Cstd::_Fwd_list_base< _Tp, _Alloc >Base class for forward_list
 Cstd::_Fwd_list_const_iterator< _Tp, _Alloc >A forward_list::const_iterator
 Cstd::_Fwd_list_iterator< _Tp, _Alloc >A forward_list::iterator
 Cstd::_Fwd_list_node_base< _Alloc >A helper basic node class for forward_list. This is just a linked list with nothing inside it. There are purely list shuffling utility methods here
 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::_List_node_baseCommon part of a node in the list
 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::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
 Cstd::auto_ptr_ref< _Tp1 >
 Cstd::basic_string< _CharT, _Traits, _Alloc >Managing sequences of characters and character-like objects
 Cstd::binary_function< _Arg1, _Arg2, _Result >
 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::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::fpos< _StateT >Class representing stream positions
 Cstd::gsliceClass defining multi-dimensional subset of an array
 Cstd::gslice_array< _Tp >Reference to multi-dimensional subset of an array
 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< _Iterator >
 Cstd::localeContainer class for localization functionality
 Cstd::locale::facetLocalization functionality base class
 Cstd::locale::idFacet ID class
 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
 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::output_iterator_tagMarking output iterators
 Cstd::pair< _T1, _T2 >Pair holds two objects of arbitrary 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::reference_wrapper< _Tp >A convenience wrapper for creating a pair from two objects
 Cstd::set< _Key, _Compare, _Alloc >A standard container made up of unique keys, which can be retrieved in logarithmic time
 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::time_baseTime format ordering data
 Cstd::tr1::__detail::__floating_point_constant< _Tp >A class to encapsulate type dependent floating point constants. Not everything will be able to be expressed as type logic
 Cstd::tr1::__detail::__numeric_constants< _Tp >A structure for numeric constants
 Cstd::unary_function< _Arg, _Result >
 Cstd::unique_ptr< _Tp, _Tp_Deleter >20.7.12.2 unique_ptr for single objects
 Cstd::unique_ptr< _Tp[], _Tp_Deleter >20.7.12.3 unique_ptr for array objects with a runtime length
 Cstd::vector< bool, _Alloc >A specialization of vector for booleans which offers fixed time access to individual elements in any order
 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< _Tp *, _Ret >
 Cstd::unary_function< _Tp *, size_t >
 Cstd::unary_function< _Tp, _Ret >
 Cstd::unary_function< _Tp, _Tp >
 Cstd::unary_function< _Tp, bool >
 Cstd::unary_function< _Tp, size_t >
 Cstd::unary_function< argument_type, bool >
 Cstd::unary_function< const _Tp *, _Ret >
 Cstd::unary_function< first_argument_type, result_type >
 Cstd::unary_function< second_argument_type, result_type >
 Cstd::unary_function< std::pair< _Tp, _Tp >, bool >