libstdc++
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_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_stringTemplate class __versa_string.Data structure managing 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::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_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::condition_baseBase struct for condition policy
__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
__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_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
__gnu_cxx::hash_multimap
__gnu_cxx::hash_multiset
__gnu_cxx::hash_set
__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_allocatorAn allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
__gnu_cxx::new_allocatorAn allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard
__gnu_cxx::project1stAn SGI extension
__gnu_cxx::project2ndAn 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
__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
__gnu_cxx::select1stAn SGI extension
__gnu_cxx::select2ndAn SGI extension
__gnu_cxx::slist
__gnu_cxx::stdio_filebufProvides 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_filebufProvides 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
__gnu_cxx::throw_allocator_baseAllocator 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_limitAllocator throwing via limit condition
__gnu_cxx::throw_allocator_randomAllocator throwing via random condition
__gnu_cxx::throw_value_baseClass 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_composeAn SGI extension
__gnu_debug::_After_nth_from
__gnu_debug::_BeforeBeginHelper
__gnu_debug::_Equal_to
__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_debug::basic_stringClass std::basic_string with safety/checking/debug instrumentation
__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::__binder1stSimilar to std::binder1st, but giving the argument types explicitly
__gnu_parallel::__binder2ndSimilar to std::binder2nd, but giving the argument types explicitly
__gnu_parallel::__count_if_selectorStd::count_if () selector
__gnu_parallel::__count_selectorStd::count() selector
__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::__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::__identity_selectorSelector that just returns the passed iterator
__gnu_parallel::__inner_product_selectorStd::inner_product() selector
__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::__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::__replace_if_selectorStd::replace() selector
__gnu_parallel::__replace_selectorStd::replace() selector
__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::unary_negate, but giving the argument types explicitly
__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::_DummyReductReduction function doing nothing
__gnu_parallel::_EqualFromLessConstructs predicate for equality from strict weak ordering predicate
__gnu_parallel::_EqualToSimilar to std::equal_to, but allows two different types
__gnu_parallel::_GuardedIterator_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
__gnu_parallel::_IteratorPairA pair of iterators. The usual iterator operations are applied to both child iterators
__gnu_parallel::_IteratorTripleA 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::_LexicographicReverseCompare __a pair of types lexicographically, descending
__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::_LoserTreeTraitsTraits for determining whether the loser tree should use pointers or copies
__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::_MultipliesSimilar to std::multiplies, but allows two different types
__gnu_parallel::_NothingFunctor doing nothing
__gnu_parallel::_PieceSubsequence description
__gnu_parallel::_PlusSimilar to std::plus, but allows two different types
__gnu_parallel::_PMWMSSortingDataData accessed by all threads
__gnu_parallel::_PseudoSequenceSequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
__gnu_parallel::_PseudoSequenceIterator_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
__gnu_parallel::_QSBThreadLocalInformation local to one thread in the parallel quicksort run
__gnu_parallel::_RandomNumberRandom number generator, based on the Mersenne twister
__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::_SamplingSorterStable sorting functor
__gnu_parallel::_SamplingSorterNon-__stable sorting functor
__gnu_parallel::_SettingsClass _Settings Run-time settings for the parallel mode including all tunable parameters
__gnu_parallel::_SplitConsistentlySplit consistently
__gnu_parallel::_SplitConsistentlySplit by sampling
__gnu_parallel::_SplitConsistentlySplit 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_tableAn abstract basic hash-based associative container
__gnu_pbds::basic_hash_tagBasic hash
__gnu_pbds::basic_treeAn 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_tableA concrete collision-chaining hash-based associative container
__gnu_pbds::cc_hash_tagCollision-chaining hash
__gnu_pbds::container_baseAn abstract basic associative container
__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_tableA concrete general-probing hash-based associative container
__gnu_pbds::gp_hash_tagGeneral-probing hash
__gnu_pbds::list_updateA 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::treeA concrete basic tree-based associative container
__gnu_pbds::tree_tagTree
__gnu_pbds::trieA 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_baseBase class for a line in the stack table
__gnu_profile::__trace_baseBase 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_baseBase class for atomic integrals
std::__atomic0::__atomic_basePartial specialization for pointer types
std::__atomic0::atomic_flagAtomic_flag
std::__atomic2::__atomic_baseBase class for atomic integrals
std::__atomic2::__atomic_basePartial specialization for pointer types
std::__atomic2::atomic_flagAtomic_flag
std::__atomic_flag_baseBase type for atomic_flag
std::__basic_futureCommon implementation for future and shared_future
std::__codecvt_abstract_baseCommon base for codecvt functions
std::__ctype_abstract_baseCommon base for ctype facet
std::__debug::bitsetClass std::bitset with additional safety/checking/debug instrumentation
std::__debug::dequeClass std::deque with safety/checking/debug instrumentation
std::__debug::forward_listClass std::forward_list with safety/checking/debug instrumentation
std::__debug::listClass std::list with safety/checking/debug instrumentation
std::__debug::mapClass std::map with safety/checking/debug instrumentation
std::__debug::multimapClass std::multimap with safety/checking/debug instrumentation
std::__debug::multisetClass std::multiset with safety/checking/debug instrumentation
std::__debug::setClass std::set with safety/checking/debug instrumentation
std::__debug::unordered_mapClass std::unordered_map with safety/checking/debug instrumentation
std::__debug::unordered_multimapClass std::unordered_multimap with safety/checking/debug instrumentation
std::__debug::unordered_multisetClass std::unordered_multiset with safety/checking/debug instrumentation
std::__debug::unordered_setClass std::unordered_set with safety/checking/debug instrumentation
std::__debug::vectorClass std::vector with safety/checking/debug instrumentation
std::__declval_protectorDeclval
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::_PtrA unique_ptr based on the instantiating type
std::__future_base::_ResultResult
std::__future_base::_ResultPartial specialization for reference types
std::__future_base::_ResultExplicit specialization for void
std::__future_base::_Result_allocResult_alloc
std::__future_base::_Result_baseBase class for results
std::__future_base::_State_baseBase class for state between a promise and one or more associated futures
std::__is_location_invariant
std::__is_member_pointer_helperIs_member_pointer
std::__iterator_traitsTraits class for iterators
std::__numeric_limits_basePart of std::numeric_limits
std::__parallel::_CRandNumberFunctor wrapper for std::rand()
std::__profile::bitsetClass std::bitset wrapper with performance instrumentation
std::__profile::dequeClass std::deque wrapper with performance instrumentation
std::__profile::forward_listClass std::forward_list wrapper with performance instrumentation
std::__profile::listList wrapper with performance instrumentation
std::__profile::mapClass std::map wrapper with performance instrumentation
std::__profile::multimapClass std::multimap wrapper with performance instrumentation
std::__profile::multisetClass std::multiset wrapper with performance instrumentation
std::__profile::setClass std::set wrapper with performance instrumentation
std::__profile::unordered_mapClass std::unordered_map wrapper with performance instrumentation
std::__profile::unordered_multimapClass std::unordered_multimap wrapper with performance instrumentation
std::__profile::unordered_multisetUnordered_multiset wrapper with performance instrumentation
std::__profile::unordered_setUnordered_set wrapper with performance instrumentation
std::_Base_bitset
std::_Base_bitset
std::_Base_bitset
std::_Build_index_tupleBuilds an _Index_tuple<0, 1, 2, ..., _Num-1>
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::_Function_baseBase class of all polymorphic function object wrappers
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::_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::_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::_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::aligned_storageAlignment type
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::allocator_arg_t[allocator.tag]
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 wchar_t
std::atomic_boolAtomic_bool
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::bad_weak_ptrException possibly thrown by shared_ptr
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).This is a base class. Derived stream buffers each control a pair of character sequences: one for input, and one for output
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::bernoulli_distribution::param_type
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::binomial_distribution::param_type
std::cauchy_distributionA cauchy_distribution random number distribution
std::cauchy_distribution::param_type
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::chi_squared_distributionA chi_squared_distribution random number distribution
std::chi_squared_distribution::param_type
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::codecvtPrimary class template codecvt.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::conditionalConditional
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::ctypePrimary 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::ctypeThe 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::ctypeThe 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_bynameClass ctype_byname [22.2.1.2]
std::ctype_byname22.2.1.4 Class ctype_byname specializations
std::decayDecay
std::decimal::decimal1283.2.4 Class decimal128
std::decimal::decimal323.2.2 Class decimal32
std::decimal::decimal643.2.3 Class decimal64
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_engine
std::discrete_distributionA discrete_distribution random number distribution
std::discrete_distribution::param_type
std::dividesOne of the math functors
std::domain_error
std::enable_ifEnable_if
std::enable_shared_from_thisBase class allowing use of member function shared_from_this
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::exponential_distribution::param_type
std::extentExtent
std::extreme_value_distributionA extreme_value_distribution random number distribution
std::extreme_value_distribution::param_type
std::fisher_f_distributionA fisher_f_distribution random number distribution
std::fisher_f_distribution::param_type
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...)>Primary class template for std::function.Polymorphic function wrapper
std::futurePrimary template for future
std::futurePartial specialization for future<R&>
std::futureExplicit specialization for future<void>
std::future_errorException type thrown by futures
std::gamma_distributionA gamma continuous distribution for random numbers
std::gamma_distribution::param_type
std::geometric_distributionA discrete geometric random number distribution
std::geometric_distribution::param_type
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_nothrow_copy_assignHas_nothrow_copy_assign
std::has_nothrow_copy_constructorHas_nothrow_copy_constructor
std::has_nothrow_default_constructorHas_nothrow_default_constructor
std::has_trivial_copy_assignHas_trivial_copy_assign
std::has_trivial_copy_constructorHas_trivial_copy_constructor
std::has_trivial_default_constructorHas_trivial_default_constructor
std::has_trivial_destructorHas_trivial_destructor
std::has_virtual_destructorHas_virtual_destructor
std::hashPrimary class template hash
std::hashStd::hash specialization for bitset
std::hashStd::hash specialization for vector<bool>
std::hashStd::hash specialization for __u16vstring
std::hashStd::hash specialization for __u32vstring
std::hashStd::hash specialization for __vstring
std::hashStd::hash specialization for __wvstring
std::hashExplicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hashExplicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hashStd::hash specialization for bitset
std::hashStd::hash specialization for vector<bool>
std::hashStd::hash specialization for __shared_ptr
std::hashPartial specializations for pointer types
std::hashStd::hash specialization for error_code
std::hashStd::hash specialization for shared_ptr
std::hashStd::hash specialization for string
std::hashStd::hash specialization for thread::id
std::hashStd::hash specialization for type_index
std::hashStd::hash specialization for u16string
std::hashStd::hash specialization for u32string
std::hashStd::hash specialization for unique_ptr
std::hashStd::hash specialization for wstring
std::hash<::bitsetStd::hash specialization for bitset
std::hash<::vectorStd::hash specialization for vector<bool>
std::independent_bits_engine
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_base_ofIs_base_of
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 is always a bind expression
std::is_classIs_class
std::is_compoundIs_compound
std::is_constIs_const
std::is_constructibleIs_constructible
std::is_convertibleIs_convertible
std::is_emptyIs_empty
std::is_enumIs_enum
std::is_error_code_enumIs_error_code_enum
std::is_error_code_enumSpecialization
std::is_error_condition_enumIs_error_condition_enum
std::is_explicitly_convertibleIs_explicitly_convertible
std::is_floating_pointIs_floating_point
std::is_functionIs_function
std::is_fundamentalIs_fundamental
std::is_integralIs_integral
std::is_literal_typeIs_literal_type
std::is_lvalue_referenceIs_lvalue_reference
std::is_member_function_pointerIs_member_function_pointer
std::is_member_object_pointerIs_member_object_pointer
std::is_nothrow_constructibleIs_nothrow_constructible
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_podIs_pod
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_signedIs_signed
std::is_standard_layoutIs_standard_layout
std::is_trivialIs_trivial
std::is_unionIs_union
std::is_unsignedIs_unsigned
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_traitsPartial specialization for pointer types
std::iterator_traitsPartial specialization for const pointer types
std::length_error
std::lessOne of the comparison functors
std::less_equalOne of the comparison functors
std::linear_congruential_engineA 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.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_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::lognormal_distributionA lognormal_distribution random number distribution
std::lognormal_distribution::param_type
std::make_signedMake_signed
std::make_unsignedMake_unsigned
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::messagesPrimary 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_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.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_getPrimary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
std::money_putPrimary class template money_put.This facet encapsulates the code to format and output a monetary amount
std::moneypunctPrimary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
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::negative_binomial_distributionA negative_binomial_distribution random number distribution
std::negative_binomial_distribution::param_type
std::nested_exceptionException class with exception_ptr data member
std::normal_distributionA normal continuous distribution for random numbers
std::normal_distribution::param_type
std::not_equal_toOne of the comparison functors
std::num_getPrimary 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_putPrimary 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_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::numpunctPrimary 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_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::owner_lessPartial specialization of owner_less for shared_ptr
std::owner_lessPartial specialization of owner_less for weak_ptr
std::packaged_task< _Res(_ArgTypes...)>Packaged_task
std::pairStruct holding two objects of arbitrary type
std::piecewise_constant_distributionA piecewise_constant_distribution random number distribution
std::piecewise_constant_distribution::param_type
std::piecewise_construct_tPiecewise_construct_t
std::piecewise_linear_distributionA piecewise_linear_distribution random number distribution
std::piecewise_linear_distribution::param_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::poisson_distribution::param_type
std::priority_queueA standard container automatically sorting its contents
std::promisePrimary template for promise
std::promisePartial specialization for promise<R&>
std::promiseExplicit specialization for promise<void>
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_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_wrapperPrimary 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
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::reverse_iterator
std::runtime_errorOne of two subclasses of exception
std::seed_seqGenerates sequences of seeds for random number generators
std::setA standard container made up of unique keys, which can be retrieved in logarithmic time
std::shared_futurePrimary template for shared_future
std::shared_futurePartial specialization for shared_future<R&>
std::shared_futureExplicit specialization for shared_future<void>
std::shared_ptrA smart pointer with reference-counted copy semantics
std::shuffle_order_engineProduces 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_arrayReference to one-dimensional subset of an array
std::stackA standard container giving FILO behavior
std::student_t_distributionA student_t_distribution random number distribution
std::student_t_distribution::param_type
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.This class provides an enum representing different orderings of time: day, month, and year
std::time_getPrimary 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_bynameClass time_get_byname [22.2.5.2]
std::time_putPrimary 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_bynameClass 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::tupleTuple
std::tupleTuple (1-element)
std::tupleTuple (2-element), with construction and assignment from a pair
std::tuple_element
std::tuple_element
std::tuple_sizeClass 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
std::unary_negateOne of the negation functors
std::underflow_error
std::uniform_int_distributionUniform discrete distribution for random numbers. A discrete random distribution on the range $[min, max]$ with equal probability throughout the range
std::uniform_int_distribution::param_type
std::uniform_real_distributionUniform continuous distribution for random numbers
std::uniform_real_distribution::param_type
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::uses_allocator[allocator.uses.trait]
std::valarraySmart array designed to support numeric processing
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::weak_ptrA smart pointer with weak semantics
std::weibull_distributionA weibull_distribution random number distribution
std::weibull_distribution::param_type