▼ 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
N typelist GNU typelist extensions for public compile-time use
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 _Unqualified_type
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 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 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
N __gnu_internal GNU implemenation details, not for public use or export. Used only when anonymous namespaces cannot be substituted
▼ 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
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
N __gnu_sequential GNU sequential classes for public use
N abi The cross-vendor C++ Application Binary Interface. A namespace alias to __cxxabiv1, but user programs should use the alias 'abi'
▼ N std ISO C++ entities toplevel namespace is std
▼ 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 __parallel GNU parallel code, replaces standard behavior with parallel behavior
C _CRandNumber Functor wrapper for std::rand()
▼ 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
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
▼ N literals ISO C++ inline namespace for literal suffixes
N chrono_literals
N placeholders ISO C++ 2011 namespace for std::bind placeholders
N regex_constants ISO C++ 2011 namespace for options and flags used with std::regex
N rel_ops The generated relational operators are sequestered here
N this_thread ISO C++ 2011 namespace for interacting with the current thread
▼ N tr1 ISO C++ TR1 entities toplevel namespace is std::tr1
N __detail Implementation details not part of the namespace std::tr1 interface
▼ N tr2 Namespace for non-standard "TR2" extensions
N __detail Implementation details not part of the namespace std::tr2 interface
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 __add_pointer_helper Add_pointer
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 __is_member_object_pointer_helper Is_member_object_pointer
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 __remove_pointer_helper Remove_pointer
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. This is just a linked list with nothing inside it. There are purely list shuffling utility methods here
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 _Node_handle Node handle type for maps
C _Node_handle< _Value, _Value, _NodeAlloc > Node handle type for sets
C _Node_handle_common Base class for node handle types of maps and sets
C _Node_insert_return Return type of insert(node_handle&&) on unique maps/sets
C _Not_fn Generalized negator
C _Placeholder The type of placeholder objects defined by libstdc++
C _Sp_ebo_helper< _Nm, _Tp, false > Specialization not using EBO
C _Sp_ebo_helper< _Nm, _Tp, true > Specialization using EBO
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_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 Alignment type
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< _Tp > > 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< _Value, _Int, _St > > 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 collate Facet for localized string comparison
C collate_byname Class collate_byname [22.2.4.2]
C common_iterator An iterator/sentinel adaptor for representing a non-common range
C common_type Common_type
C common_type< chrono::duration< _Rep, _Period > > Specialization of common_type for one chrono::duration type
C common_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > > Specialization of common_type for two identical chrono::duration types
C common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > >
C common_type< chrono::time_point< _Clock, _Duration > > Specialization of common_type for one chrono::time_point type
C common_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > > Specialization of common_type for two identical chrono::time_point types
C common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > >
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 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 decay Decay
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 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 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 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< _Nb > > Std::hash specialization for bitset
C hash< __debug::vector< bool, _Alloc > > 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< _CharT > > 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< _Tp > > Std::hash partial specialization for experimental::optional
C hash< experimental::shared_ptr< _Tp > > 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< _Nb > > Std::hash specialization for bitset
C hash<::vector< bool, _Alloc > > 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 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_convertible Is_convertible
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_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 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
C move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)> Polymorphic function wrapper
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 nostopstate_t Tag type indicating a stop_source should have no shared-stop-state
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 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 of arbitrary type
▼ 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_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 stop_callback A wrapper for callbacks to be run when a stop request is made
C stop_source A type that allows a stop request to be made
C stop_token Allow testing whether a stop request has been made on a stop_source
▼ 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 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