Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
__atomic0::atomic_address29.4.2, address types
__atomic0::atomic_boolAtomic_bool
__atomic0::atomic_flagAtomic_flag
__atomic2::atomic_address29.4.2, address types
__atomic2::atomic_boolAtomic_bool
__atomic2::atomic_flagAtomic_flag
__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_policyPolicy for shared __pool objects
__gnu_cxx::__detail::__mini_vector__mini_vector<> is a stripped down version of the full-fledged std::vector<>
__gnu_cxx::__detail::_Bitmap_counterThe 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_finderThe class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
__gnu_cxx::__mt_allocThis 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_baseBase class for _Tp dependent member functions
__gnu_cxx::__per_type_pool_policyPolicy for individual __pool objects
__gnu_cxx::__poolSpecialization for single thread
__gnu_cxx::__poolSpecialization for thread enabled, via gthreads.h
__gnu_cxx::__pool_allocAllocator 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
__gnu_cxx::__scoped_lockScoped lock idiom
__gnu_cxx::__versa_stringManaging sequences of characters and character-like objects
__gnu_cxx::_Caster
__gnu_cxx::_Char_typesMapping from character type to associated types
__gnu_cxx::_ExtPtr_allocatorAn 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
__gnu_cxx::_Relative_pointer_implA 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
__gnu_cxx::_Std_pointer_implA storage policy for use with _Pointer_adapter<> which yields a standard pointer
__gnu_cxx::_Unqualified_type
__gnu_cxx::array_allocatorAn allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
__gnu_cxx::array_allocator_baseBase class
__gnu_cxx::binary_composeAn SGI extension
__gnu_cxx::bitmap_allocatorBitmap Allocator, primary template
__gnu_cxx::char_traitsBase class used to implement std::char_traits
__gnu_cxx::characterA POD class that serves as a character abstraction class
__gnu_cxx::constant_binary_funAn SGI extension
__gnu_cxx::constant_unary_funAn SGI extension
__gnu_cxx::constant_void_funAn SGI extension
__gnu_cxx::debug_allocatorA 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_filebufClass enc_filebuf
__gnu_cxx::encoding_char_traitsEncoding_char_traits
__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
__gnu_cxx::forced_exception_errorThown by throw_allocator
__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
__gnu_cxx::hash_multimap
__gnu_cxx::hash_multiset
__gnu_cxx::hash_set
__gnu_cxx::malloc_allocatorAn 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_allocatorAn 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::project1stAn SGI extension
__gnu_cxx::project2ndAn SGI extension
__gnu_cxx::rb_tree
__gnu_cxx::rope
__gnu_cxx::select1stAn SGI extension
__gnu_cxx::select2ndAn SGI extension
__gnu_cxx::slist
__gnu_cxx::stdio_filebufProvides a layer of compatibility for C/POSIX
__gnu_cxx::stdio_sync_filebufClass stdio_sync_filebuf
__gnu_cxx::subtractive_rng
__gnu_cxx::temporary_buffer
__gnu_cxx::throw_allocatorAllocator class with logging and exception control
__gnu_cxx::throw_allocator_baseBase class
__gnu_cxx::unary_composeAn SGI extension
__gnu_debug::__is_same
__gnu_debug::_After_nth_from
__gnu_debug::_Not_equal_to
__gnu_debug::_Safe_iteratorSafe iterator wrapper
__gnu_debug::_Safe_iterator_baseBasic functionality for a "safe" iterator
__gnu_debug::_Safe_sequenceBase 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_parallel::_SettingsClass _Settings Run-time settings for the parallel mode, including all tunable parameters
__gnu_parallel::accumulate_binop_reductGeneral reduction, using a binary operator
__gnu_parallel::accumulate_selectorStd::accumulate() selector
__gnu_parallel::adjacent_difference_selectorSelector that returns the difference between two adjacent elements
__gnu_parallel::adjacent_find_selectorTest predicate on two adjacent elements
__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::binder1stSimilar to std::binder1st, but giving the argument types explicitly
__gnu_parallel::binder2ndSimilar to std::binder2nd, but giving the argument types explicitly
__gnu_parallel::constant_size_blocks_tagSelects the constant block size variant for std::find()
__gnu_parallel::count_if_selectorStd::count_if () selector
__gnu_parallel::count_selectorStd::count() selector
__gnu_parallel::default_parallel_tagRecommends parallel execution using the default parallel algorithm
__gnu_parallel::DRandomShufflingGlobalDataData known to every thread participating in __gnu_parallel::parallel_random_shuffle()
__gnu_parallel::DRSSorterPULocal data for a thread participating in __gnu_parallel::parallel_random_shuffle()
__gnu_parallel::dummy_reductReduction function doing nothing
__gnu_parallel::equal_from_lessConstructs predicate for equality from strict weak ordering predicate
__gnu_parallel::equal_split_tagSelects the equal splitting variant for std::find()
__gnu_parallel::equal_toSimilar to std::equal_to, but allows two different types
__gnu_parallel::exact_tagForces parallel merging with exact splitting, at compile time
__gnu_parallel::fill_selectorStd::fill() selector
__gnu_parallel::find_first_of_selectorTest predicate on several elements
__gnu_parallel::find_if_selectorTest predicate on a single element, used for std::find() and std::find_if ()
__gnu_parallel::find_tagBase class for for std::find() variants
__gnu_parallel::for_each_selectorStd::for_each() selector
__gnu_parallel::generate_selectorStd::generate() selector
__gnu_parallel::generic_find_selectorBase class of all __gnu_parallel::find_template selectors
__gnu_parallel::generic_for_each_selectorGeneric selector for embarrassingly parallel functions
__gnu_parallel::growing_blocks_tagSelects the growing block size variant for std::find()
__gnu_parallel::guarded_iteratorIterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
__gnu_parallel::identity_selectorSelector that just returns the passed iterator
__gnu_parallel::inner_product_selectorStd::inner_product() selector
__gnu_parallel::iterator_pairA pair of iterators. The usual iterator operations are applied to both child iterators
__gnu_parallel::iterator_tripleA triple of iterators. The usual iterator operations are applied to all three child iterators
__gnu_parallel::JobOne job for a certain thread
__gnu_parallel::lessSimilar to std::less, but allows two different types
__gnu_parallel::lexicographicCompare a pair of types lexicographically, ascending
__gnu_parallel::lexicographic_reverseCompare a pair of types lexicographically, descending
__gnu_parallel::loser_tree_traitsTraits for determining whether the loser tree should use pointers or copies
__gnu_parallel::LoserTreeStable LoserTree variant
__gnu_parallel::LoserTreeUnstable LoserTree variant
__gnu_parallel::LoserTreeBaseGuarded loser/tournament tree
__gnu_parallel::LoserTreeBase::LoserInternal representation of a LoserTree element
__gnu_parallel::LoserTreePointerStable LoserTree implementation
__gnu_parallel::LoserTreePointerUnstable LoserTree implementation
__gnu_parallel::LoserTreePointerBaseBase class of Loser Tree implementation using pointers
__gnu_parallel::LoserTreePointerBase::LoserInternal representation of LoserTree elements
__gnu_parallel::LoserTreePointerUnguardedStable unguarded LoserTree variant storing pointers
__gnu_parallel::LoserTreePointerUnguardedUnstable unguarded LoserTree variant storing pointers
__gnu_parallel::LoserTreePointerUnguardedBaseUnguarded loser tree, keeping only pointers to the elements in the tree structure
__gnu_parallel::LoserTreeUnguardedStable implementation of unguarded LoserTree
__gnu_parallel::LoserTreeUnguardedNon-Stable implementation of unguarded LoserTree
__gnu_parallel::LoserTreeUnguardedBaseBase class for unguarded LoserTree implementation
__gnu_parallel::max_element_reductReduction for finding the maximum element, using a comparator
__gnu_parallel::min_element_reductReduction for finding the maximum element, using a comparator
__gnu_parallel::mismatch_selectorTest inverted predicate on a single element
__gnu_parallel::multipliesSimilar to std::multiplies, but allows two different types
__gnu_parallel::multiway_merge_3_variant_sentinel_switchSwitch for 3-way merging with sentinels turned off
__gnu_parallel::multiway_merge_3_variant_sentinel_switchSwitch for 3-way merging with sentinels turned on
__gnu_parallel::multiway_merge_4_variant_sentinel_switchSwitch for 4-way merging with sentinels turned off
__gnu_parallel::multiway_merge_4_variant_sentinel_switchSwitch for 4-way merging with sentinels turned on
__gnu_parallel::multiway_merge_k_variant_sentinel_switchSwitch for k-way merging with sentinels turned on
__gnu_parallel::multiway_merge_k_variant_sentinel_switchSwitch for k-way merging with sentinels turned off
__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::nothingFunctor doing nothing
__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::PieceSubsequence description
__gnu_parallel::plusSimilar to std::plus, but allows two different types
__gnu_parallel::PMWMSSortingDataData accessed by all threads
__gnu_parallel::pseudo_sequenceSequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
__gnu_parallel::pseudo_sequence_iteratorIterator associated with __gnu_parallel::pseudo_sequence. If features the usual random-access iterator functionality
__gnu_parallel::QSBThreadLocalInformation local to one thread in the parallel quicksort run
__gnu_parallel::quicksort_tagForces parallel sorting using unbalanced quicksort at compile time
__gnu_parallel::random_numberRandom number generator, based on the Mersenne twister
__gnu_parallel::replace_if_selectorStd::replace() selector
__gnu_parallel::replace_selectorStd::replace() selector
__gnu_parallel::RestrictedBoundedConcurrentQueueDouble-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::sampling_sorterStable sorting functor
__gnu_parallel::sampling_sorterNon-stable sorting functor
__gnu_parallel::sampling_tagForces parallel merging with exact splitting, at compile time
__gnu_parallel::sequential_tagForces sequential execution at compile time
__gnu_parallel::split_consistentlySplit consistently
__gnu_parallel::split_consistentlySplit by sampling
__gnu_parallel::split_consistentlySplit by exact splitting
__gnu_parallel::transform1_selectorStd::transform() selector, one input sequence variant
__gnu_parallel::transform2_selectorStd::transform() selector, two input sequences variant
__gnu_parallel::unary_negateSimilar to std::binder1st, but giving the argument types explicitly
__gnu_parallel::unbalanced_tagRecommends parallel execution using static load-balancing at compile time
__gnu_parallel::void_functorFunctor that does nothing
__gnu_pbds::associative_container_tagBasic associative-container
__gnu_pbds::basic_hash_tagBasic hash
__gnu_pbds::basic_tree_tagBasic tree
__gnu_pbds::binary_heap_tagBinary-heap (array-based)
__gnu_pbds::binomial_heap_tagBinomial-heap
__gnu_pbds::cc_hash_tagCollision-chaining hash
__gnu_pbds::container_tagBase data structure tag
__gnu_pbds::container_traitsContainer_traits
__gnu_pbds::detail::value_type_base
__gnu_pbds::detail::value_type_base
__gnu_pbds::detail::value_type_base
__gnu_pbds::detail::value_type_base
__gnu_pbds::gp_hash_tagGeneral-probing hash
__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_tagTree
__gnu_pbds::trie_tagTrie
std::__codecvt_abstract_baseCommon base for codecvt functions
std::__ctype_abstract_baseCommon base for ctype facet
std::__is_location_invariant
std::__is_member_pointer_helperIs_member_pointer
std::__numeric_limits_basePart of std::numeric_limits
std::__parallel::c_rand_numberFunctor wrapper for std::rand()
std::_Base_bitset
std::_Base_bitset
std::_Base_bitset
std::_Deque_base
std::_Deque_iteratorA deque::iterator
std::_Derives_from_binary_functionDetermines if the type _Tp derives from binary_function
std::_Derives_from_unary_functionDetermines if the type _Tp derives from unary_function
std::_Fnv_hashDummy generic implementation (for sizeof(size_t) != 4, 8)
std::_Function_baseBase class of all polymorphic function object wrappers
std::_Function_to_function_pointerTurns a function type into a function pointer type
std::_Fwd_list_baseBase class for forward_list
std::_Fwd_list_const_iteratorA forward_list::const_iterator
std::_Fwd_list_iteratorA forward_list::iterator
std::_Fwd_list_nodeA 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::_Has_result_type_helper
std::_Index_tuple
std::_List_baseSee bits/stl_deque.h's _Deque_base for an explanation
std::_List_const_iteratorA list::const_iterator
std::_List_iteratorA list::iterator
std::_List_nodeAn actual node in the list
std::_List_node_baseCommon part of a node in the list
std::_Maybe_get_result_typeIf we have found a result_type, extract it
std::_Maybe_unary_or_binary_function
std::_Maybe_unary_or_binary_functionDerives from unary_function, as appropriate
std::_Maybe_unary_or_binary_functionDerives from binary_function, as appropriate
std::_Maybe_wrap_member_pointer
std::_Maybe_wrap_member_pointer
std::_Mem_fnImplementation of mem_fn for const member function pointers
std::_Mem_fnImplementation of mem_fn for const volatile member function pointers
std::_Mem_fnImplementation of mem_fn for volatile member function pointers
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...)>Implementation of mem_fn for member function pointers
std::_Mu
std::_Mu
std::_Mu
std::_Mu
std::_PlaceholderThe type of placeholder objects defined by libstdc++
std::_Reference_wrapper_base
std::_Result_of_impl< false, _Functor()>
std::_Result_of_impl< false, _Functor(_ArgTypes...)>
std::_Result_of_impl< true, _Functor(_ArgTypes...)>We already know the result type for Functor; use it
std::_Safe_tuple_element
std::_Safe_tuple_element_impl
std::_Safe_tuple_element_impl
std::_Temporary_buffer
std::_Tuple_impl
std::_Tuple_impl< _Idx, _Head, _Tail...>
std::_Vector_baseSee bits/stl_deque.h's _Deque_base for an explanation
std::_Weak_result_type
std::_Weak_result_type_impl
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_implRetrieve result type for a const member function pointer
std::_Weak_result_type_implRetrieve result type for a const volatile member function pointer
std::_Weak_result_type_implRetrieve 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_constAdd_const
std::add_cvAdd_cv
std::add_lvalue_referenceAdd_lvalue_reference
std::add_pointerAdd_pointer
std::add_rvalue_referenceAdd_rvalue_reference
std::add_volatileAdd_volatile
std::adopt_lock_tAssume the calling thread has already obtained mutex ownership and manage it
std::alignment_ofAlignment_of
std::allocatorThe "standard" allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
std::allocatorAllocator<void> specialization
std::arrayA standard container for storing a fixed size sequence of elements
std::atomicAtomic 29.4.3, Generic atomic type, primary class template
std::atomicPartial specialization for pointer types
std::atomicExplicit specialization for bool
std::atomicExplicit specialization for char
std::atomicExplicit specialization for char16_t
std::atomicExplicit specialization for char32_t
std::atomicExplicit specialization for int
std::atomicExplicit specialization for long
std::atomicExplicit specialization for long long
std::atomicExplicit specialization for short
std::atomicExplicit specialization for signed char
std::atomicExplicit specialization for unsigned char
std::atomicExplicit specialization for unsigned int
std::atomicExplicit specialization for unsigned long
std::atomicExplicit specialization for unsigned long long
std::atomicExplicit specialization for unsigned short
std::atomicExplicit specialization for void*
std::atomicExplicit specialization for wchar_t
std::auto_ptrA simple smart pointer providing strict ownership semantics
std::auto_ptr_ref
std::back_insert_iteratorTurns 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::basic_filebufThe 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_fstreamControlling 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_ifstreamControlling 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_iosVirtual 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_iostreamMerging istream and ostream capabilities.This class multiply inherits from the input and output stream classes simply to provide a single interface
std::basic_istreamControlling 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::sentryPerforms setup work for input streams
std::basic_istringstreamControlling 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_ofstreamControlling 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_ostreamControlling 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::sentryPerforms setup work for output streams
std::basic_ostringstreamControlling 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
std::basic_streambufThe actual work of input and output (interface)
std::basic_stringManaging sequences of characters and character-like objects
std::basic_stringbufThe 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_stringstreamControlling 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::bidirectional_iterator_tagBidirectional iterators support a superset of forward iterator operations
std::binary_function
std::binary_negateOne of the negation functors
std::binder1stOne of the binder functors
std::binder2ndOne of the binder functors
std::binomial_distributionA discrete binomial random number distribution
std::bitsetThe bitset class represents a fixed-size sequence of bits
std::bitset::reference
std::char_traitsBasis for explicit traits specializations
std::char_traitsChar_traits<__gnu_cxx::character> specialization
std::char_traits21.1.3.1 char_traits specializations
std::char_traits21.1.3.2 char_traits specializations
std::chrono::durationDuration
std::chrono::duration_valuesDuration_values
std::chrono::system_clockSystem_clock
std::chrono::time_pointTime_point
std::chrono::treat_as_floating_pointTreat_as_floating_point
std::codecvtClass codecvt [22.2.1.5]. NB: Generic, mostly useless implementation
std::codecvtCodecvt<InternT, _ExternT, encoding_state> specialization
std::codecvtClass codecvt<char, char, mbstate_t> specialization
std::codecvtClass codecvt<wchar_t, char, mbstate_t> specialization
std::codecvt_baseEmpty base class for codecvt facet [22.2.1.5]
std::codecvt_bynameClass codecvt_byname [22.2.1.6]
std::collateFacet for localized string comparison
std::collate_bynameClass collate_byname [22.2.4.2]
std::complex
std::condition_variableCondition_variable
std::condition_variable_anyCondition_variable_any
std::const_mem_fun1_ref_tOne of the adaptors for member pointers
std::const_mem_fun1_tOne of the adaptors for member pointers
std::const_mem_fun_ref_tOne of the adaptors for member pointers
std::const_mem_fun_tOne of the adaptors for member pointers
std::ctypeTemplate ctype facet
std::ctypeThe ctype<char> specialization
std::ctypeThe ctype<wchar_t> specialization
std::ctype_baseBase class for ctype
std::ctype_bynameClass ctype_byname [22.2.1.2]
std::ctype_byname22.2.1.4 Class ctype_byname specializations
std::default_deletePrimary template, default_delete
std::default_delete< _Tp[]>Specialization, default_delete
std::defer_lock_tDo not acquire ownership of the mutex
std::dequeA standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
std::discard_block
std::dividesOne of the math functors
std::domain_error
std::equal_toOne 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_distributionAn exponential continuous distribution for random numbers
std::extentExtent
std::forward_iterator_tagForward iterators support a superset of input iterator operations
std::forward_listA standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
std::fposClass representing stream positions
std::front_insert_iteratorTurns assignment into insertion
std::function< _Res(_ArgTypes...)>Class function
std::gamma_distributionA gamma continuous distribution for random numbers
std::geometric_distributionA discrete geometric random number distribution
std::greaterOne of the comparison functors
std::greater_equalOne of the comparison functors
std::gsliceClass defining multi-dimensional subset of an array
std::gslice_arrayReference to multi-dimensional subset of an array
std::has_virtual_destructorHas_virtual_destructor
std::hashClass template hash
std::hashPartial specializations for pointer types
std::indirect_arrayReference to arbitrary subset of an array
std::initializer_listInitializer_list
std::input_iterator_tagMarking input iterators
std::insert_iteratorTurns assignment into insertion
std::integral_constantIntegral_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_abstractIs_abstract
std::is_arithmeticIs_arithmetic
std::is_arrayIs_array
std::is_bind_expressionDetermines 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_expressionClass template _Bind is always a bind expression
std::is_bind_expressionClass template _Bind_result is always a bind expression
std::is_classIs_class
std::is_compoundIs_compound
std::is_constIs_const
std::is_emptyIs_empty
std::is_enumIs_enum
std::is_error_code_enumIs_error_code_enum
std::is_error_condition_enumIs_error_condition_enum
std::is_floating_pointIs_floating_point
std::is_functionIs_function
std::is_fundamentalIs_fundamental
std::is_integralIs_integral
std::is_lvalue_referenceIs_lvalue_reference
std::is_member_function_pointerIs_member_function_pointer
std::is_member_object_pointerIs_member_object_pointer
std::is_objectIs_object
std::is_placeholderDetermines 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
std::is_pointerIs_pointer
std::is_polymorphicIs_polymorphic
std::is_referenceIs_reference
std::is_rvalue_referenceIs_rvalue_reference
std::is_sameIs_same
std::is_scalarIs_scalar
std::is_unionIs_union
std::is_voidIs_void
std::is_volatileIs_volatile
std::istream_iteratorProvides input iterator semantics for streams
std::istreambuf_iteratorProvides input iterator semantics for streambufs
std::iteratorCommon iterator class
std::iterator_traits
std::length_error
std::lessOne of the comparison functors
std::less_equalOne of the comparison functors
std::linear_congruentialA model of a linear congruential random number generator
std::listA 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
std::locale::facetLocalization functionality base class
std::locale::idFacet ID class
std::lock_errorThrown to indicate errors with lock operations
std::lock_guardScoped lock idiom
std::logic_errorOne of two subclasses of exception
std::logical_andOne of the Boolean operations functors
std::logical_notOne of the Boolean operations functors
std::logical_orOne of the Boolean operations functors
std::mapA standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::mask_arrayReference to selected subset of an array
std::match_resultsThe results of a match or search operation
std::mem_fun1_ref_tOne of the adaptors for member pointers
std::mem_fun1_tOne of the adaptors for member pointers
std::mem_fun_ref_tOne of the adaptors for member pointers
std::mem_fun_tOne of the adaptors for member pointers
std::messagesFacet for handling message catalogs
std::messages_baseMessages facet base class providing catalog typedef
std::messages_bynameClass messages_byname [22.2.7.2]
std::minusOne of the math functors
std::modulusOne of the math functors
std::money_baseMoney format ordering data
std::money_getFacet for parsing monetary amounts
std::money_putFacet for outputting monetary amounts
std::moneypunctFacet for formatting data for money amounts
std::moneypunct_bynameClass moneypunct_byname [22.2.6.4]
std::move_iterator
std::multimapA standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::multipliesOne of the math functors
std::multisetA standard container made up of elements, which can be retrieved in logarithmic time
std::mutexMutex
std::negateOne of the math functors
std::normal_distributionA normal continuous distribution for random numbers
std::not_equal_toOne of the comparison functors
std::num_getFacet for parsing number strings
std::num_putFacet for converting numbers to strings
std::numeric_limitsProperties of fundamental types
std::numeric_limitsNumeric_limits<bool> specialization
std::numeric_limitsNumeric_limits<char> specialization
std::numeric_limitsNumeric_limits<char16_t> specialization
std::numeric_limitsNumeric_limits<char32_t> specialization
std::numeric_limitsNumeric_limits<double> specialization
std::numeric_limitsNumeric_limits<float> specialization
std::numeric_limitsNumeric_limits<int> specialization
std::numeric_limitsNumeric_limits<long> specialization
std::numeric_limitsNumeric_limits<long double> specialization
std::numeric_limitsNumeric_limits<long long> specialization
std::numeric_limitsNumeric_limits<short> specialization
std::numeric_limitsNumeric_limits<signed char> specialization
std::numeric_limitsNumeric_limits<unsigned char> specialization
std::numeric_limitsNumeric_limits<unsigned int> specialization
std::numeric_limitsNumeric_limits<unsigned long> specialization
std::numeric_limitsNumeric_limits<unsigned long long> specialization
std::numeric_limitsNumeric_limits<unsigned short> specialization
std::numeric_limitsNumeric_limits<wchar_t> specialization
std::numpunctNumpunct facet
std::numpunct_bynameClass numpunct_byname [22.2.3.2]
std::once_flagOnce_flag
std::ostream_iteratorProvides output iterator semantics for streams
std::ostreambuf_iteratorProvides output iterator semantics for streambufs
std::out_of_range
std::output_iterator_tagMarking output iterators
std::overflow_error
std::pairPair holds two objects of arbitrary type
std::plusOne of the math functors
std::pointer_to_binary_functionOne of the adaptors for function pointers
std::pointer_to_unary_functionOne of the adaptors for function pointers
std::poisson_distributionA discrete Poisson random number distribution
std::priority_queueA standard container automatically sorting its contents
std::queueA 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::rankRank
std::ratioProvides compile-time rational arithmetic
std::ratio_addRatio_add
std::ratio_divideRatio_divide
std::ratio_equalRatio_equal
std::ratio_greaterRatio_greater
std::ratio_greater_equalRatio_greater_equal
std::ratio_lessRatio_less
std::ratio_less_equalRatio_less_equal
std::ratio_multiplyRatio_multiply
std::ratio_not_equalRatio_not_equal
std::ratio_subtractRatio_subtract
std::raw_storage_iterator
std::recursive_mutexRecursive_mutex
std::recursive_timed_mutexRecursive_timed_mutex
std::reference_wrapperReference_wrapper
std::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
std::regex_iterator
std::regex_token_iterator
std::regex_traitsDescribes aspects of a regular expression
std::remove_all_extentsRemove_all_extents
std::remove_constRemove_const
std::remove_cvRemove_cv
std::remove_extentRemove_extent
std::remove_pointerRemove_pointer
std::remove_referenceRemove_reference
std::remove_volatileRemove_volatile
std::result_of< _Functor(_ArgTypes...)>
std::reverse_iterator
std::runtime_errorOne of two subclasses of exception
std::setA standard container made up of unique keys, which can be retrieved in logarithmic time
std::sliceClass defining one-dimensional subset of an array
std::slice_arrayReference to one-dimensional subset of an array
std::stackA standard container giving FILO behavior
std::sub_match
std::system_errorThrown to indicate error code of underlying system
std::threadThread
std::thread::idThread::id
std::time_baseTime format ordering data
std::time_getFacet for parsing dates and times
std::time_get_bynameClass time_get_byname [22.2.5.2]
std::time_putFacet for outputting dates and times
std::time_put_bynameClass time_put_byname [22.2.5.4]
std::timed_mutexTimed_mutex
std::tr1::__detail::__floating_point_constantA class to encapsulate type dependent floating point constants. Not everything will be able to be expressed as type logic
std::tr1::__detail::__numeric_constantsA structure for numeric constants
std::tr1::_Tuple_impl
std::tr1::_Tuple_impl< _Idx, _Head, _Tail...>
std::tr1::tuple_element
std::tr1::tuple_element
std::tr1::tuple_sizeClass tuple_size
std::try_to_lock_tTry to acquire ownership of the mutex without blocking
std::tupleTuple
std::tupleTuple (2-element), with construction and assignment from a pair
std::tuple_element
std::tuple_element
std::tuple_sizeClass tuple_size
std::type_infoPart of RTTI
std::unary_function
std::unary_negateOne of the negation functors
std::underflow_error
std::uniform_intUniform discrete distribution for random numbers. A discrete random distribution on the range $[min, max]$ with equal probability throughout the range
std::uniform_realUniform continuous distribution for random numbers
std::unique_lockUnique_lock
std::unique_ptr20.7.12.2 unique_ptr for single objects
std::unique_ptr20.7.12.3 unique_ptr for array objects with a runtime length
std::unordered_mapA 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_multimapA standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
std::unordered_multisetA standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
std::unordered_setA standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
std::valarraySmart array designed to support numeric processing
std::variate_generator
std::vectorA standard container which offers fixed time access to individual elements in any order
std::vectorA specialization of vector for booleans which offers fixed time access to individual elements in any order
std::xor_combine

Generated on 19 Jun 2018 for libstdc++ by  doxygen 1.6.1