# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

__atomic0::atomic_address | 29.4.2, address types
__atomic0::atomic_bool | Atomic_bool
__atomic0::atomic_flag | Atomic_flag
__atomic2::atomic_address | 29.4.2, address types
__atomic2::atomic_bool | Atomic_bool
__atomic2::atomic_flag | Atomic_flag
__cxxabiv1::__forced_unwind | Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
__gnu_cxx::__common_pool_policy | Policy 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_counter | The bitmap counter which acts as the bitmap manipulator, and manages the bit-manipulation functions and the searching and identification functions on the bit-map
__gnu_cxx::__detail::_Ffit_finder | The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
__gnu_cxx::__mt_alloc | This is a fixed size (power of 2) allocator which - when compiled with thread support - will maintain one freelist per size per thread plus a global one. Steps are taken to limit the per thread freelist sizes (by returning excess back to the global list).Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.html
__gnu_cxx::__mt_alloc_base | Base class for _Tp dependent member functions
__gnu_cxx::__per_type_pool_policy | Policy for individual __pool objects
__gnu_cxx::__pool | Specialization for single thread
__gnu_cxx::__pool | Specialization for thread enabled, via gthreads.h
__gnu_cxx::__pool_alloc | Allocator using a memory pool with a single lock
__gnu_cxx::__pool_alloc_base | Base class for __pool_alloc
__gnu_cxx::__pool_base | Base class for pool object
__gnu_cxx::__rc_string_base |
__gnu_cxx::__scoped_lock | Scoped lock idiom
__gnu_cxx::__versa_string | Template class __versa_string.Data structure managing sequences of characters and character-like objects
__gnu_cxx::_Caster |
__gnu_cxx::_Char_types | Mapping from character type to associated types
__gnu_cxx::_ExtPtr_allocator | An example allocator which uses a non-standard pointer type.This allocator specifies that containers use a 'relative pointer' as it's pointer type. (See ext/pointer.h) Memory allocation in this example is still performed using std::allocator
__gnu_cxx::_Invalid_type |
__gnu_cxx::_Pointer_adapter |
__gnu_cxx::_Relative_pointer_impl | A storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset value which is relative to its own address
__gnu_cxx::_Relative_pointer_impl |
__gnu_cxx::_Std_pointer_impl | A storage policy for use with _Pointer_adapter<> which yields a standard pointer
__gnu_cxx::_Unqualified_type |
__gnu_cxx::annotate_base | Base class for checking address and label information about allocations. Create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size
__gnu_cxx::array_allocator | An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
__gnu_cxx::array_allocator_base | Base class
__gnu_cxx::binary_compose | An SGI extension
__gnu_cxx::bitmap_allocator | Bitmap Allocator, primary template
__gnu_cxx::char_traits | Base class used to implement std::char_traits
__gnu_cxx::character | A POD class that serves as a character abstraction class
__gnu_cxx::condition_base | Base struct for condition policy
__gnu_cxx::constant_binary_fun | An SGI extension
__gnu_cxx::constant_unary_fun | An SGI extension
__gnu_cxx::constant_void_fun | An SGI extension

__gnu_cxx::debug_allocator

A meta-allocator with debugging bits, as per [20.4].This is precisely the allocator defined in the C++ Standard.

- all allocation calls operator new
- all deallocation calls operator delete

__gnu_cxx::enc_filebuf | Class enc_filebuf
__gnu_cxx::encoding_char_traits | Encoding_char_traits
__gnu_cxx::encoding_state | Extension to use iconv for dealing with character encodings
__gnu_cxx::forced_error | Thown by exception safety machinery
__gnu_cxx::free_list | The 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_condition | Base class for incremental control and throw
__gnu_cxx::limit_condition::always_adjustor | Always enter the condition
__gnu_cxx::limit_condition::limit_adjustor | Enter the nth condition
__gnu_cxx::limit_condition::never_adjustor | Never enter the condition

__gnu_cxx::malloc_allocator

An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard.

- all allocation calls malloc
- all deallocation calls free

__gnu_cxx::new_allocator

An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard.

- all allocation calls operator new
- all deallocation calls operator delete

__gnu_cxx::project1st | An SGI extension
__gnu_cxx::project2nd | An SGI extension
__gnu_cxx::random_condition | Base class for random probability control and throw
__gnu_cxx::random_condition::always_adjustor | Always enter the condition
__gnu_cxx::random_condition::group_adjustor | Group condition
__gnu_cxx::random_condition::never_adjustor | Never enter the condition
__gnu_cxx::rb_tree |
__gnu_cxx::recursive_init_error | Exception 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::select1st | An SGI extension
__gnu_cxx::select2nd | An SGI extension
__gnu_cxx::slist |
__gnu_cxx::stdio_filebuf | Provides a layer of compatibility for C/POSIX.This GNU extension provides extensions for working with standard C FILE*'s and POSIX file descriptors. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
__gnu_cxx::stdio_sync_filebuf | Provides a layer of compatibility for C.This GNU extension provides extensions for working with standard C FILE*'s. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
__gnu_cxx::subtractive_rng |
__gnu_cxx::temporary_buffer |
__gnu_cxx::throw_allocator_base | Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code.Note: Deallocate not allowed to throw
__gnu_cxx::throw_allocator_limit | Allocator throwing via limit condition
__gnu_cxx::throw_allocator_random | Allocator throwing via random condition
__gnu_cxx::throw_value_base | Class with exception generation control. Intended to be used as a value_type in templatized code
__gnu_cxx::throw_value_limit | Type throwing via limit condition
__gnu_cxx::throw_value_random | Type throwing via random condition
__gnu_cxx::unary_compose | An SGI extension
__gnu_debug::__is_same |
__gnu_debug::_After_nth_from |
__gnu_debug::_Not_equal_to |
__gnu_debug::_Safe_iterator | Safe iterator wrapper
__gnu_debug::_Safe_iterator_base | Basic functionality for a safe iterator
__gnu_debug::_Safe_sequence | Base class for constructing a safe sequence type that tracks iterators that reference it
__gnu_debug::_Safe_sequence_base | Base class that supports tracking of iterators that reference a sequence
__gnu_debug::basic_string | Class std::basic_string with safety/checking/debug instrumentation
__gnu_parallel::__accumulate_binop_reduct | General reduction, using a binary operator
__gnu_parallel::__accumulate_selector | Std::accumulate() selector
__gnu_parallel::__adjacent_difference_selector | Selector that returns the difference between two adjacent __elements
__gnu_parallel::__adjacent_find_selector | Test predicate on two adjacent elements
__gnu_parallel::__binder1st | Similar to std::binder1st, but giving the argument types explicitly
__gnu_parallel::__binder2nd | Similar to std::binder2nd, but giving the argument types explicitly
__gnu_parallel::__count_if_selector | Std::count_if () selector
__gnu_parallel::__count_selector | Std::count() selector
__gnu_parallel::__fill_selector | Std::fill() selector
__gnu_parallel::__find_first_of_selector | Test predicate on several elements
__gnu_parallel::__find_if_selector | Test predicate on a single element, used for std::find() and std::find_if ()
__gnu_parallel::__for_each_selector | Std::for_each() selector
__gnu_parallel::__generate_selector | Std::generate() selector
__gnu_parallel::__generic_find_selector | Base class of all __gnu_parallel::__find_template selectors
__gnu_parallel::__generic_for_each_selector | Generic __selector for embarrassingly parallel functions
__gnu_parallel::__identity_selector | Selector that just returns the passed iterator
__gnu_parallel::__inner_product_selector | Std::inner_product() selector
__gnu_parallel::__max_element_reduct | Reduction for finding the maximum element, using a comparator
__gnu_parallel::__min_element_reduct | Reduction for finding the maximum element, using a comparator
__gnu_parallel::__mismatch_selector | Test inverted predicate on a single element
__gnu_parallel::__multiway_merge_3_variant_sentinel_switch | Switch for 3-way merging with __sentinels turned off
__gnu_parallel::__multiway_merge_3_variant_sentinel_switch | Switch for 3-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_4_variant_sentinel_switch | Switch for 4-way merging with __sentinels turned off
__gnu_parallel::__multiway_merge_4_variant_sentinel_switch | Switch for 4-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_k_variant_sentinel_switch | Switch for k-way merging with __sentinels turned on
__gnu_parallel::__multiway_merge_k_variant_sentinel_switch | Switch for k-way merging with __sentinels turned off
__gnu_parallel::__replace_if_selector | Std::replace() selector
__gnu_parallel::__replace_selector | Std::replace() selector
__gnu_parallel::__transform1_selector | Std::transform() __selector, one input sequence variant
__gnu_parallel::__transform2_selector | Std::transform() __selector, two input sequences variant
__gnu_parallel::__unary_negate | Similar to std::unary_negate, but giving the argument types explicitly
__gnu_parallel::_DRandomShufflingGlobalData | Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
__gnu_parallel::_DRSSorterPU | Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
__gnu_parallel::_DummyReduct | Reduction function doing nothing
__gnu_parallel::_EqualFromLess | Constructs predicate for equality from strict weak ordering predicate
__gnu_parallel::_EqualTo | Similar 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::_IteratorPair | A pair of iterators. The usual iterator operations are applied to both child iterators
__gnu_parallel::_IteratorTriple | A triple of iterators. The usual iterator operations are applied to all three child iterators
__gnu_parallel::_Job | One __job for a certain thread
__gnu_parallel::_Less | Similar to std::less, but allows two different types
__gnu_parallel::_Lexicographic | Compare __a pair of types lexicographically, ascending
__gnu_parallel::_LexicographicReverse | Compare __a pair of types lexicographically, descending
__gnu_parallel::_LoserTree | Stable _LoserTree variant
__gnu_parallel::_LoserTree | Unstable _LoserTree variant
__gnu_parallel::_LoserTreeBase | Guarded loser/tournament tree
__gnu_parallel::_LoserTreeBase::_Loser | Internal representation of a _LoserTree element
__gnu_parallel::_LoserTreePointer | Stable _LoserTree implementation
__gnu_parallel::_LoserTreePointer | Unstable _LoserTree implementation
__gnu_parallel::_LoserTreePointerBase | Base class of _Loser Tree implementation using pointers
__gnu_parallel::_LoserTreePointerBase::_Loser | Internal representation of _LoserTree __elements
__gnu_parallel::_LoserTreePointerUnguarded | Stable unguarded _LoserTree variant storing pointers
__gnu_parallel::_LoserTreePointerUnguarded | Unstable unguarded _LoserTree variant storing pointers
__gnu_parallel::_LoserTreePointerUnguardedBase | Unguarded loser tree, keeping only pointers to the elements in the tree structure
__gnu_parallel::_LoserTreeTraits | Traits for determining whether the loser tree should use pointers or copies
__gnu_parallel::_LoserTreeUnguarded | Stable implementation of unguarded _LoserTree
__gnu_parallel::_LoserTreeUnguarded | Non-Stable implementation of unguarded _LoserTree
__gnu_parallel::_LoserTreeUnguardedBase | Base class for unguarded _LoserTree implementation
__gnu_parallel::_Multiplies | Similar to std::multiplies, but allows two different types
__gnu_parallel::_Nothing | Functor doing nothing
__gnu_parallel::_Piece | Subsequence description
__gnu_parallel::_Plus | Similar to std::plus, but allows two different types
__gnu_parallel::_PMWMSSortingData | Data accessed by all threads
__gnu_parallel::_PseudoSequence | Sequence 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::_QSBThreadLocal | Information local to one thread in the parallel quicksort run
__gnu_parallel::_RandomNumber | Random number generator, based on the Mersenne twister
__gnu_parallel::_RestrictedBoundedConcurrentQueue | Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. `empty()`, `size()`, and `top()` are intentionally not provided. Calling them would not make sense in a concurrent setting
__gnu_parallel::_SamplingSorter | Stable sorting functor
__gnu_parallel::_SamplingSorter | Non-__stable sorting functor
__gnu_parallel::_Settings | Class _Settings /// Run-time settings for the parallel mode including all tunable parameters
__gnu_parallel::_SplitConsistently | Split consistently
__gnu_parallel::_SplitConsistently | Split by sampling
__gnu_parallel::_SplitConsistently | Split by exact splitting
__gnu_parallel::balanced_quicksort_tag | Forces parallel sorting using balanced quicksort at compile time
__gnu_parallel::balanced_tag | Recommends parallel execution using dynamic load-balancing at compile time
__gnu_parallel::constant_size_blocks_tag | Selects the constant block size variant for std::find()
__gnu_parallel::default_parallel_tag | Recommends parallel execution using the default parallel algorithm
__gnu_parallel::equal_split_tag | Selects the equal splitting variant for std::find()
__gnu_parallel::exact_tag | Forces parallel merging with exact splitting, at compile time
__gnu_parallel::find_tag | Base class for for std::find() variants
__gnu_parallel::growing_blocks_tag | Selects the growing block size variant for std::find()
__gnu_parallel::multiway_mergesort_exact_tag | Forces parallel sorting using multiway mergesort with exact splitting at compile time
__gnu_parallel::multiway_mergesort_sampling_tag | Forces parallel sorting using multiway mergesort with splitting by sampling at compile time
__gnu_parallel::multiway_mergesort_tag | Forces parallel sorting using multiway mergesort at compile time
__gnu_parallel::omp_loop_static_tag | Recommends parallel execution using OpenMP static load-balancing at compile time
__gnu_parallel::omp_loop_tag | Recommends parallel execution using OpenMP dynamic load-balancing at compile time
__gnu_parallel::parallel_tag | Recommends parallel execution at compile time, optionally using a user-specified number of threads
__gnu_parallel::quicksort_tag | Forces parallel sorting using unbalanced quicksort at compile time
__gnu_parallel::sampling_tag | Forces parallel merging with exact splitting, at compile time
__gnu_parallel::sequential_tag | Forces sequential execution at compile time
__gnu_parallel::unbalanced_tag | Recommends parallel execution using static load-balancing at compile time
__gnu_pbds::associative_container_tag | Basic associative-container
__gnu_pbds::basic_hash_table | An abstract basic hash-based associative container
__gnu_pbds::basic_hash_tag | Basic hash
__gnu_pbds::basic_tree | An abstract basic tree-like (tree, trie) associative container
__gnu_pbds::basic_tree_tag | Basic tree
__gnu_pbds::binary_heap_tag | Binary-heap (array-based)
__gnu_pbds::binomial_heap_tag | Binomial-heap
__gnu_pbds::cc_hash_table | A concrete collision-chaining hash-based associative container
__gnu_pbds::cc_hash_tag | Collision-chaining hash
__gnu_pbds::container_base | An abstract basic associative container
__gnu_pbds::container_tag | Base data structure tag
__gnu_pbds::container_traits | Container_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_table | A concrete general-probing hash-based associative container
__gnu_pbds::gp_hash_tag | General-probing hash
__gnu_pbds::list_update | A list-update based associative container
__gnu_pbds::list_update_tag | List-update
__gnu_pbds::null_mapped_type | A mapped-policy indicating that an associative container is a set
__gnu_pbds::ov_tree_tag | Ordered-vector tree
__gnu_pbds::pairing_heap_tag | Pairing-heap
__gnu_pbds::pat_trie_tag | PATRICIA trie
__gnu_pbds::priority_queue_tag | Basic priority-queue
__gnu_pbds::rb_tree_tag | Red-black tree
__gnu_pbds::rc_binomial_heap_tag | Redundant-counter binomial-heap
__gnu_pbds::sequence_tag | Basic sequence
__gnu_pbds::splay_tree_tag | Splay tree
__gnu_pbds::string_tag | Basic string container, inclusive of strings, ropes, etc
__gnu_pbds::thin_heap_tag | Thin heap
__gnu_pbds::tree | A concrete basic tree-based associative container
__gnu_pbds::tree_tag | Tree
__gnu_pbds::trie | A concrete basic trie-based associative container
__gnu_pbds::trie_tag | Trie
__gnu_profile::__container_size_info | A container size instrumentation line in the object table
__gnu_profile::__container_size_stack_info | A container size instrumentation line in the stack table
__gnu_profile::__hashfunc_info | A hash performance instrumentation line in the object table
__gnu_profile::__hashfunc_stack_info | A hash performance instrumentation line in the stack table
__gnu_profile::__list2vector_info | A list-to-vector instrumentation line in the object table
__gnu_profile::__map2umap_info | A map-to-unordered_map instrumentation line in the object table
__gnu_profile::__map2umap_stack_info | A map-to-unordered_map instrumentation line in the stack table
__gnu_profile::__object_info_base | Base class for a line in the object table
__gnu_profile::__reentrance_guard | Reentrance guard
__gnu_profile::__stack_hash | Hash function for summary trace using call stack as index
__gnu_profile::__stack_info_base | Base class for a line in the stack table
__gnu_profile::__trace_base | Base class for all trace producers
__gnu_profile::__trace_container_size | Container size instrumentation trace producer
__gnu_profile::__trace_hash_func | Hash performance instrumentation producer
__gnu_profile::__trace_hashtable_size | Hashtable size instrumentation trace producer
__gnu_profile::__trace_map2umap | Map-to-unordered_map instrumentation producer
__gnu_profile::__trace_vector_size | Hashtable size instrumentation trace producer
__gnu_profile::__trace_vector_to_list | Vector-to-list instrumentation producer
__gnu_profile::__vector2list_info | A vector-to-list instrumentation line in the object table
__gnu_profile::__vector2list_stack_info | A vector-to-list instrumentation line in the stack table
__gnu_profile::__warning_data | Representation of a warning
std::__basic_future | Common implementation for future and shared_future
std::__codecvt_abstract_base | Common base for codecvt functions
std::__ctype_abstract_base | Common base for ctype facet
std::__debug::bitset | Class std::bitset with additional safety/checking/debug instrumentation
std::__debug::deque | Class std::deque with safety/checking/debug instrumentation
std::__debug::list | Class std::list with safety/checking/debug instrumentation
std::__debug::map | Class std::map with safety/checking/debug instrumentation
std::__debug::multimap | Class std::multimap with safety/checking/debug instrumentation
std::__debug::multiset | Class std::multiset with safety/checking/debug instrumentation
std::__debug::set | Class std::set with safety/checking/debug instrumentation
std::__debug::unordered_map | Class std::unordered_map with safety/checking/debug instrumentation
std::__debug::unordered_multimap | Class std::unordered_multimap with safety/checking/debug instrumentation
std::__debug::unordered_multiset | Class std::unordered_multiset with safety/checking/debug instrumentation
std::__debug::unordered_set | Class std::unordered_set with safety/checking/debug instrumentation
std::__debug::vector | Class std::vector with safety/checking/debug instrumentation
std::__declval_protector | Declval
std::__exception_ptr::exception_ptr | An opaque pointer to an arbitrary exception
std::__future_base | Base class and enclosing scope
std::__future_base::_Ptr | A unique_ptr based on the instantiating type
std::__future_base::_Result | Result
std::__future_base::_Result | Partial specialization for reference types
std::__future_base::_Result | Explicit specialization for void
std::__future_base::_Result_base | Base class for results
std::__future_base::_State | Shared state between a promise and one or more associated futures
std::__is_location_invariant |
std::__numeric_limits_base | Part of std::numeric_limits
std::__parallel::_CRandNumber | Functor wrapper for std::rand()
std::__profile::bitset | Class std::bitset wrapper with performance instrumentation
std::__profile::deque | Class std::deque wrapper with performance instrumentation
std::__profile::list | List wrapper with performance instrumentation
std::__profile::map | Class std::map wrapper with performance instrumentation
std::__profile::multimap | Class std::multimap wrapper with performance instrumentation
std::__profile::multiset | Class std::multiset wrapper with performance instrumentation
std::__profile::set | Class std::set wrapper with performance instrumentation
std::__profile::unordered_map | Class std::unordered_map wrapper with performance instrumentation
std::__profile::unordered_multimap | Class std::unordered_multimap wrapper with performance instrumentation
std::__profile::unordered_multiset | Unordered_multiset wrapper with performance instrumentation
std::__profile::unordered_set | Unordered_set wrapper with performance instrumentation
std::_Base_bitset |
std::_Base_bitset |
std::_Base_bitset |
std::_Build_index_tuple | Builds an _Index_tuple<0, 1, 2, ..., _Num-1>
std::_Deque_base |
std::_Deque_iterator | A deque::iterator
std::_Derives_from_binary_function | Determines if the type _Tp derives from binary_function
std::_Derives_from_unary_function | Determines if the type _Tp derives from unary_function
std::_Function_base | Base class of all polymorphic function object wrappers
std::_Function_to_function_pointer | Turns a function type into a function pointer type
std::_Fwd_list_base | Base class for forward_list
std::_Fwd_list_const_iterator | A forward_list::const_iterator
std::_Fwd_list_iterator | A forward_list::iterator
std::_Fwd_list_node | A helper node class for forward_list. This is just a linked list with a data value in each node. There is a sorting utility method
std::_Fwd_list_node_base | 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
std::_Has_result_type_helper |
std::_Index_tuple |
std::_List_base | See bits/stl_deque.h's _Deque_base for an explanation
std::_List_const_iterator | A list::const_iterator
std::_List_iterator | A list::iterator
std::_List_node | An actual node in the list
std::_List_node_base | Common part of a node in the list
std::_Maybe_get_result_type | If we have found a result_type, extract it
std::_Maybe_unary_or_binary_function |
std::_Maybe_unary_or_binary_function | Derives from `unary_function`, as appropriate
std::_Maybe_unary_or_binary_function | Derives from `binary_function`, as appropriate
std::_Maybe_wrap_member_pointer |
std::_Maybe_wrap_member_pointer |
std::_Mem_fn | Implementation of `mem_fn` for const member function pointers
std::_Mem_fn | Implementation of `mem_fn` for const volatile member function pointers
std::_Mem_fn | Implementation of `mem_fn` for volatile member function pointers
std::_Mem_fn< _Res(_Class::*)(_ArgTypes...)> | Implementation of `mem_fn` for member function pointers
std::_Mu |
std::_Mu |
std::_Mu |
std::_Mu |
std::_Placeholder | The 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_base | See 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_impl | Retrieve result type for a const member function pointer
std::_Weak_result_type_impl | Retrieve result type for a const volatile member function pointer
std::_Weak_result_type_impl | Retrieve result type for a volatile member function pointer
std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...)> | Retrieve result type for a member function pointer
std::add_lvalue_reference | Add_lvalue_reference
std::add_rvalue_reference | Add_rvalue_reference
std::adopt_lock_t | Assume the calling thread has already obtained mutex ownership /// and manage it
std::aligned_storage | Alignment type
std::allocator | The standard allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
std::allocator | Allocator<void> specialization
std::atomic | Atomic /// 29.4.3, Generic atomic type, primary class template
std::atomic | Partial specialization for pointer types
std::atomic | Explicit specialization for bool
std::atomic | Explicit specialization for char
std::atomic | Explicit specialization for char16_t
std::atomic | Explicit specialization for char32_t
std::atomic | Explicit specialization for int
std::atomic | Explicit specialization for long
std::atomic | Explicit specialization for long long
std::atomic | Explicit specialization for short
std::atomic | Explicit specialization for signed char
std::atomic | Explicit specialization for unsigned char
std::atomic | Explicit specialization for unsigned int
std::atomic | Explicit specialization for unsigned long
std::atomic | Explicit specialization for unsigned long long
std::atomic | Explicit specialization for unsigned short
std::atomic | Explicit specialization for void*
std::atomic | Explicit specialization for wchar_t
std::auto_ptr | A simple smart pointer providing strict ownership semantics
std::auto_ptr_ref |
std::back_insert_iterator | Turns assignment into insertion
std::bad_alloc | Exception 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_cast | Thrown 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_call | Exception class thrown when class template function's operator() is called with an empty target
std::bad_typeid | Thrown when a NULL pointer in a `typeid` expression is used
std::basic_filebuf | The actual work of input and output (for files).This class associates both its input and output sequence with an external disk file, and maintains a joint file position for both sequences. Many of its semantics are described in terms of similar behavior in the Standard C Library's `FILE` streams
std::basic_fstream | Controlling input and output for files.This class supports reading from and writing to named files, using the inherited functions from std::basic_iostream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as `sb`
std::basic_ifstream | Controlling input for files.This class supports reading from named files, using the inherited functions from std::basic_istream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as `sb`
std::basic_ios | Virtual base class for all stream classes.Most of the member functions called dispatched on stream objects (e.g., `std::cout.foo(bar)`;) are consolidated in this class
std::basic_iostream | Merging istream and ostream capabilities.This class multiply inherits from the input and output stream classes simply to provide a single interface
std::basic_istream | Controlling input.This is the base class for all input streams. It provides text formatting of all builtin types, and communicates with any class derived from basic_streambuf to do the actual input
std::basic_istream::sentry | Performs setup work for input streams
std::basic_istringstream | Controlling input for std::string.This class supports reading from objects of type std::basic_string, using the inherited functions from std::basic_istream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as `sb`
std::basic_ofstream | Controlling output for files.This class supports reading from named files, using the inherited functions from std::basic_ostream. To control the associated sequence, an instance of std::basic_filebuf is used, which this page refers to as `sb`
std::basic_ostream | Controlling output.This is the base class for all output streams. It provides text formatting of all builtin types, and communicates with any class derived from basic_streambuf to do the actual output
std::basic_ostream::sentry | Performs setup work for output streams
std::basic_ostringstream | Controlling output for std::string.This class supports writing to objects of type std::basic_string, using the inherited functions from std::basic_ostream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as `sb`
std::basic_streambuf | The actual work of input and output (interface).This is a base class. Derived stream buffers each control a pair of character sequences: one for input, and one for output
std::basic_string | Managing sequences of characters and character-like objects
std::basic_stringbuf | The actual work of input and output (for std::string).This class associates either or both of its input and output sequences with a sequence of characters, which can be initialized from, or made available as, a `std::basic_string`. (Paraphrased from [27.7.1]/1.)
std::basic_stringstream | Controlling input and output for std::string.This class supports reading from and writing to objects of type std::basic_string, using the inherited functions from std::basic_iostream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as `sb`
std::bernoulli_distribution | A Bernoulli random number distribution
std::bernoulli_distribution::param_type |
std::bidirectional_iterator_tag | Bidirectional iterators support a superset of forward iterator /// operations
std::binary_function |
std::binary_negate | One of the negation functors
std::binder1st | One of the binder functors
std::binder2nd | One of the binder functors
std::binomial_distribution | A discrete binomial random number distribution
std::binomial_distribution::param_type |
std::bitset | The bitset class represents a fixed-size sequence of bits
std::bitset::reference |
std::cauchy_distribution | A cauchy_distribution random number distribution
std::cauchy_distribution::param_type |
std::char_traits | Basis for explicit traits specializations
std::char_traits | Char_traits<__gnu_cxx::character> specialization
std::char_traits | 21.1.3.1 char_traits specializations
std::char_traits | 21.1.3.2 char_traits specializations
std::chi_squared_distribution | A chi_squared_distribution random number distribution
std::chi_squared_distribution::param_type |
std::chrono::duration | Duration
std::chrono::duration_values | Duration_values
std::chrono::system_clock | System_clock
std::chrono::time_point | Time_point
std::chrono::treat_as_floating_point | Treat_as_floating_point
std::codecvt | Primary class template codecvt.NB: Generic, mostly useless implementation
std::codecvt | Codecvt<InternT, _ExternT, encoding_state> specialization
std::codecvt | Class codecvt<char, char, mbstate_t> specialization
std::codecvt | Class codecvt<wchar_t, char, mbstate_t> specialization
std::codecvt_base | Empty base class for codecvt facet [22.2.1.5]
std::codecvt_byname | Class codecvt_byname [22.2.1.6]
std::collate | Facet for localized string comparison
std::collate_byname | Class collate_byname [22.2.4.2]
std::complex |
std::condition_variable | Condition_variable
std::condition_variable_any | Condition_variable_any
std::conditional | Conditional
std::const_mem_fun1_ref_t | One of the adaptors for member /// pointers
std::const_mem_fun1_t | One of the adaptors for member /// pointers
std::const_mem_fun_ref_t | One of the adaptors for member /// pointers
std::const_mem_fun_t | One of the adaptors for member /// pointers
std::ctype | Primary class template ctype facet.This template class defines classification and conversion functions for character sets. It wraps cctype functionality. Ctype gets used by streams for many I/O operations
std::ctype | The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well
std::ctype | The ctype<wchar_t> specialization.This class defines classification and conversion functions for the wchar_t type. It gets used by wchar_t streams for many I/O operations. The wchar_t specialization provides a number of optimizations as well
std::ctype_base | Base class for ctype
std::ctype_byname | Class ctype_byname [22.2.1.2]
std::ctype_byname | 22.2.1.4 Class ctype_byname specializations
std::decay | Decay
std::decimal::decimal128 | 3.2.4 Class decimal128
std::decimal::decimal32 | 3.2.2 Class decimal32
std::decimal::decimal64 | 3.2.3 Class decimal64
std::default_delete | Primary template, default_delete
std::default_delete< _Tp[]> | Specialization, default_delete
std::defer_lock_t | Do not acquire ownership of the mutex
std::deque | A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
std::discard_block_engine |
std::discrete_distribution | A discrete_distribution random number distribution
std::discrete_distribution::param_type |
std::divides | One of the math functors
std::domain_error |
std::enable_if | Enable_if
std::enable_shared_from_this | Base class allowing use of member function shared_from_this
std::equal_to | One of the comparison functors
std::error_category | Error_category
std::error_code | Error_code
std::error_condition | Error_condition
std::exception | Base class for all library exceptions
std::exponential_distribution | An exponential continuous distribution for random numbers
std::exponential_distribution::param_type |
std::extreme_value_distribution | A extreme_value_distribution random number distribution
std::extreme_value_distribution::param_type |
std::fisher_f_distribution | A fisher_f_distribution random number distribution
std::fisher_f_distribution::param_type |
std::forward_iterator_tag | Forward iterators support a superset of input iterator operations
std::forward_list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
std::fpos | Class representing stream positions
std::front_insert_iterator | Turns assignment into insertion
std::function< _Res(_ArgTypes...)> | Primary class template for std::function.Polymorphic function wrapper
std::future | Primary template for future
std::future | Partial specialization for future<R&>
std::future | Explicit specialization for future<void>
std::future_error | Exception type thrown by futures
std::gamma_distribution | A gamma continuous distribution for random numbers
std::gamma_distribution::param_type |
std::geometric_distribution | A discrete geometric random number distribution
std::geometric_distribution::param_type |
std::greater | One of the comparison functors
std::greater_equal | One of the comparison functors
std::gslice | Class defining multi-dimensional subset of an array
std::gslice_array | Reference to multi-dimensional subset of an array
std::has_nothrow_assign | Has_nothrow_assign
std::has_nothrow_copy_constructor | Has_nothrow_copy_constructor
std::has_nothrow_default_constructor | Has_nothrow_default_constructor
std::has_trivial_assign | Has_trivial_assign
std::has_trivial_copy_constructor | Has_trivial_copy_constructor
std::has_trivial_default_constructor | Has_trivial_default_constructor
std::has_trivial_destructor | Has_trivial_destructor
std::hash | Primary class template hash
std::hash | Std::hash specialization for bitset
std::hash | Std::hash specialization for vector<bool>
std::hash | Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hash | Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
std::hash | Std::hash specialization for bitset
std::hash | Std::hash specialization for vector<bool>
std::hash | Partial specializations for pointer types
std::hash | Std::hash specialization for error_code
std::hash | Std::hash specialization for string
std::hash | Std::hash specialization for thread::id
std::hash | Std::hash specialization for u16string
std::hash | Std::hash specialization for u32string
std::hash | Std::hash specialization for wstring
std::hash<::bitset | Std::hash specialization for bitset
std::hash<::vector | Std::hash specialization for vector<bool>
std::identity | Identity
std::independent_bits_engine |
std::indirect_array | Reference to arbitrary subset of an array
std::initializer_list | Initializer_list
std::input_iterator_tag | Marking input iterators
std::insert_iterator | Turns assignment into insertion
std::invalid_argument |
std::ios_base | The 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::failure | These are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
std::is_base_of | Is_base_of
std::is_bind_expression | Determines if the given type _Tp is a function object should be treated as a subexpression when evaluating calls to function objects returned by bind(). [TR1 3.6.1]
std::is_bind_expression | Class template _Bind is always a bind expression
std::is_bind_expression | Class template _Bind is always a bind expression
std::is_constructible | Is_constructible
std::is_convertible | Is_convertible
std::is_error_code_enum | Is_error_code_enum
std::is_error_condition_enum | Is_error_condition_enum
std::is_explicitly_convertible | Is_explicitly_convertible
std::is_lvalue_reference | Is_lvalue_reference
std::is_placeholder | Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
std::is_placeholder |
std::is_pod | Is_pod
std::is_reference | Is_reference
std::is_rvalue_reference | Is_rvalue_reference
std::is_signed | Is_signed
std::is_standard_layout | Is_standard_layout
std::is_trivial | Is_trivial
std::is_unsigned | Is_unsigned
std::istream_iterator | Provides input iterator semantics for streams
std::istreambuf_iterator | Provides input iterator semantics for streambufs
std::iterator | Common iterator class
std::iterator_traits | Traits class for iterators
std::iterator_traits | Partial specialization for pointer types
std::iterator_traits | Partial specialization for const pointer types
std::length_error |
std::less | One of the comparison functors
std::less_equal | One of the comparison functors
std::linear_congruential_engine | A model of a linear congruential random number generator
std::list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
std::locale | Container 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::facet | Localization 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::id | Facet ID class.The ID class provides facets with an index used to identify them. Every facet class must define a public static member locale::id, or be derived from a facet that provides this member, otherwise the facet cannot be used in a locale. The locale::id ensures that each class type gets a unique identifier
std::lock_guard | Scoped lock idiom
std::logic_error | One of two subclasses of exception
std::logical_and | One of the Boolean operations functors
std::logical_not | One of the Boolean operations functors
std::logical_or | One of the Boolean operations functors
std::lognormal_distribution | A lognormal_distribution random number distribution
std::lognormal_distribution::param_type |
std::make_signed | Make_signed
std::make_unsigned | Make_unsigned
std::map | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::mask_array | Reference to selected subset of an array
std::mem_fun1_ref_t | One of the adaptors for member /// pointers
std::mem_fun1_t | One of the adaptors for member /// pointers
std::mem_fun_ref_t | One of the adaptors for member /// pointers
std::mem_fun_t | One of the adaptors for member /// pointers
std::messages | Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined
std::messages_base | Messages facet base class providing catalog typedef
std::messages_byname | Class messages_byname [22.2.7.2]
std::minus | One of the math functors
std::modulus | One of the math functors
std::money_base | Money format ordering data.This class contains an ordered array of 4 fields to represent the pattern for formatting a money amount. Each field may contain one entry from the part enum. symbol, sign, and value must be present and the remaining field must contain either none or space
std::money_get | Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
std::money_put | Primary class template money_put.This facet encapsulates the code to format and output a monetary amount
std::moneypunct | Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
std::moneypunct_byname | Class moneypunct_byname [22.2.6.4]
std::move_iterator |
std::multimap | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
std::multiplies | One of the math functors
std::multiset | A standard container made up of elements, which can be retrieved in logarithmic time
std::mutex | Mutex
std::negate | One of the math functors
std::negative_binomial_distribution | A negative_binomial_distribution random number distribution
std::negative_binomial_distribution::param_type |
std::nested_exception | Exception class with exception_ptr data member
std::normal_distribution | A normal continuous distribution for random numbers
std::normal_distribution::param_type |
std::not_equal_to | One of the comparison functors
std::num_get | Primary class template num_get.This facet encapsulates the code to parse and return a number from a string. It is used by the istream numeric extraction operators
std::num_put | Primary class template num_put.This facet encapsulates the code to convert a number to a string. It is used by the ostream numeric insertion operators
std::numeric_limits | Properties of fundamental types
std::numeric_limits | Numeric_limits<bool> specialization
std::numeric_limits | Numeric_limits<char> specialization
std::numeric_limits | Numeric_limits<char16_t> specialization
std::numeric_limits | Numeric_limits<char32_t> specialization
std::numeric_limits | Numeric_limits<double> specialization
std::numeric_limits | Numeric_limits<float> specialization
std::numeric_limits | Numeric_limits<int> specialization
std::numeric_limits | Numeric_limits<long> specialization
std::numeric_limits | Numeric_limits<long double> specialization
std::numeric_limits | Numeric_limits<long long> specialization
std::numeric_limits | Numeric_limits<short> specialization
std::numeric_limits | Numeric_limits<signed char> specialization
std::numeric_limits | Numeric_limits<unsigned char> specialization
std::numeric_limits | Numeric_limits<unsigned int> specialization
std::numeric_limits | Numeric_limits<unsigned long> specialization
std::numeric_limits | Numeric_limits<unsigned long long> specialization
std::numeric_limits | Numeric_limits<unsigned short> specialization
std::numeric_limits | Numeric_limits<wchar_t> specialization
std::numpunct | Primary class template numpunct.This facet stores several pieces of information related to printing and scanning numbers, such as the decimal point character. It takes a template parameter specifying the char type. The numpunct facet is used by streams for many I/O operations involving numbers
std::numpunct_byname | Class numpunct_byname [22.2.3.2]
std::once_flag | Once_flag
std::ostream_iterator | Provides output iterator semantics for streams
std::ostreambuf_iterator | Provides output iterator semantics for streambufs
std::out_of_range |
std::output_iterator_tag | Marking output iterators
std::overflow_error |
std::owner_less | Partial specialization of owner_less for shared_ptr
std::owner_less | Partial specialization of owner_less for weak_ptr
std::packaged_task< _Res(_ArgTypes...)> | Packaged_task
std::pair | Pair holds two objects of arbitrary type
std::piecewise_constant_distribution | A piecewise_constant_distribution random number distribution
std::piecewise_constant_distribution::param_type |
std::piecewise_linear_distribution | A piecewise_linear_distribution random number distribution
std::piecewise_linear_distribution::param_type |
std::plus | One of the math functors
std::pointer_to_binary_function | One of the adaptors for function pointers
std::pointer_to_unary_function | One of the adaptors for function pointers
std::poisson_distribution | A discrete Poisson random number distribution
std::poisson_distribution::param_type |
std::priority_queue | A standard container automatically sorting its contents
std::promise | Primary template for promise
std::promise | Partial specialization for promise<R&>
std::promise | Explicit specialization for promise<void>
std::queue | A standard container giving FIFO behavior
std::random_access_iterator_tag | Random-access iterators support a superset of bidirectional /// iterator operations
std::random_device |
std::range_error |
std::ratio | Provides compile-time rational arithmetic
std::ratio_add | Ratio_add
std::ratio_divide | Ratio_divide
std::ratio_equal | Ratio_equal
std::ratio_greater | Ratio_greater
std::ratio_greater_equal | Ratio_greater_equal
std::ratio_less | Ratio_less
std::ratio_less_equal | Ratio_less_equal
std::ratio_multiply | Ratio_multiply
std::ratio_not_equal | Ratio_not_equal
std::ratio_subtract | Ratio_subtract
std::raw_storage_iterator |
std::recursive_mutex | Recursive_mutex
std::recursive_timed_mutex | Recursive_timed_mutex
std::reference_wrapper | Primary class template for reference_wrapper
std::remove_reference | Remove_reference
std::reverse_iterator |
std::runtime_error | One of two subclasses of exception
std::seed_seq | Generates sequences of seeds for random number generators
std::set | A standard container made up of unique keys, which can be retrieved in logarithmic time
std::shared_future | Primary template for shared_future
std::shared_future | Partial specialization for shared_future<R&>
std::shared_future | Explicit specialization for shared_future<void>
std::shared_ptr | A smart pointer with reference-counted copy semantics
std::shuffle_order_engine | Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits `__w`
std::slice | Class defining one-dimensional subset of an array
std::slice_array | Reference to one-dimensional subset of an array
std::stack | A standard container giving FILO behavior
std::student_t_distribution | A student_t_distribution random number distribution
std::student_t_distribution::param_type |
std::system_error | Thrown to indicate error code of underlying system
std::thread | Thread
std::thread::id | Thread::id
std::time_base | Time format ordering data.This class provides an enum representing different orderings of time: day, month, and year
std::time_get | Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators
std::time_get_byname | Class time_get_byname [22.2.5.2]
std::time_put | Primary class template time_put.This facet encapsulates the code to format and output dates and times according to formats used by strftime()
std::time_put_byname | Class time_put_byname [22.2.5.4]
std::timed_mutex | Timed_mutex
std::tr1::__is_member_pointer_helper | Is_member_pointer
std::tr1::add_const | Add_const
std::tr1::add_cv | Add_cv
std::tr1::add_pointer | Add_pointer
std::tr1::add_volatile | Add_volatile
std::tr1::alignment_of | Alignment_of
std::tr1::array | A standard container for storing a fixed size sequence of elements
std::tr1::bad_weak_ptr | Exception possibly thrown by `shared_ptr`
std::tr1::extent | Extent
std::tr1::has_virtual_destructor | Has_virtual_destructor
std::tr1::integral_constant | Integral_constant
std::tr1::is_abstract | Is_abstract
std::tr1::is_arithmetic | Is_arithmetic
std::tr1::is_array | Is_array
std::tr1::is_class | Is_class
std::tr1::is_compound | Is_compound
std::tr1::is_const | Is_const
std::tr1::is_empty | Is_empty
std::tr1::is_enum | Is_enum
std::tr1::is_floating_point | Is_floating_point
std::tr1::is_function | Is_function
std::tr1::is_fundamental | Is_fundamental
std::tr1::is_integral | Is_integral
std::tr1::is_member_function_pointer | Is_member_function_pointer
std::tr1::is_member_object_pointer | Is_member_object_pointer
std::tr1::is_object | Is_object
std::tr1::is_pointer | Is_pointer
std::tr1::is_polymorphic | Is_polymorphic
std::tr1::is_same | Is_same
std::tr1::is_scalar | Is_scalar
std::tr1::is_union | Is_union
std::tr1::is_void | Is_void
std::tr1::is_volatile | Is_volatile
std::tr1::rank | Rank
std::tr1::remove_all_extents | Remove_all_extents
std::tr1::remove_const | Remove_const
std::tr1::remove_cv | Remove_cv
std::tr1::remove_extent | Remove_extent
std::tr1::remove_pointer | Remove_pointer
std::tr1::remove_volatile | Remove_volatile
std::try_to_lock_t | Try to acquire ownership of the mutex without blocking
std::tuple | Tuple
std::tuple | Tuple (2-element), with construction and assignment from a pair
std::tuple_element |
std::tuple_element |
std::tuple_size | Class tuple_size
std::type_info | Part of RTTI
std::unary_function |
std::unary_negate | One of the negation functors
std::underflow_error |
std::uniform_int_distribution | Uniform discrete distribution for random numbers. A discrete random distribution on the range with equal probability throughout the range
std::uniform_int_distribution::param_type |
std::uniform_real_distribution | Uniform continuous distribution for random numbers
std::uniform_real_distribution::param_type |
std::unique_lock | Unique_lock
std::unique_ptr | 20.7.12.2 unique_ptr for single objects
std::unique_ptr | 20.7.12.3 unique_ptr for array objects with a runtime length
std::unordered_map | A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys
std::unordered_multimap | A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
std::unordered_multiset | A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
std::unordered_set | A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
std::valarray | Smart array designed to support numeric processing
std::vector | A standard container which offers fixed time access to individual elements in any order
std::vector | A specialization of vector for booleans which offers fixed time access to individual elements in any order
std::weak_ptr | A smart pointer with weak semantics
std::weibull_distribution | A weibull_distribution random number distribution
std::weibull_distribution::param_type |