libstdc++: Class List

libstdc++

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123456]

N__cxxabiv1 |
C __forced_unwind | Thrown as part of forced unwinding
N __gnu_cxx | GNU extensions for public use
N __detail | Implementation details not part of the namespace __gnu_cxx interface
C __mini_vector | __mini_vector<> is a stripped down version of the full-fledged std::vector<>
C _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
C _Ffit_finder | The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
C __alloc_traits | Uniform interface to C++98 and C++11 allocators
C __common_pool_policy | Policy for shared __pool objects
C __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)
C __mt_alloc_base | Base class for _Tp dependent member functions
C __per_type_pool_policy | Policy for individual __pool objects
C __pool | Data describing the underlying memory pool, parameterized on threading support
C __pool< false > | Specialization for single thread
C __pool< true > | Specialization for thread enabled, via gthreads.h
C __pool_alloc | Allocator using a memory pool with a single lock
C __pool_alloc_base | Base class for __pool_alloc
C __pool_base | Base class for pool object
C __rc_string_base |
C __scoped_lock | Scoped lock idiom
C __versa_string | Template class __versa_string
C _Caster |
C _Char_types | Mapping from character type to associated types
C _ExtPtr_allocator | An example allocator which uses a non-standard pointer type
C _Invalid_type |
C _Pointer_adapter |
C _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
C _Relative_pointer_impl< const _Tp > |
C _Std_pointer_impl | A storage policy for use with _Pointer_adapter<> which yields a standard pointer
C _Temporary_buffer |
C _Unqualified_type |
C allocator | The standard allocator, as per C++03 [20.4.1]
C 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
C binary_compose | An SGI extension
C bitmap_allocator | Bitmap Allocator, primary template
C char_traits | Base class used to implement std::char_traits
C character | A POD class that serves as a character abstraction class
C condition_base | Base struct for condition policy
C constant_binary_fun | An SGI extension
C constant_unary_fun | An SGI extension
C constant_void_fun | An SGI extension
C debug_allocator | A meta-allocator with debugging bits
C enc_filebuf | Class enc_filebuf
C encoding_char_traits | Encoding_char_traits
C encoding_state | Extension to use iconv for dealing with character encodings
C equal_to | One of the comparison functors
C forced_error | Thrown by utilities for testing exception safety
C free_list | The free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
C hash_map |
C hash_multimap |
C hash_multiset |
C hash_set |
C limit_condition | Base class for incremental control and throw
C always_adjustor | Always enter the condition
C limit_adjustor | Enter the nth condition
C never_adjustor | Never enter the condition
C malloc_allocator | An allocator that uses malloc
C new_allocator | An allocator that uses global new, as per C++03 [20.4.1]
C pair | Struct holding two objects (or references) of arbitrary type
C project1st | An SGI extension
C project2nd | An SGI extension
C random_condition | Base class for random probability control and throw
C always_adjustor | Always enter the condition
C group_adjustor | Group condition
C never_adjustor | Never enter the condition
C rb_tree |
C recursive_init_error | Exception thrown by __cxa_guard_acquire
C rope |
C select1st | An SGI extension
C select2nd | An SGI extension
C slist |
C stdio_filebuf | Provides a layer of compatibility for C/POSIX
C stdio_sync_filebuf | Provides a layer of compatibility for C
C subtractive_rng |
C temporary_buffer |
C throw_allocator_base | Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code
C throw_allocator_limit | Allocator throwing via limit condition
C throw_allocator_random | Allocator throwing via random condition
C throw_value_base | Class with exception generation control. Intended to be used as a value_type in templatized code
C throw_value_limit | Type throwing via limit condition
C throw_value_random | Type throwing via random condition
C unary_compose | An SGI extension
N __gnu_debug | GNU debug classes for public use
C _After_nth_from |
C _BeforeBeginHelper |
C _Equal_to |
C _Not_equal_to |
C _Safe_container | Safe class dealing with some allocator dependent operations
C _Safe_forward_list | Special iterators swap and invalidation for forward_list because of the before_begin iterator
C _Safe_iterator | Safe iterator wrapper
C _Safe_iterator_base | Basic functionality for a safe iterator
C _Safe_local_iterator | Safe iterator wrapper
C _Safe_local_iterator_base | Basic functionality for a safe iterator
C _Safe_node_sequence | Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence
C _Safe_sequence | Base class for constructing a safe sequence type that tracks iterators that reference it
C _Safe_sequence_base | Base class that supports tracking of iterators that reference a sequence
C _Safe_unordered_container | Base class for constructing a safe unordered container type that tracks iterators that reference it
C _Safe_unordered_container_base | Base class that supports tracking of local iterators that reference an unordered container
C _Safe_vector | Base class for Debug Mode vector
C _Sequence_traits |
C basic_string | Class std::basic_string with safety/checking/debug instrumentation
C type_info | Part of RTTI
N __gnu_parallel | GNU parallel code for public use
C __accumulate_binop_reduct | General reduction, using a binary operator
C __accumulate_selector | Std::accumulate() selector
C __adjacent_difference_selector | Selector that returns the difference between two adjacent __elements
C __adjacent_find_selector | Test predicate on two adjacent elements
C __binder1st | Similar to std::binder1st, but giving the argument types explicitly
C __binder2nd | Similar to std::binder2nd, but giving the argument types explicitly
C __count_if_selector | Std::count_if () selector
C __count_selector | Std::count() selector
C __fill_selector | Std::fill() selector
C __find_first_of_selector | Test predicate on several elements
C __find_if_selector | Test predicate on a single element, used for std::find() and std::find_if ()
C __for_each_selector | Std::for_each() selector
C __generate_selector | Std::generate() selector
C __generic_find_selector | Base class of all __gnu_parallel::__find_template selectors
C __generic_for_each_selector | Generic __selector for embarrassingly parallel functions
C __identity_selector | Selector that just returns the passed iterator
C __inner_product_selector | Std::inner_product() selector
C __max_element_reduct | Reduction for finding the maximum element, using a comparator
C __min_element_reduct | Reduction for finding the maximum element, using a comparator
C __mismatch_selector | Test inverted predicate on a single element
C __multiway_merge_3_variant_sentinel_switch | Switch for 3-way merging with __sentinels turned off
C __multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 3-way merging with __sentinels turned on
C __multiway_merge_4_variant_sentinel_switch | Switch for 4-way merging with __sentinels turned off
C __multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for 4-way merging with __sentinels turned on
C __multiway_merge_k_variant_sentinel_switch | Switch for k-way merging with __sentinels turned on
C __multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > | Switch for k-way merging with __sentinels turned off
C __replace_if_selector | Std::replace() selector
C __replace_selector | Std::replace() selector
C __transform1_selector | Std::transform() __selector, one input sequence variant
C __transform2_selector | Std::transform() __selector, two input sequences variant
C __unary_negate | Similar to std::unary_negate, but giving the argument types explicitly
C _DRandomShufflingGlobalData | Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
C _DRSSorterPU | Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
C _DummyReduct | Reduction function doing nothing
C _EqualFromLess | Constructs predicate for equality from strict weak ordering predicate
C _EqualTo | Similar to std::equal_to, but allows two different types
C _GuardedIterator | _Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
C _IteratorPair | A pair of iterators. The usual iterator operations are applied to both child iterators
C _IteratorTriple | A triple of iterators. The usual iterator operations are applied to all three child iterators
C _Job | One __job for a certain thread
C _Less | Similar to std::less, but allows two different types
C _Lexicographic | Compare __a pair of types lexicographically, ascending
C _LexicographicReverse | Compare __a pair of types lexicographically, descending
C _LoserTree | Stable _LoserTree variant
C _LoserTree< false, _Tp, _Compare > | Unstable _LoserTree variant
C _LoserTreeBase | Guarded loser/tournament tree
C _Loser | Internal representation of a _LoserTree element
C _LoserTreePointer | Stable _LoserTree implementation
C _LoserTreePointer< false, _Tp, _Compare > | Unstable _LoserTree implementation
C _LoserTreePointerBase | Base class of _Loser Tree implementation using pointers
C _Loser | Internal representation of _LoserTree __elements
C _LoserTreePointerUnguarded | Stable unguarded _LoserTree variant storing pointers
C _LoserTreePointerUnguarded< false, _Tp, _Compare > | Unstable unguarded _LoserTree variant storing pointers
C _LoserTreePointerUnguardedBase | Unguarded loser tree, keeping only pointers to the elements in the tree structure
C _LoserTreeTraits | Traits for determining whether the loser tree should use pointers or copies
C _LoserTreeUnguarded | Stable implementation of unguarded _LoserTree
C _LoserTreeUnguarded< false, _Tp, _Compare > | Non-Stable implementation of unguarded _LoserTree
C _LoserTreeUnguardedBase | Base class for unguarded _LoserTree implementation
C _Multiplies | Similar to std::multiplies, but allows two different types
C _Nothing | Functor doing nothing
C _Piece | Subsequence description
C _Plus | Similar to std::plus, but allows two different types
C _PMWMSSortingData | Data accessed by all threads
C _PseudoSequence | Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
C _PseudoSequenceIterator | _Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
C _QSBThreadLocal | Information local to one thread in the parallel quicksort run
C _RandomNumber | Random number generator, based on the Mersenne twister
C _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
C _SamplingSorter | Stable sorting functor
C _SamplingSorter< false, _RAIter, _StrictWeakOrdering > | Non-__stable sorting functor
C _Settings | Class _Settings Run-time settings for the parallel mode including all tunable parameters
C _SplitConsistently | Split consistently
C _SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator > | Split by sampling
C _SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator > | Split by exact splitting
C balanced_quicksort_tag | Forces parallel sorting using balanced quicksort at compile time
C balanced_tag | Recommends parallel execution using dynamic load-balancing at compile time
C constant_size_blocks_tag | Selects the constant block size variant for std::find()
C default_parallel_tag | Recommends parallel execution using the default parallel algorithm
C equal_split_tag | Selects the equal splitting variant for std::find()
C exact_tag | Forces parallel merging with exact splitting, at compile time
C find_tag | Base class for for std::find() variants
C growing_blocks_tag | Selects the growing block size variant for std::find()
C multiway_mergesort_exact_tag | Forces parallel sorting using multiway mergesort with exact splitting at compile time
C multiway_mergesort_sampling_tag | Forces parallel sorting using multiway mergesort with splitting by sampling at compile time
C multiway_mergesort_tag | Forces parallel sorting using multiway mergesort at compile time
C omp_loop_static_tag | Recommends parallel execution using OpenMP static load-balancing at compile time
C omp_loop_tag | Recommends parallel execution using OpenMP dynamic load-balancing at compile time
C parallel_tag | Recommends parallel execution at compile time, optionally using a user-specified number of threads
C quicksort_tag | Forces parallel sorting using unbalanced quicksort at compile time
C sampling_tag | Forces parallel merging with exact splitting, at compile time
C sequential_tag | Forces sequential execution at compile time
C unbalanced_tag | Recommends parallel execution using static load-balancing at compile time
N __gnu_pbds | GNU extensions for policy-based data structures for public use
Ndetail |
C bin_search_tree_const_it_ | Const iterator
C bin_search_tree_const_node_it_ | Const node iterator
C bin_search_tree_it_ | Iterator
C bin_search_tree_node_it_ | Node iterator
C bin_search_tree_traits | Binary search tree traits, primary template
C bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc > | Specialization
C binary_heap |
C binary_heap_const_iterator_ | Const point-type iterator
C binary_heap_point_const_iterator_ | Const point-type iterator
C binomial_heap |
C binomial_heap_base | Base class for binomial heap
C branch_policy | Primary template, base class for branch structure policies
C branch_policy< Node_CItr, Node_CItr, _Alloc > | Specialization for const iterators
C cc_ht_map |
C cond_dealtor | Conditional deallocate constructor argument
C container_base_dispatch | Dispatch mechanism, primary template for associative types
C container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type > | Specialization for binary_heap
C container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type > | Specialization for binomial_heap
C container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type > | Specialization for pairing_heap
C container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type > | Specialization for rc_binary_heap
C container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type > | Specialization for thin_heap
C container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl > | Specialization collision-chaining hash map
C container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash map
C container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update map
C container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree map
C container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie map
C container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree map
C container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree map
C container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl > | Specialization collision-chaining hash set
C container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl > | Specialization general-probe hash set
C container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl > | Specialization for list-update set
C container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl > | Specialization ordered-vector tree set
C container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl > | Specialization for PATRICIA trie set
C container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl > | Specialization for R-B tree set
C container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl > | Specialization splay tree set
C default_comb_hash_fn | Primary template, default_comb_hash_fn
C default_eq_fn | Primary template, default_eq_fn
C default_hash_fn | Primary template, default_hash_fn
C default_probe_fn | Primary template, default_probe_fn
C default_resize_policy | Primary template, default_resize_policy
C default_trie_access_traits | Primary template, default_trie_access_traits
C default_trie_access_traits< std::basic_string | Partial specialization, default_trie_access_traits
C default_update_policy | Default update policy
C dumnode_const_iterator | Constant node iterator
C entry_cmp | Entry compare, primary template
C entry_cmp< _VTp, Cmp_Fn, _Alloc, false > | Specialization, false
C type | Compare plus entry
C entry_cmp< _VTp, Cmp_Fn, _Alloc, true > | Specialization, true
C entry_pred | Entry predicate primary class template
C entry_pred< _VTp, Pred, _Alloc, false > | Specialization, false
C entry_pred< _VTp, Pred, _Alloc, true > | Specialization, true
C eq_by_less | Equivalence function
C gp_ht_map |
C hash_eq_fn | Primary template
C hash_eq_fn< Key, Eq_Fn, _Alloc, false > | Specialization 1 - The client requests that hash values not be stored
C hash_eq_fn< Key, Eq_Fn, _Alloc, true > | Specialization 2 - The client requests that hash values be stored
C hash_load_check_resize_trigger_size_base | Primary template
C hash_load_check_resize_trigger_size_base< Size_Type, true > | Specializations
C left_child_next_sibling_heap | Base class for a basic heap
C left_child_next_sibling_heap_const_iterator_ | Const point-type iterator
C left_child_next_sibling_heap_node_ | Node
C left_child_next_sibling_heap_node_point_const_iterator_ | Const point-type iterator
C lu_counter_metadata | A list-update metadata type that moves elements to the front of the list based on the counter algorithm
C lu_counter_policy_base | Base class for list-update counter policy
C lu_map | List-based (with updates) associative container. Skip to the lu, my darling
C mask_based_range_hashing | Range hashing policy
C maybe_null_type | Base class for conditionally defining a static data member
C maybe_null_type< Key, null_type, _Alloc, Store_Hash > | Specialization that defines a static data member of type null_type
C mod_based_range_hashing | Mod based range hashing
C no_throw_copies | Primary template
C no_throw_copies< Key, null_type > | Specialization
C ov_tree_map | Ordered-vector tree associative-container
C cond_dtor | Conditional destructor
C ov_tree_node_const_it_ | Const node reference
C ov_tree_node_it_ | Node reference
C pairing_heap |
C pat_trie_base | Base type for PATRICIA trees
C _CIter | Const iterator
C _Head | Head node for PATRICIA tree
C _Inode | Internal node type, PATRICIA tree
C const_iterator | Constant child iterator
C iterator | Child iterator
C _Iter | Iterator
C _Leaf | Leaf node for PATRICIA tree
C _Metadata | Metadata base primary template
C _Metadata< null_type, _Alloc > | Specialization for null metadata
C _Node_base | Node base
C _Node_citer | Node const iterator
C _Node_iter | Node iterator
C pat_trie_map | PATRICIA trie
C probe_fn_base | Probe functor base
C ranged_hash_fn | Primary template
C ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false > |
C ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true > |
C ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false > |
C ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true > |
C ranged_probe_fn | Primary template
C ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false > |
C ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true > |
C ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false > |
C rb_tree_map | Red-Black tree
C rb_tree_node_ | Node for Red-Black trees
C rc | Redundant binary counter
C rc_binomial_heap |
C rebind_traits | Consistent API for accessing allocator-related types
C resize_policy | Resize policy for binary heap
C select_value_type | Choose value_type to be a key/value pair or just a key
C select_value_type< Key, null_type > | Specialization for sets where the key is the value_type
C splay_tree_map | Splay tree
C splay_tree_node_ | Node for splay tree
C stored_data | Primary template for representation of stored data. Two types of data can be stored: value and hash
C stored_data< _Tv, _Th, false > | Specialization for representation of stored data of just value type
C stored_hash | Stored hash
C stored_value | Stored value
C synth_access_traits | Synthetic element access traits
C thin_heap |
C tree_metadata_helper | Tree metadata helper
C tree_metadata_helper< Node_Update, false > | Specialization, false
C tree_metadata_helper< Node_Update, true > | Specialization, true
C tree_node_metadata_dispatch | Tree node metadata dispatch
C tree_traits | Tree traits class, primary template
C tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Tree traits
C tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization
C tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization
C tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > | Specialization
C tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > | Specialization
C tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > | Specialization
C trie_metadata_helper | Trie metadata helper
C trie_metadata_helper< Node_Update, false > | Specialization, false
C trie_metadata_helper< Node_Update, true > | Specialization, true
C trie_node_metadata_dispatch | Trie node metadata dispatch
C trie_policy_base | Base class for trie policies
C trie_traits | Trie traits class, primary template
C trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization
C trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc > | Specialization
C types_traits | Traits for abstract types
C associative_tag | Basic associative-container
C basic_branch |
C basic_branch_tag | Basic branch structure
C basic_hash_table |
C basic_hash_tag | Basic hash structure
C basic_invalidation_guarantee |
C binary_heap_tag | Binary-heap (array-based)
C binomial_heap_tag | Binomial-heap
C 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
C cc_hash_table |
C cc_hash_tag | Collision-chaining hash
C container_error | Base class for exceptions
C container_tag | Base data structure tag
C container_traits | Container traits
C container_traits_base | Primary template, container traits base
C container_traits_base< binary_heap_tag > | Specialization, binary heap
C container_traits_base< binomial_heap_tag > | Specialization, binomial heap
C container_traits_base< cc_hash_tag > | Specialization, cc hash
C container_traits_base< gp_hash_tag > | Specialization, gp hash
C container_traits_base< list_update_tag > | Specialization, list update
C container_traits_base< ov_tree_tag > | Specialization, ov tree
C container_traits_base< pairing_heap_tag > | Specialization, pairing heap
C container_traits_base< pat_trie_tag > | Specialization, pat trie
C container_traits_base< rb_tree_tag > | Specialization, rb tree
C container_traits_base< rc_binomial_heap_tag > | Specialization, rc binomial heap
C container_traits_base< splay_tree_tag > | Specialization, splay tree
C container_traits_base< thin_heap_tag > | Specialization, thin heap
C direct_mask_range_hashing | A mask range-hashing class (uses a bitmask)
C direct_mod_range_hashing | A mod range-hashing class (uses the modulo function)
C gp_hash_table |
C gp_hash_tag | General-probing hash
C hash_exponential_size_policy | A size policy whose sequence of sizes form an exponential sequence (typically powers of 2
C 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
C hash_prime_size_policy | A size policy whose sequence of sizes form a nearly-exponential sequence of primes
C hash_standard_resize_policy | A resize policy which delegates operations to size and trigger policies
C 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)
C join_error | A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps
C linear_probe_fn | A probe sequence policy using fixed increments
C list_update |
C list_update_tag | List-update
C lu_counter_policy |
C lu_move_to_front_policy |
C null_node_update | A null node updator, indicating that no node updates are required
C null_type | Represents no type, or absence of type, for template tricks
C ov_tree_tag | Ordered-vector tree
C pairing_heap_tag | Pairing-heap
C pat_trie_tag | PATRICIA trie
C point_invalidation_guarantee |
C priority_queue |
C priority_queue_tag | Basic priority-queue
C quadratic_probe_fn | A probe sequence policy using square increments
C range_invalidation_guarantee |
C rb_tree_tag | Red-black tree
C rc_binomial_heap_tag | Redundant-counter binomial-heap
C resize_error | A container cannot be resized
C sample_probe_fn | A sample probe policy
C sample_range_hashing | A sample range-hashing functor
C sample_ranged_hash_fn | A sample ranged-hash functor
C sample_ranged_probe_fn | A sample ranged-probe functor
C sample_resize_policy | A sample resize policy
C sample_resize_trigger | A sample resize trigger policy
C sample_size_policy | A sample size policy
C sample_tree_node_update | A sample node updator
C sample_trie_access_traits | A sample trie element access traits
C sample_trie_node_update | A sample node updator
C sample_update_policy | A sample list-update policy
C sequence_tag | Basic sequence
C splay_tree_tag | Splay tree
C string_tag | Basic string container, inclusive of strings, ropes, etc
C thin_heap_tag | Thin heap
C tree |
C tree_order_statistics_node_update | Functor updating ranks of entrees
C tree_tag | Basic tree structure
C trie |
C trie_order_statistics_node_update | Functor updating ranks of entrees
C trie_prefix_search_node_update | A node updator that allows tries to be searched for the range of values that match a certain prefix
C trie_string_access_traits |
C trie_tag | Basic trie structure
C trivial_iterator_tag | A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
Nparallelism_v2 |
Nsimd_abi |
C deduce |
N std | ISO C++ entities toplevel namespace is std
N__cxx11 |
C collate | Facet for localized string comparison
C collate_byname | Class collate_byname [22.2.4.2]
N __debug | GNU debug code, replaces standard behavior with debug behavior
C bitset | Class std::bitset with additional safety/checking/debug instrumentation
C deque | Class std::deque with safety/checking/debug instrumentation
C forward_list | Class std::forward_list with safety/checking/debug instrumentation
C list | Class std::list with safety/checking/debug instrumentation
C map | Class std::map with safety/checking/debug instrumentation
C multimap | Class std::multimap with safety/checking/debug instrumentation
C multiset | Class std::multiset with safety/checking/debug instrumentation
C set | Class std::set with safety/checking/debug instrumentation
C unordered_map | Class std::unordered_map with safety/checking/debug instrumentation
C unordered_multimap | Class std::unordered_multimap with safety/checking/debug instrumentation
C unordered_multiset | Class std::unordered_multiset with safety/checking/debug instrumentation
C unordered_set | Class std::unordered_set with safety/checking/debug instrumentation
C vector | Class std::vector with safety/checking/debug instrumentation
N __detail | Implementation details not part of the namespace std interface
C _BracketMatcher | Matches a character range (bracket expression)
C _Compiler | Builds an NFA from an input iterator range
C _Executor | Takes a regex and an input string and does the matching
C _List_node_base | Common part of a node in the list
C _List_node_header | The list node header
C _Quoted_string | Struct for delimited strings
C _Scanner | Scans an input range for regex tokens
C _StateSeq | Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction
N__fwdlist |
C _Iterator | A forward_list iterator when the allocator uses fancy pointers
C _Node | A helper node class for forward_list
C _Node_base | The node-base type for allocators that use fancy pointers
N __parallel | GNU parallel code, replaces standard behavior with parallel behavior
C _CRandNumber | Functor wrapper for std::rand()
N__unspecified__ |
C exception_ptr | An opaque pointer to an arbitrary exception
N chrono | ISO C++ 2011 namespace for date and time utilities
C duration | chrono::duration represents a distance between two points in time
C duration_values | Duration_values
C gps_clock |
C hh_mm_ss |
C steady_clock | Monotonic clock
C system_clock | System clock
C tai_clock |
C time_point | chrono::time_point represents a point in time as measured by a clock
C treat_as_floating_point |
C tzdb_list |
C const_iterator |
C utc_clock |
N decimal | ISO/IEC TR 24733 Decimal floating-point arithmetic
C decimal128 | 3.2.4 Class decimal128
C decimal32 | 3.2.2 Class decimal32
C decimal64 | 3.2.3 Class decimal64
N experimental | Namespace for features defined in ISO Technical Specifications
Nfilesystem |
Nv1 |
C basic_string_view | A non-owning reference to a string
C filesystem_error | Exception type thrown by the Filesystem TS library
C path | A filesystem path
C iterator | An iterator for the components of a path
C space_info | Information about free space on a disk
C filesystem_error | Exception type thrown by the Filesystem TS library
C path | A filesystem path
C iterator | An iterator for the components of a path
C space_info | Information about free space on a disk
Nfundamentals_v1 |
C any | A type-safe container of any type
C bad_any_cast | Exception class thrown by a failed `any_cast`
C bad_optional_access | Exception class thrown when a disengaged optional object is dereferenced
C basic_string_view | A non-owning reference to a string
C in_place_t | Tag type for in-place construction
C nullopt_t | Tag type to disengage optional objects
C optional | Class template for optional values
Nfundamentals_v2 |
C ostream_joiner | Output iterator that inserts a delimiter between elements
C owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr
C owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr
C propagate_const | Const-propagating wrapper
C any | A type-safe container of any type
C bad_any_cast | Exception class thrown by a failed `any_cast`
C bad_optional_access | Exception class thrown when a disengaged optional object is dereferenced
C basic_string_view | A non-owning reference to a string
C in_place_t | Tag type for in-place construction
C nullopt_t | Tag type to disengage optional objects
C optional | Class template for optional values
C ostream_joiner | Output iterator that inserts a delimiter between elements
C owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr
C owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr
C propagate_const | Const-propagating wrapper
N filesystem | ISO C++ 2017 namespace for File System library
C directory_entry | The value type used by directory iterators
C directory_iterator | Iterator type for traversing the entries in a single directory
C file_status | Information about a file's type and permissions
C filesystem_error | Exception type thrown by the Filesystem library
C path | A filesystem path
C iterator | An iterator for the components of a path
C recursive_directory_iterator | Iterator type for recursively traversing a directory hierarchy
C space_info | Information about free space on a disk
Npmr |
C memory_resource | Class memory_resource
C monotonic_buffer_resource | A memory resource that allocates from a fixed-size buffer
C polymorphic_allocator | Class template polymorphic_allocator
C pool_options | Parameters for tuning a pool resource's behaviour
C unsynchronized_pool_resource | A non-thread-safe memory resource that manages pools of fixed-size blocks
Nranges |
C dangling | Type returned by algorithms instead of a dangling iterator or subrange
C elements_of |
C empty_view | A view that contains no elements
C equal_to | Ranges::equal_to function object type
C greater | Ranges::greater function object type
C greater_equal | Ranges::greater_equal function object type
C less | Ranges::less function object type
C less_equal | Ranges::less_equal function object type
C not_equal_to | Ranges::not_equal_to function object type
C single_view | A view that contains exactly one element
C subrange | The ranges::subrange class template
C view_base | [range.view] The ranges::view_base type
C view_interface | The ranges::view_interface class template
Nsimd |
C rebind< _Tp, _Mp, _Traits > |
C rebind< _Tp, _Vp, _Traits > |
N tr2 | Namespace for non-standard "TR2" extensions
C __dynamic_bitset_base |
C __reflection_typelist |
C __reflection_typelist< _First, _Rest... > | Partial specialization
C __reflection_typelist<> | Specialization for an empty typelist
C bases | Sequence abstraction metafunctions for manipulating a typelist
C bool_set |
C direct_bases | Enumerate all the direct base classes of a class. Form of a typelist
C dynamic_bitset | The dynamic_bitset class represents a sequence of bits
C reference |
C __basic_future | Common implementation for future and shared_future
C __codecvt_abstract_base | Common base for codecvt functions
C __ctype_abstract_base | Common base for ctype facet
C __is_fast_hash |
C __is_location_invariant |
C __new_allocator | An allocator that uses global new, as per C++03 [20.4.1]
C __numeric_limits_base | Part of std::numeric_limits
C _Base_bitset |
C _Base_bitset< 0 > |
C _Base_bitset< 1 > |
C _Bind | Type of the function object returned from bind()
C _Bind_result | Type of the function object returned from bind<R>()
C _Deque_base |
C _Deque_iterator | A deque::iterator
C _Function_base | Base class of all polymorphic function object wrappers
C _Fwd_list_base | Base class for forward_list
C _Fwd_list_const_iterator | A forward_list::const_iterator
C _Fwd_list_iterator | A forward_list::iterator
C _Fwd_list_node | A helper node class for forward_list. This is just a linked list with uninitialized storage for a data value in each node. There is a sorting utility method
C _Fwd_list_node_base | A helper basic node class for forward_list
C _List_base | See bits/stl_deque.h's _Deque_base for an explanation
C _List_const_iterator | A list::const_iterator
C _List_iterator | A list::iterator
C _List_node | An actual node in the list
C _Not_fn | Generalized negator
C _Placeholder | The type of placeholder objects defined by libstdc++
C _Sp_ebo_helper< _Tp, false > | Specialization not using [[no_unique_address]]
C _Sp_ebo_helper< _Tp, true > | Specialization using [[no_unique_address]]
C _Temporary_buffer |
C _Vector_base | See bits/stl_deque.h's _Deque_base for an explanation
C add_const | Add_const
C add_cv | Add_cv
C add_lvalue_reference | Add_lvalue_reference
C add_pointer | Add_pointer
C add_rvalue_reference | Add_rvalue_reference
C add_volatile | Add_volatile
C adopt_lock_t | Assume the calling thread has already obtained mutex ownership and manage it
C aligned_storage | Aligned storage
C aligned_union | Provide aligned storage for types
C alignment_of | Alignment_of
C allocator | The standard allocator, as per C++03 [20.4.1]
C allocator< void > |
C allocator_traits | Uniform interface to all allocator types
C allocator_traits< allocator< _Tp > > | Partial specialization for std::allocator
C allocator_traits< allocator< void > > | Explicit specialization for std::allocator<void>
C allocator_traits< pmr::polymorphic_allocator | Partial specialization for std::pmr::polymorphic_allocator
C array | A standard container for storing a fixed size sequence of elements
C atomic | Generic atomic type, primary class template
C atomic< _Tp * > | Partial specialization for pointer types
C atomic< bool > | Atomic<bool>
C atomic< char > | Explicit specialization for char
C atomic< char16_t > | Explicit specialization for char16_t
C atomic< char32_t > | Explicit specialization for char32_t
C atomic< int > | Explicit specialization for int
C atomic< long > | Explicit specialization for long
C atomic< long long > | Explicit specialization for long long
C atomic< short > | Explicit specialization for short
C atomic< signed char > | Explicit specialization for signed char
C atomic< unsigned char > | Explicit specialization for unsigned char
C atomic< unsigned int > | Explicit specialization for unsigned int
C atomic< unsigned long > | Explicit specialization for unsigned long
C atomic< unsigned long long > | Explicit specialization for unsigned long long
C atomic< unsigned short > | Explicit specialization for unsigned short
C atomic< wchar_t > | Explicit specialization for wchar_t
C atomic_flag | Atomic_flag
C auto_ptr | A simple smart pointer providing strict ownership semantics
C auto_ptr_ref |
C back_insert_iterator | Turns assignment into insertion
C bad_alloc | Exception possibly thrown by `new`
C bad_cast | Thrown during incorrect typecasting
C bad_exception |
C bad_function_call | Exception class thrown when class template function's operator() is called with an empty target
C bad_typeid | Thrown when a NULL pointer in a `typeid` expression is used
C bad_weak_ptr | Exception possibly thrown by `shared_ptr`
C basic_filebuf | The actual work of input and output (for files)
C basic_fstream | Controlling input and output for files
C basic_ifstream | Controlling input for files
C basic_ios | Template class basic_ios, virtual base class for all stream classes
C basic_iostream | Template class basic_iostream
C basic_istream | Template class basic_istream
C sentry | Performs setup work for input streams
C basic_istringstream | Controlling input for std::string
C basic_ofstream | Controlling output for files
C basic_ostream | Template class basic_ostream
C sentry | Performs setup work for output streams
C basic_ostringstream | Controlling output for std::string
C basic_regex | A regular expression
C basic_streambuf | The actual work of input and output (interface)
C basic_string | Managing sequences of characters and character-like objects
C basic_string_view | A non-owning reference to a string
C basic_stringbuf | The actual work of input and output (for std::string)
C basic_stringstream | Controlling input and output for std::string
C bernoulli_distribution | A Bernoulli random number distribution
C param_type |
C bidirectional_iterator_tag | Bidirectional iterators support a superset of forward iterator operations
C binary_function |
C binary_negate | One of the negation functors
C binder1st | One of the binder functors
C binder2nd | One of the binder functors
C binomial_distribution | A discrete binomial random number distribution
C param_type |
C bitset | The bitset class represents a fixed-size sequence of bits
C reference |
C cauchy_distribution | A cauchy_distribution random number distribution
C param_type |
C char_traits | Basis for explicit traits specializations
C char_traits< __gnu_cxx::character | Char_traits<__gnu_cxx::character> specialization
C char_traits< char > | 21.1.3.1 char_traits specializations
C char_traits< wchar_t > | 21.1.3.2 char_traits specializations
C chi_squared_distribution | A chi_squared_distribution random number distribution
C param_type |
C codecvt | Primary class template codecvt
C codecvt< _InternT, _ExternT, encoding_state > | Codecvt<InternT, _ExternT, encoding_state> specialization
C codecvt< char, char, mbstate_t > | Class codecvt<char, char, mbstate_t> specialization
C codecvt< char16_t, char, mbstate_t > | Class codecvt<char16_t, char, mbstate_t> specialization
C codecvt< char32_t, char, mbstate_t > | Class codecvt<char32_t, char, mbstate_t> specialization
C codecvt< wchar_t, char, mbstate_t > | Class codecvt<wchar_t, char, mbstate_t> specialization
C codecvt_base | Empty base class for codecvt facet [22.2.1.5]
C codecvt_byname | Class codecvt_byname [22.2.1.6]
C common_iterator | An iterator/sentinel adaptor for representing a non-common range
C common_type | Common_type
C common_type< chrono::duration | Specialization of common_type for one chrono::duration type
C common_type< chrono::duration | Specialization of common_type for two identical chrono::duration types
C common_type< chrono::duration | Specialization of common_type for chrono::duration types
C common_type< chrono::time_point | Specialization of common_type for one chrono::time_point type
C common_type< chrono::time_point | Specialization of common_type for two identical chrono::time_point types
C common_type< chrono::time_point | Specialization of common_type for chrono::time_point types
C compare_three_way_result | [cmp.result], result of three-way comparison
C complex |
C complex< double > | 26.2.3 complex specializations complex<double> specialization
C complex< float > | 26.2.3 complex specializations complex<float> specialization
C complex< long double > | 26.2.3 complex specializations complex<long double> specialization
C condition_variable | Condition_variable
C condition_variable_any | Condition_variable_any
C conditional | Define a member typedef `type` to one of two argument types
C const_mem_fun1_ref_t | One of the adaptors for member pointers
C const_mem_fun1_t | One of the adaptors for member pointers
C const_mem_fun_ref_t | One of the adaptors for member pointers
C const_mem_fun_t | One of the adaptors for member pointers
C contiguous_iterator_tag | Contiguous iterators point to objects stored contiguously in memory
C copyable_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)> | Polymorphic copyable function wrapper
C counted_iterator | An iterator adaptor that keeps track of the distance to the end
C ctype | Primary class template ctype facet
C ctype< char > | The ctype<char> specialization
C ctype< wchar_t > | The ctype<wchar_t> specialization
C ctype_base | Base class for ctype
C ctype_byname | Class ctype_byname [22.2.1.2]
C ctype_byname< char > | 22.2.1.4 Class ctype_byname specializations
C default_delete |
C default_delete< _Tp[]> |
C default_sentinel_t |
C defer_lock_t | Do not acquire ownership of the mutex
C deque | A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
C destroying_delete_t | Tag type used to declare a class-specific operator delete that can invoke the destructor before deallocating the memory
C discard_block_engine |
C discrete_distribution | A discrete_distribution random number distribution
C param_type |
C divides | One of the math functors
C divides< void > | One of the math functors
C domain_error |
C enable_if | Define a member typedef type only if a boolean constant is true
C enable_shared_from_this | Base class allowing use of the member function shared_from_this
C encoding_state | Extension to use iconv for dealing with character encodings
C equal_to | One of the comparison functors
C equal_to< void > | One of the comparison functors
C error_category |
C error_code |
C error_condition |
C exception | Base class for all library exceptions
C exception_ptr | An opaque pointer to an arbitrary exception
C exponential_distribution | An exponential continuous distribution for random numbers
C param_type |
C extent | Extent
C extreme_value_distribution | A extreme_value_distribution random number distribution
C param_type |
C fisher_f_distribution | A fisher_f_distribution random number distribution
C param_type |
C forward_iterator_tag | Forward iterators support a superset of input iterator operations
C forward_list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
C fpos | Class representing stream positions
C from_chars_result | Result type of std::from_chars
C front_insert_iterator | Turns assignment into insertion
C function< _Res(_ArgTypes...)> | Polymorphic function wrapper
C function_ref< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)> | Non-owning polymorphic function wrapper
C future | Primary template for future
C future< _Res & > | Partial specialization for future<R&>
C future< void > | Explicit specialization for future<void>
C future_error | Exception type thrown by futures
C gamma_distribution | A gamma continuous distribution for random numbers
C param_type |
C geometric_distribution | A discrete geometric random number distribution
C param_type |
C greater | One of the comparison functors
C greater< void > | One of the comparison functors
C greater_equal | One of the comparison functors
C greater_equal< void > | One of the comparison functors
C gslice | Class defining multi-dimensional subset of an array
C gslice_array | Reference to multi-dimensional subset of an array
C has_virtual_destructor | Has_virtual_destructor
C hash | Primary class template hash
C hash< __debug::bitset | Std::hash specialization for bitset
C hash< __debug::vector | Std::hash specialization for vector<bool>
C hash< __gnu_cxx::__u16vstring > | Std::hash specialization for __u16vstring
C hash< __gnu_cxx::__u32vstring > | Std::hash specialization for __u32vstring
C hash< __gnu_cxx::__vstring > | Std::hash specialization for __vstring
C hash< __gnu_cxx::__wvstring > | Std::hash specialization for __wvstring
C hash< __gnu_cxx::throw_value_limit > | Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
C hash< __gnu_cxx::throw_value_random > | Explicit specialization of std::hash for __gnu_cxx::throw_value_random
C hash< __gnu_debug::basic_string | Std::hash specialization for __gnu_debug::basic_string
C hash< __shared_ptr< _Tp, _Lp > > | Std::hash specialization for __shared_ptr
C hash< _Tp * > | Partial specializations for pointer types
C hash< basic_string< char, char_traits< char >, _Alloc > > | Std::hash specialization for string
C hash< basic_string< char16_t, char_traits< char16_t >, _Alloc > > | Std::hash specialization for u16string
C hash< basic_string< char32_t, char_traits< char32_t >, _Alloc > > | Std::hash specialization for u32string
C hash< basic_string< wchar_t, char_traits< wchar_t >, _Alloc > > | Std::hash specialization for wstring
C hash< bool > | Explicit specialization for bool
C hash< char > | Explicit specialization for char
C hash< char16_t > | Explicit specialization for char16_t
C hash< char32_t > | Explicit specialization for char32_t
C hash< double > | Specialization for double
C hash< error_code > | Std::hash specialization for error_code
C hash< error_condition > | Std::hash specialization for error_condition
C hash< experimental::optional | Std::hash partial specialization for experimental::optional
C hash< experimental::shared_ptr | Std::hash specialization for shared_ptr
C hash< float > | Specialization for float
C hash< int > | Explicit specialization for int
C hash< long > | Explicit specialization for long
C hash< long double > | Specialization for long double
C hash< long long > | Explicit specialization for long long
C hash< shared_ptr< _Tp > > | Std::hash specialization for shared_ptr
C hash< short > | Explicit specialization for short
C hash< signed char > | Explicit specialization for signed char
C hash< thread::id > | Std::hash specialization for thread::id
C hash< type_index > | Std::hash specialization for type_index
C hash< unique_ptr< _Tp, _Dp > > | Std::hash specialization for unique_ptr
C hash< unsigned char > | Explicit specialization for unsigned char
C hash< unsigned int > | Explicit specialization for unsigned int
C hash< unsigned long > | Explicit specialization for unsigned long
C hash< unsigned long long > | Explicit specialization for unsigned long long
C hash< unsigned short > | Explicit specialization for unsigned short
C hash< wchar_t > | Explicit specialization for wchar_t
C hash<::bitset | Std::hash specialization for bitset
C hash<::vector | Std::hash specialization for vector<bool>
C identity | [func.identity] The identity function
C independent_bits_engine |
C indirect_array | Reference to arbitrary subset of an array
C initializer_list | Initializer_list
C inout_ptr_t | Smart pointer adaptor for functions taking an inout pointer parameter
C input_iterator_tag | Marking input iterators
C insert_iterator | Turns assignment into insertion
C integer_sequence | Class template integer_sequence
C integral_constant | Integral_constant
C invalid_argument |
C ios_base | The base of the I/O class hierarchy
C failure | These are thrown to indicate problems with io
C is_abstract | Is_abstract
C is_arithmetic | Is_arithmetic
C is_array | Is_array
C is_assignable | Is_assignable
C is_base_of | Is_base_of
C is_bind_expression | Trait that identifies a bind expression
C is_bind_expression< _Bind< _Signature > > | Class template _Bind is always a bind expression
C is_bind_expression< _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
C is_bind_expression< const _Bind< _Signature > > | Class template _Bind is always a bind expression
C is_bind_expression< const _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
C is_bind_expression< const volatile _Bind< _Signature > > | Class template _Bind is always a bind expression
C is_bind_expression< const volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
C is_bind_expression< volatile _Bind< _Signature > > | Class template _Bind is always a bind expression
C is_bind_expression< volatile _Bind_result< _Result, _Signature > > | Class template _Bind_result is always a bind expression
C is_class | Is_class
C is_compound | Is_compound
C is_const | Is_const
C is_constructible | Is_constructible
C is_copy_assignable | Is_copy_assignable
C is_copy_constructible | Is_copy_constructible
C is_default_constructible | Is_default_constructible
C is_destructible | Is_destructible
C is_empty | Is_empty
C is_enum | Is_enum
C is_error_code_enum | Is_error_code_enum
C is_error_code_enum< future_errc > | Specialization that allows future_errc to convert to error_code
C is_error_condition_enum | Is_error_condition_enum
C is_floating_point | Is_floating_point
C is_function | Is_function
C is_fundamental | Is_fundamental
C is_integral | Is_integral
C is_layout_compatible |
C is_literal_type |
C is_lvalue_reference | Is_lvalue_reference
C is_member_function_pointer | Is_member_function_pointer
C is_member_object_pointer | Is_member_object_pointer
C is_member_pointer | Is_member_pointer
C is_move_assignable | Is_move_assignable
C is_move_constructible | Is_move_constructible
C is_nothrow_assignable | Is_nothrow_assignable
C is_nothrow_constructible | Is_nothrow_constructible
C is_nothrow_copy_assignable | Is_nothrow_copy_assignable
C is_nothrow_copy_constructible | Is_nothrow_copy_constructible
C is_nothrow_default_constructible | Is_nothrow_default_constructible
C is_nothrow_destructible | Is_nothrow_destructible
C is_nothrow_move_assignable | Is_nothrow_move_assignable
C is_nothrow_move_constructible | Is_nothrow_move_constructible
C is_object | Is_object
C is_placeholder | Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is
C is_placeholder< _Placeholder< _Num > > |
C is_pod |
C is_pointer | Is_pointer
C is_pointer_interconvertible_base_of | True if _Derived is standard-layout and has a base class of type _Base
C is_polymorphic | Is_polymorphic
C is_reference | Is_reference
C is_rvalue_reference | Is_rvalue_reference
C is_same | Is_same
C is_scalar | Is_scalar
C is_signed | Is_signed
C is_standard_layout | Is_standard_layout
C is_trivial |
C is_trivially_assignable | Is_trivially_assignable
C is_trivially_constructible | Is_trivially_constructible
C is_trivially_copy_assignable | Is_trivially_copy_assignable
C is_trivially_copy_constructible | Is_trivially_copy_constructible
C is_trivially_copyable | Is_trivially_copyable
C is_trivially_default_constructible | Is_trivially_default_constructible
C is_trivially_destructible | Is_trivially_destructible
C is_trivially_move_assignable | Is_trivially_move_assignable
C is_trivially_move_constructible | Is_trivially_move_constructible
C is_union | Is_union
C is_unsigned | Is_unsigned
C is_void | Is_void
C is_volatile | Is_volatile
C istream_iterator | Provides input iterator semantics for streams
C istreambuf_iterator | Provides input iterator semantics for streambufs
C iterator | Common iterator class
C iterator_traits | Traits class for iterators
C iterator_traits< _Tp * > | Partial specialization for object pointer types
C length_error |
C less | One of the comparison functors
C less< void > | One of the comparison functors
C less_equal | One of the comparison functors
C less_equal< void > | One of the comparison functors
C linear_congruential_engine | A model of a linear congruential random number generator
C list | A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
C locale | Container class for localization functionality
C facet | Localization functionality base class
C id | Facet ID class
C lock_guard | A simple scoped lock type
C logic_error | One of two subclasses of exception
C logical_and | One of the Boolean operations functors
C logical_and< void > | One of the Boolean operations functors
C logical_not | One of the Boolean operations functors
C logical_not< void > | One of the Boolean operations functors
C logical_or | One of the Boolean operations functors
C logical_or< void > | One of the Boolean operations functors
C lognormal_distribution | A lognormal_distribution random number distribution
C param_type |
C make_signed | Make_signed
C make_unsigned | Make_unsigned
C map | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
C mask_array | Reference to selected subset of an array
C match_results | The results of a match or search operation
C mem_fun1_ref_t | One of the adaptors for member pointers
C mem_fun1_t | One of the adaptors for member pointers
C mem_fun_ref_t | One of the adaptors for member pointers
C mem_fun_t | One of the adaptors for member pointers
C mersenne_twister_engine |
C messages | Primary class template messages
C messages_base | Messages facet base class providing catalog typedef
C messages_byname | Class messages_byname [22.2.7.2]
C minus | One of the math functors
C minus< void > | One of the math functors
C modulus | One of the math functors
C modulus< void > | One of the math functors
C money_base | Money format ordering data
C money_get | Primary class template money_get
C money_put | Primary class template money_put
C moneypunct | Primary class template moneypunct
C moneypunct_byname | Class moneypunct_byname [22.2.6.4]
C move_iterator | An iterator adaptor that yields an rvalue reference
C move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)> | Polymorphic function wrapper
C move_sentinel | A sentinel adaptor for use with std::move_iterator
C multimap | A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
C multiplies | One of the math functors
C multiplies< void > | One of the math functors
C multiset | A standard container made up of elements, which can be retrieved in logarithmic time
C mutex |
C negate | One of the math functors
C negate< void > | One of the math functors
C negative_binomial_distribution | A negative_binomial_distribution random number distribution
C param_type |
C nested_exception |
C normal_distribution | A normal continuous distribution for random numbers
C param_type |
C not_equal_to | One of the comparison functors
C not_equal_to< void > | One of the comparison functors
C num_get | Primary class template num_get
C num_put | Primary class template num_put
C numeric_limits | Properties of fundamental types
C numeric_limits< bool > | Numeric_limits<bool> specialization
C numeric_limits< char > | Numeric_limits<char> specialization
C numeric_limits< char16_t > | Numeric_limits<char16_t> specialization
C numeric_limits< char32_t > | Numeric_limits<char32_t> specialization
C numeric_limits< double > | Numeric_limits<double> specialization
C numeric_limits< float > | Numeric_limits<float> specialization
C numeric_limits< int > | Numeric_limits<int> specialization
C numeric_limits< long > | Numeric_limits<long> specialization
C numeric_limits< long double > | Numeric_limits<long double> specialization
C numeric_limits< long long > | Numeric_limits<long long> specialization
C numeric_limits< short > | Numeric_limits<short> specialization
C numeric_limits< signed char > | Numeric_limits<signed char> specialization
C numeric_limits< unsigned char > | Numeric_limits<unsigned char> specialization
C numeric_limits< unsigned int > | Numeric_limits<unsigned int> specialization
C numeric_limits< unsigned long > | Numeric_limits<unsigned long> specialization
C numeric_limits< unsigned long long > | Numeric_limits<unsigned long long> specialization
C numeric_limits< unsigned short > | Numeric_limits<unsigned short> specialization
C numeric_limits< wchar_t > | Numeric_limits<wchar_t> specialization
C numpunct | Primary class template numpunct
C numpunct_byname | Class numpunct_byname [22.2.3.2]
C once_flag | Flag type used by std::call_once
C ostream_iterator | Provides output iterator semantics for streams
C ostreambuf_iterator | Provides output iterator semantics for streambufs
C out_of_range |
C out_ptr_t | Smart pointer adaptor for functions taking an output pointer parameter
C output_iterator_tag | Marking output iterators
C overflow_error |
C owner_less | Primary template owner_less
C owner_less< shared_ptr< _Tp > > | Partial specialization of owner_less for shared_ptr
C owner_less< void > | Void specialization of owner_less compares either shared_ptr or weak_ptr
C owner_less< weak_ptr< _Tp > > | Partial specialization of owner_less for weak_ptr
C packaged_task< _Res(_ArgTypes...)> | Packaged_task
C pair | Struct holding two objects (or references) of arbitrary type
C philox_engine | A discrete pseudorandom number generator with weak cryptographic properties
C piecewise_constant_distribution | A piecewise_constant_distribution random number distribution
C param_type |
C piecewise_construct_t | Tag type for piecewise construction of std::pair objects
C piecewise_linear_distribution | A piecewise_linear_distribution random number distribution
C param_type |
C plus | One of the math functors
C pointer_to_binary_function | One of the adaptors for function pointers
C pointer_to_unary_function | One of the adaptors for function pointers
C pointer_traits | Uniform interface to all pointer-like types
C pointer_traits< _Tp * > | Partial specialization for built-in pointers
C poisson_distribution | A discrete Poisson random number distribution
C param_type |
C priority_queue | A standard container automatically sorting its contents
C promise | Primary template for promise
C promise< _Res & > | Partial specialization for promise<R&>
C promise< void > | Explicit specialization for promise<void>
C queue | A standard container giving FIFO behavior
C random_access_iterator_tag | Random-access iterators support a superset of bidirectional iterator operations
C random_device |
C range_error |
C rank | Rank
C ratio | Provides compile-time rational arithmetic
C ratio_equal | Ratio_equal
C ratio_greater | Ratio_greater
C ratio_greater_equal | Ratio_greater_equal
C ratio_less | Ratio_less
C ratio_less_equal | Ratio_less_equal
C ratio_not_equal | Ratio_not_equal
C raw_storage_iterator |
C recursive_mutex |
C recursive_timed_mutex |
C reference_wrapper | Primary class template for reference_wrapper
C regex_error | A regular expression exception class
C regex_iterator |
C regex_token_iterator |
C regex_traits | Describes aspects of a regular expression
C remove_all_extents | Remove_all_extents
C remove_const | Remove_const
C remove_cv | Remove_cv
C remove_extent | Remove_extent
C remove_pointer | Remove_pointer
C remove_reference | Remove_reference
C remove_volatile | Remove_volatile
C result_of | Result_of
C reverse_iterator |
C runtime_error | One of two subclasses of exception
C scoped_allocator_adaptor | An adaptor to recursively pass an allocator to the objects it constructs
C seed_seq | Generates sequences of seeds for random number generators
C set | A standard container made up of unique keys, which can be retrieved in logarithmic time
C shared_future | Primary template for shared_future
C shared_future< _Res & > | Partial specialization for shared_future<R&>
C shared_future< void > | Explicit specialization for shared_future<void>
C shared_lock | Shared_lock
C shared_ptr | A smart pointer with reference-counted copy semantics
C shared_timed_mutex | The standard shared timed mutex type
C shuffle_order_engine | Produces random numbers by reordering random numbers from some base engine
C slice | Class defining one-dimensional subset of an array
C slice_array | Reference to one-dimensional subset of an array
C stack | A standard container giving FILO behavior
C student_t_distribution | A student_t_distribution random number distribution
C param_type |
C sub_match |
C subtract_with_carry_engine | The Marsaglia-Zaman generator
C system_error | An exception type that includes an error_code value
C thread |
C id |
C time_base | Time format ordering data
C time_get | Primary class template time_get
C time_get_byname | Class time_get_byname [22.2.5.2]
C time_put | Primary class template time_put
C time_put_byname | Class time_put_byname [22.2.5.4]
C timed_mutex |
C to_chars_result | Result type of std::to_chars
C try_to_lock_t | Try to acquire ownership of the mutex without blocking
C tuple | Primary class template, tuple
C tuple< _T1, _T2 > | Partial specialization, 2-element tuple. Includes construction and assignment from a pair
C tuple_element | Gives the type of the ith element of a given tuple type
C tuple_element< 0, pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
C tuple_element< 1, pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
C tuple_element< __i, tuple< _Types... > > | Trait to get the Ith element type from a tuple
C tuple_element< _Ind, array< _Tp, _Nm > > | Partial specialization for std::array
C tuple_size | Finds the size of a given tuple type
C tuple_size< array< _Tp, _Nm > > | Partial specialization for std::array
C tuple_size< pair< _Tp1, _Tp2 > > | Partial specialization for std::pair
C tuple_size< tuple< _Elements... > > | Class tuple_size
C type_index | Class type_index
C type_info | Part of RTTI
C type_order | Total ordering of types
C unary_function |
C unary_negate | One of the negation functors
C underflow_error |
C underlying_type | The underlying type of an enum
C uniform_int_distribution | Uniform discrete distribution for random numbers. A discrete random distribution on the range with equal probability throughout the range
C param_type |
C uniform_real_distribution | Uniform continuous distribution for random numbers
C param_type |
C unique_lock | A movable scoped lock type
C unique_ptr | A move-only smart pointer that manages unique ownership of a resource
C unique_ptr< _Tp[], _Dp > | A move-only smart pointer that manages unique ownership of an array
C 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
C 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
C 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
C 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
C uses_allocator | Declare uses_allocator so it can be specialized in <queue> etc
C uses_allocator< tuple< _Types... >, _Alloc > | Partial specialization for tuples
C valarray | Smart array designed to support numeric processing
C vector | A standard container which offers fixed time access to individual elements in any order
C vector< bool, _Alloc > | A specialization of vector for booleans which offers fixed time access to individual elements in any order
C wbuffer_convert | Buffer conversions
C weak_ptr | A non-owning observer for a pointer owned by a shared_ptr
C weibull_distribution | A weibull_distribution random number distribution
C param_type |
C wstring_convert | String conversions