Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
| __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::__alloc_traits | Uniform interface to C++98 and C++0x allocators |
| __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 |
| __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 |
| __gnu_cxx::new_allocator | An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard |
| __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::_After_nth_from | |
| __gnu_debug::_BeforeBeginHelper | |
| __gnu_debug::_Equal_to | |
| __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_local_iterator | Safe iterator wrapper |
| __gnu_debug::_Safe_local_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::_Safe_unordered_container | Base class for constructing a safe unordered container type that tracks iterators that reference it |
| __gnu_debug::_Safe_unordered_container_base | Base class that supports tracking of local iterators that reference an unordered container |
| __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_tag | Basic associative-container |
| __gnu_pbds::basic_branch | |
| __gnu_pbds::basic_branch_tag | Basic branch structure |
| __gnu_pbds::basic_hash_table | |
| __gnu_pbds::basic_hash_tag | Basic hash structure |
| __gnu_pbds::basic_invalidation_guarantee | |
| __gnu_pbds::binary_heap_tag | Binary-heap (array-based) |
| __gnu_pbds::binomial_heap_tag | Binomial-heap |
| __gnu_pbds::cc_hash_max_collision_check_resize_trigger | A resize trigger policy based on collision checks. It keeps the simulated load factor lower than some given load factor |
| __gnu_pbds::cc_hash_table | |
| __gnu_pbds::cc_hash_tag | Collision-chaining hash |
| __gnu_pbds::container_error | Base class for exceptions |
| __gnu_pbds::container_tag | Base data structure tag |
| __gnu_pbds::container_traits | Container traits |
| __gnu_pbds::container_traits_base | Specialization, binary heap |
| __gnu_pbds::container_traits_base | Specialization, binomial heap |
| __gnu_pbds::container_traits_base | Specialization, cc hash |
| __gnu_pbds::container_traits_base | Specialization, gp hash |
| __gnu_pbds::container_traits_base | Specialization, list update |
| __gnu_pbds::container_traits_base | Specialization, ov tree |
| __gnu_pbds::container_traits_base | Specialization, pairing heap |
| __gnu_pbds::container_traits_base | Specialization, pat trie |
| __gnu_pbds::container_traits_base | Specialization, rb tree |
| __gnu_pbds::container_traits_base | Specialization, rc binomial heap |
| __gnu_pbds::container_traits_base | Specialization, splay tree |
| __gnu_pbds::container_traits_base | Specialization, thin heap |
| __gnu_pbds::detail::bin_search_tree_const_it_ | Const iterator |
| __gnu_pbds::detail::bin_search_tree_const_node_it_ | Const node iterator |
| __gnu_pbds::detail::bin_search_tree_it_ | Iterator |
| __gnu_pbds::detail::bin_search_tree_node_it_ | Node iterator |
| __gnu_pbds::detail::bin_search_tree_traits | Binary search tree traits, primary template |
| __gnu_pbds::detail::bin_search_tree_traits | Specialization |
| __gnu_pbds::detail::binary_heap | |
| __gnu_pbds::detail::binary_heap_const_iterator_ | Const point-type iterator |
| __gnu_pbds::detail::binary_heap_point_const_iterator_ | Const point-type iterator |
| __gnu_pbds::detail::binomial_heap | |
| __gnu_pbds::detail::binomial_heap_base | Base class for binomial heap |
| __gnu_pbds::detail::branch_policy | Primary template, base class for branch structure policies |
| __gnu_pbds::detail::branch_policy | Specialization for const iterators |
| __gnu_pbds::detail::cc_ht_map | |
| __gnu_pbds::detail::cond_dealtor | Conditional deallocate constructor argument |
| __gnu_pbds::detail::container_base_dispatch | Specialization for binary_heap |
| __gnu_pbds::detail::container_base_dispatch | Specialization for binomial_heap |
| __gnu_pbds::detail::container_base_dispatch | Specialization for pairing_heap |
| __gnu_pbds::detail::container_base_dispatch | Specialization for rc_binary_heap |
| __gnu_pbds::detail::container_base_dispatch | Specialization for thin_heap |
| __gnu_pbds::detail::container_base_dispatch | Specialization colision-chaining hash map |
| __gnu_pbds::detail::container_base_dispatch | Specialization general-probe hash map |
| __gnu_pbds::detail::container_base_dispatch | Specialization for list-update map |
| __gnu_pbds::detail::container_base_dispatch | Specialization ordered-vector tree map |
| __gnu_pbds::detail::container_base_dispatch | Specialization for PATRICIA trie map |
| __gnu_pbds::detail::container_base_dispatch | Specialization for R-B tree map |
| __gnu_pbds::detail::container_base_dispatch | Specialization splay tree map |
| __gnu_pbds::detail::container_base_dispatch | Specialization colision-chaining hash set |
| __gnu_pbds::detail::container_base_dispatch | Specialization general-probe hash set |
| __gnu_pbds::detail::container_base_dispatch | Specialization for list-update set |
| __gnu_pbds::detail::container_base_dispatch | Specialization ordered-vector tree set |
| __gnu_pbds::detail::container_base_dispatch | Specialization for PATRICIA trie set |
| __gnu_pbds::detail::container_base_dispatch | Specialization for R-B tree set |
| __gnu_pbds::detail::container_base_dispatch | Specialization splay tree set |
| __gnu_pbds::detail::default_comb_hash_fn | Primary template, default_comb_hash_fn |
| __gnu_pbds::detail::default_eq_fn | Primary template, default_eq_fn |
| __gnu_pbds::detail::default_hash_fn | Primary template, default_hash_fn |
| __gnu_pbds::detail::default_probe_fn | Primary template, default_probe_fn |
| __gnu_pbds::detail::default_resize_policy | Primary template, default_resize_policy |
| __gnu_pbds::detail::default_trie_access_traits | Partial specialization, default_trie_access_traits |
| __gnu_pbds::detail::default_update_policy | Default update policy |
| __gnu_pbds::detail::dumnode_const_iterator | Constant node iterator |
| __gnu_pbds::detail::entry_cmp | Specialization, false |
| __gnu_pbds::detail::entry_cmp::type | Compare plus entry |
| __gnu_pbds::detail::entry_cmp | Specialization, true |
| __gnu_pbds::detail::entry_pred | Specialization, false |
| __gnu_pbds::detail::entry_pred | Specialization, true |
| __gnu_pbds::detail::eq_by_less | Equivalence function |
| __gnu_pbds::detail::gp_ht_map | |
| __gnu_pbds::detail::hash_eq_fn | Specialization 1 - The client requests that hash values not be stored |
| __gnu_pbds::detail::hash_eq_fn | Specialization 2 - The client requests that hash values be stored |
| __gnu_pbds::detail::hash_load_check_resize_trigger_size_base | Specializations |
| __gnu_pbds::detail::left_child_next_sibling_heap | Base class for a basic heap |
| __gnu_pbds::detail::left_child_next_sibling_heap_const_iterator_ | Const point-type iterator |
| __gnu_pbds::detail::left_child_next_sibling_heap_node_ | Node |
| __gnu_pbds::detail::left_child_next_sibling_heap_node_point_const_iterator_ | Const point-type iterator |
| __gnu_pbds::detail::lu_counter_metadata | A list-update metadata type that moves elements to the front of the list based on the counter algorithm |
| __gnu_pbds::detail::lu_counter_policy_base | Base class for list-update counter policy |
| __gnu_pbds::detail::lu_map | List-based (with updates) associative container. Skip to the lu, my darling |
| __gnu_pbds::detail::mask_based_range_hashing | Range hashing policy |
| __gnu_pbds::detail::mod_based_range_hashing | Mod based range hashing |
| __gnu_pbds::detail::no_throw_copies | Primary template |
| __gnu_pbds::detail::no_throw_copies | Specialization |
| __gnu_pbds::detail::ov_tree_map | Ordered-vector tree associative-container.
|
| __gnu_pbds::detail::ov_tree_map | Conditional destructor |
| __gnu_pbds::detail::ov_tree_node_const_it_ | Const node reference |
| __gnu_pbds::detail::ov_tree_node_it_ | Node reference |
| __gnu_pbds::detail::pairing_heap | |
| __gnu_pbds::detail::pat_trie_base | Base type for PATRICIA trees |
| __gnu_pbds::detail::pat_trie_base::_CIter | Const iterator |
| __gnu_pbds::detail::pat_trie_base::_Head | Head node for PATRICIA tree |
| __gnu_pbds::detail::pat_trie_base::_Inode | Internal node type, PATRICIA tree |
| __gnu_pbds::detail::pat_trie_base::_Inode::const_iterator | Constant child iterator |
| __gnu_pbds::detail::pat_trie_base::_Inode::iterator | Child iterator |
| __gnu_pbds::detail::pat_trie_base::_Iter | Iterator |
| __gnu_pbds::detail::pat_trie_base::_Leaf | Leaf node for PATRICIA tree |
| __gnu_pbds::detail::pat_trie_base::_Metadata | Metadata base primary template |
| __gnu_pbds::detail::pat_trie_base::_Metadata | Specialization for null metadata |
| __gnu_pbds::detail::pat_trie_base::_Node_base | Node base |
| __gnu_pbds::detail::pat_trie_base::_Node_citer | Node const iterator |
| __gnu_pbds::detail::pat_trie_base::_Node_iter | Node iterator |
| __gnu_pbds::detail::pat_trie_map | PATRICIA trie.This implementation loosely borrows ideas from: 1) Fast Mergeable Integer Maps, Okasaki, Gill 1998 2) Ptset: Sets of integers implemented as Patricia trees, Jean-Christophe Filliatr, 2000 |
| __gnu_pbds::detail::probe_fn_base | Probe functor base |
| __gnu_pbds::detail::ranged_hash_fn | |
| __gnu_pbds::detail::ranged_hash_fn | |
| __gnu_pbds::detail::ranged_hash_fn | |
| __gnu_pbds::detail::ranged_hash_fn | |
| __gnu_pbds::detail::ranged_probe_fn | |
| __gnu_pbds::detail::ranged_probe_fn | |
| __gnu_pbds::detail::ranged_probe_fn | |
| __gnu_pbds::detail::rb_tree_map | Red-Black tree.This implementation uses an idea from the SGI STL (using a header node which is needed for efficient iteration) |
| __gnu_pbds::detail::rb_tree_node_ | Node for Red-Black trees |
| __gnu_pbds::detail::rc | Redundant binary counter |
| __gnu_pbds::detail::rc_binomial_heap | |
| __gnu_pbds::detail::resize_policy | Resize policy for binary heap |
| __gnu_pbds::detail::splay_tree_map | Splay tree.
|
| __gnu_pbds::detail::splay_tree_node_ | Node for splay tree |
| __gnu_pbds::detail::stored_data | Primary template for representation of stored data. Two types of data can be stored: value and hash |
| __gnu_pbds::detail::stored_data | Specialization for representation of stored data of just value type |
| __gnu_pbds::detail::stored_hash | Stored hash |
| __gnu_pbds::detail::stored_value | Stored value |
| __gnu_pbds::detail::synth_access_traits | Synthetic element access traits |
| __gnu_pbds::detail::thin_heap | |
| __gnu_pbds::detail::tree_metadata_helper | Specialization, false |
| __gnu_pbds::detail::tree_metadata_helper | Specialization, true |
| __gnu_pbds::detail::tree_node_metadata_dispatch | Tree node metadata dispatch |
| __gnu_pbds::detail::tree_traits | Tree traits |
| __gnu_pbds::detail::tree_traits | Specialization |
| __gnu_pbds::detail::tree_traits | Specialization |
| __gnu_pbds::detail::tree_traits | Specialization |
| __gnu_pbds::detail::tree_traits | Specialization |
| __gnu_pbds::detail::tree_traits | Specialization |
| __gnu_pbds::detail::trie_metadata_helper | Specialization, false |
| __gnu_pbds::detail::trie_metadata_helper | Specialization, true |
| __gnu_pbds::detail::trie_node_metadata_dispatch | Trie node metadata dispatch |
| __gnu_pbds::detail::trie_policy_base | Base class for trie policies |
| __gnu_pbds::detail::trie_traits | Specialization |
| __gnu_pbds::detail::trie_traits | Specialization |
| __gnu_pbds::detail::type_base | |
| __gnu_pbds::detail::type_base | |
| __gnu_pbds::detail::type_base | |
| __gnu_pbds::detail::type_base | |
| __gnu_pbds::detail::type_dispatch | Type base dispatch |
| __gnu_pbds::detail::types_traits | Traits for abstract types |
| __gnu_pbds::direct_mask_range_hashing | A mask range-hashing class (uses a bitmask) |
| __gnu_pbds::direct_mod_range_hashing | A mod range-hashing class (uses the modulo function) |
| __gnu_pbds::gp_hash_table | |
| __gnu_pbds::gp_hash_tag | General-probing hash |
| __gnu_pbds::hash_exponential_size_policy | A size policy whose sequence of sizes form an exponential sequence (typically powers of 2 |
| __gnu_pbds::hash_load_check_resize_trigger | A resize trigger policy based on a load check. It keeps the load factor between some load factors load_min and load_max |
| __gnu_pbds::hash_prime_size_policy | A size policy whose sequence of sizes form a nearly-exponential sequence of primes |
| __gnu_pbds::hash_standard_resize_policy | A resize policy which delegates operations to size and trigger policies |
| __gnu_pbds::insert_error | An entry cannot be inserted into a container object for logical reasons (not, e.g., if memory is unabvailable, in which case the allocator_type's exception will be thrown) |
| __gnu_pbds::join_error | A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps |
| __gnu_pbds::linear_probe_fn | A probe sequence policy using fixed increments |
| __gnu_pbds::list_update | |
| __gnu_pbds::list_update_tag | List-update |
| __gnu_pbds::lu_counter_policy | |
| __gnu_pbds::lu_move_to_front_policy | |
| __gnu_pbds::null_node_update | A null node updator, indicating that no node updates are required |
| __gnu_pbds::null_type | Represents no type, or absence of type, for template tricks |
| __gnu_pbds::ov_tree_tag | Ordered-vector tree |
| __gnu_pbds::pairing_heap_tag | Pairing-heap |
| __gnu_pbds::pat_trie_tag | PATRICIA trie |
| __gnu_pbds::point_invalidation_guarantee | |
| __gnu_pbds::priority_queue | |
| __gnu_pbds::priority_queue_tag | Basic priority-queue |
| __gnu_pbds::quadratic_probe_fn | A probe sequence policy using square increments |
| __gnu_pbds::range_invalidation_guarantee | |
| __gnu_pbds::rb_tree_tag | Red-black tree |
| __gnu_pbds::rc_binomial_heap_tag | Redundant-counter binomial-heap |
| __gnu_pbds::resize_error | A container cannot be resized |
| __gnu_pbds::sample_probe_fn | A sample probe policy |
| __gnu_pbds::sample_range_hashing | A sample range-hashing functor |
| __gnu_pbds::sample_ranged_hash_fn | A sample ranged-hash functor |
| __gnu_pbds::sample_ranged_probe_fn | A sample ranged-probe functor |
| __gnu_pbds::sample_resize_policy | A sample resize policy |
| __gnu_pbds::sample_resize_trigger | A sample resize trigger policy |
| __gnu_pbds::sample_size_policy | A sample size policy |
| __gnu_pbds::sample_tree_node_update | A sample node updator |
| __gnu_pbds::sample_trie_access_traits | A sample trie element access traits |
| __gnu_pbds::sample_trie_node_update | A sample node updator |
| __gnu_pbds::sample_update_policy | A sample list-update policy |
| __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 | |
| __gnu_pbds::tree_order_statistics_node_update | Functor updating ranks of entrees |
| __gnu_pbds::tree_tag | Basic tree structure |
| __gnu_pbds::trie | |
| __gnu_pbds::trie_order_statistics_node_update | Functor updating ranks of entrees |
| __gnu_pbds::trie_prefix_search_node_update | A node updator that allows tries to be searched for the range of values that match a certain prefix |
| __gnu_pbds::trie_string_access_traits | |
| __gnu_pbds::trie_tag | Basic trie structure |
| __gnu_pbds::trivial_iterator_tag | A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities |
| __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 |
| const_iterator_ | Const range-type iterator |
| iterator_ | Range-type iterator |
| point_const_iterator_ | Const point-type iterator |
| point_iterator_ | Find type iterator |
| std::__atomic_base | Base class for atomic integrals |
| std::__atomic_base | Partial specialization for pointer types |
| std::__atomic_flag_base | Base type for atomic_flag |
| 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::forward_list | Class std::forward_list 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::__detail::_List_node_base | Common part of a node in the list |
| std::__exception_ptr::exception_ptr | An opaque pointer to an arbitrary exception.
|
| std::__has_iterator_category_helper | Traits class for iterators |
| 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::forward_list | Class std::forward_list 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::_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::_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::_Hashtable | |
| 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::_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_const | Add_const |
| std::add_cv | Add_cv |
| std::add_lvalue_reference | Add_lvalue_reference |
| std::add_pointer | Add_pointer |
| std::add_rvalue_reference | Add_rvalue_reference |
| std::add_volatile | Add_volatile |
| std::adopt_lock_t | Assume the calling thread has already obtained mutex ownership and manage it |
| std::aligned_storage | Alignment type |
| std::alignment_of | Alignment_of |
| std::allocator | The standard allocator, as per [20.4] |
| std::allocator | Allocator<void> specialization |
| std::allocator_arg_t | [allocator.tag] |
| std::allocator_traits | Uniform interface to all allocator types |
| std::array | A standard container for storing a fixed size sequence of elements |
| 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 wchar_t |
| std::atomic_bool | Atomic_bool |
| std::atomic_flag | Atomic_flag |
| 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::bad_weak_ptr | Exception possibly thrown by shared_ptr.
|
| 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 | Template class basic_iostreamThis class multiply inherits from the input and output stream classes simply to provide a single interface |
| std::basic_istream | Template class basic_istream.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 | Template class basic_ostream.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_regex | |
| 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::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::complex | 26.2.3 complex specializations complex<double> specialization |
| std::complex | 26.2.3 complex specializations complex<float> specialization |
| std::complex | 26.2.3 complex specializations complex<long double> specialization |
| std::condition_variable | Condition_variable |
| std::condition_variable_any | Condition_variable_any |
| std::conditional | Define a member typedef type to one of two argument types |
| 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 | Define a member typedef type only if a boolean constant is true |
| 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::extent | Extent |
| 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_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_trivial_copy_assign | Has_trivial_copy_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::has_virtual_destructor | Has_virtual_destructor |
| std::hash | Primary class template hash |
| std::hash | Std::hash specialization for bitset |
| std::hash | Std::hash specialization for vector<bool> |
| std::hash | Std::hash specialization for __u16vstring |
| std::hash | Std::hash specialization for __u32vstring |
| std::hash | Std::hash specialization for __vstring |
| std::hash | Std::hash specialization for __wvstring |
| 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 | Std::hash specialization for __shared_ptr |
| std::hash | Partial specializations for pointer types |
| std::hash | Explicit specialization for bool |
| std::hash | Explicit specialization for char |
| std::hash | Explicit specialization for char16_t |
| std::hash | Explicit specialization for char32_t |
| std::hash | Specialization for double |
| std::hash | Std::hash specialization for error_code |
| std::hash | Specialization for float |
| std::hash | Explicit specialization for int |
| std::hash | Explicit specialization for long |
| std::hash | Specialization for long double |
| std::hash | Explicit specialization for long long |
| std::hash | Std::hash specialization for shared_ptr |
| std::hash | Explicit specialization for short |
| std::hash | Explicit specialization for signed char |
| std::hash | Std::hash specialization for string |
| std::hash | Std::hash specialization for thread::id |
| std::hash | Std::hash specialization for type_index |
| std::hash | Std::hash specialization for u16string |
| std::hash | Std::hash specialization for u32string |
| std::hash | Std::hash specialization for unique_ptr |
| std::hash | Explicit specialization for unsigned char |
| std::hash | Explicit specialization for unsigned int |
| std::hash | Explicit specialization for unsigned long |
| std::hash | Explicit specialization for unsigned long long |
| std::hash | Explicit specialization for unsigned short |
| std::hash | Explicit specialization for wchar_t |
| 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::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::integral_constant | Integral_constant |
| 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_abstract | Is_abstract |
| std::is_arithmetic | Is_arithmetic |
| std::is_array | Is_array |
| std::is_assignable | Is_assignable |
| 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_result is always a bind expression.
|
| std::is_bind_expression | Class template _Bind is always a bind expression.
|
| std::is_bind_expression | Class template _Bind_result is always a bind expression.
|
| std::is_bind_expression | Class template _Bind is always a bind expression.
|
| std::is_bind_expression | Class template _Bind_result is always a bind expression.
|
| std::is_bind_expression | Class template _Bind is always a bind expression.
|
| std::is_bind_expression | Class template _Bind_result is always a bind expression.
|
| std::is_class | Is_class |
| std::is_compound | Is_compound |
| std::is_const | Is_const |
| std::is_constructible | Is_constructible |
| std::is_convertible | Is_convertible |
| std::is_copy_assignable | Is_copy_assignable |
| std::is_copy_constructible | Is_copy_constructible |
| std::is_default_constructible | Is_default_constructible |
| std::is_destructible | Is_destructible |
| std::is_empty | Is_empty |
| std::is_enum | Is_enum |
| std::is_error_code_enum | Is_error_code_enum |
| std::is_error_code_enum | Specialization |
| std::is_error_condition_enum | Is_error_condition_enum |
| std::is_explicitly_convertible | Is_explicitly_convertible |
| std::is_floating_point | Is_floating_point |
| std::is_function | Is_function |
| std::is_fundamental | Is_fundamental |
| std::is_integral | Is_integral |
| std::is_literal_type | Is_literal_type |
| std::is_lvalue_reference | Is_lvalue_reference |
| std::is_member_function_pointer | Is_member_function_pointer |
| std::is_member_object_pointer | Is_member_object_pointer |
| std::is_member_pointer | Is_member_pointer |
| std::is_move_assignable | Is_move_assignable |
| std::is_move_constructible | Is_move_constructible |
| std::is_nothrow_assignable | Is_nothrow_assignable |
| std::is_nothrow_constructible | Is_nothrow_constructible |
| std::is_nothrow_copy_assignable | Is_nothrow_copy_assignable |
| std::is_nothrow_copy_constructible | Is_nothrow_copy_constructible |
| std::is_nothrow_default_constructible | Is_nothrow_default_constructible |
| std::is_nothrow_move_assignable | Is_nothrow_move_assignable |
| std::is_nothrow_move_constructible | Is_nothrow_move_constructible |
| std::is_object | Is_object |
| 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_pointer | Is_pointer |
| std::is_polymorphic | Is_polymorphic |
| std::is_reference | Is_reference |
| std::is_rvalue_reference | Is_rvalue_reference |
| std::is_same | Is_same |
| std::is_scalar | Is_scalar |
| std::is_signed | Is_signed |
| std::is_standard_layout | Is_standard_layout |
| std::is_trivial | Is_trivial |
| std::is_union | Is_union |
| std::is_unsigned | Is_unsigned |
| std::is_void | Is_void |
| std::is_volatile | Is_volatile |
| 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 | 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::match_results | The results of a match or search operation |
| 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::mersenne_twister_engine | |
| 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::pair | Struct holding two objects of arbitrary type |
| std::piecewise_constant_distribution | A piecewise_constant_distribution random number distribution |
| std::piecewise_constant_distribution::param_type | |
| std::piecewise_construct_t | Piecewise_construct_t |
| 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::pointer_traits | Uniform interface to all pointer-like types |
| std::pointer_traits | Partial specialization for built-in 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::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::rank | Rank |
| std::ratio | Provides compile-time rational arithmetic |
| std::ratio_divide | Ratio_divide |
| std::ratio_equal | Ratio_equal |
| std::ratio_multiply | Ratio_multiply |
| std::ratio_not_equal | Ratio_not_equal |
| std::raw_storage_iterator | |
| std::recursive_mutex | Recursive_mutex |
| std::reference_wrapper | Primary class template for reference_wrapper. |
| std::regex_error | A regular expression exception class.The regular expression library throws objects of this class on error |
| std::regex_iterator | |
| std::regex_token_iterator | |
| std::regex_traits | Describes aspects of a regular expression |
| std::remove_all_extents | Remove_all_extents |
| std::remove_const | Remove_const |
| std::remove_cv | Remove_cv |
| std::remove_extent | Remove_extent |
| std::remove_pointer | Remove_pointer |
| std::remove_reference | Remove_reference |
| std::remove_volatile | Remove_volatile |
| std::reverse_iterator | |
| std::runtime_error | One of two subclasses of exception |
| std::scoped_allocator_adaptor | Primary class template |
| 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_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::sub_match | |
| 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::tr2::__dynamic_bitset_base | |
| std::tr2::__reflection_typelist< _First, _Rest...> | Partial specialization |
| std::tr2::__reflection_typelist<> | Specialization for an empty typelist |
| std::tr2::bases | Sequence abstraction metafunctions for manipulating a typelist |
| std::tr2::bool_set | |
| std::tr2::direct_bases | Enumerate all the direct base classes of a class. Form of a typelist |
| std::tr2::dynamic_bitset | The dynamic_bitset class represents a sequence of bits |
| std::tr2::dynamic_bitset::reference | |
| std::try_to_lock_t | Try to acquire ownership of the mutex without blocking |
| std::tuple | Primary class template, tuple |
| std::tuple | Partial specialization, 2-element tuple. Includes construction and assignment from a pair |
| std::tuple_element | |
| std::tuple_element | |
| std::tuple_size | Class tuple_size |
| std::type_index | The 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_info | Part of RTTI |
| std::unary_function | |
| std::unary_negate | One of the negation functors |
| std::underflow_error | |
| std::underlying_type | The underlying type of an enum |
| std::uniform_int_distribution | Uniform discrete distribution for random numbers. A discrete random distribution on the range ![$[min, max]$](form_5.png) 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::uses_allocator | [allocator.uses.trait] |
| std::uses_allocator | Partial specialization for tuples |
| 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 |
