libstdc++: Namespace List (original) (raw)
GNU extensions for public use
▼N__detail
Implementation details not part of the namespace __gnu_cxx interface
__mini_vector<> is a stripped down version of the full-fledged std::vector<>
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
The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
GNU typelist extensions for public compile-time use
Uniform interface to C++98 and C++11 allocators
Policy for shared __pool objects
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)
Base class for _Tp dependent member functions
Policy for individual __pool objects
Data describing the underlying memory pool, parameterized on threading support
Specialization for single thread
Specialization for thread enabled, via gthreads.h
Allocator using a memory pool with a single lock
Base class for __pool_alloc
Base class for pool object
Scoped lock idiom
Template class __versa_string
Mapping from character type to associated types
An example allocator which uses a non-standard pointer type
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 >
A storage policy for use with _Pointer_adapter<> which yields a standard pointer
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
Bitmap Allocator, primary template
Base class used to implement std::char_traits
A POD class that serves as a character abstraction class
Base struct for condition policy
A meta-allocator with debugging bits
Class enc_filebuf
Encoding_char_traits
Extension to use iconv for dealing with character encodings
Thrown by utilities for testing exception safety
The free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
Base class for incremental control and throw
Always enter the condition
Enter the nth condition
Never enter the condition
An allocator that uses malloc
An allocator that uses global new, as per C++03 [20.4.1]
Base class for random probability control and throw
Always enter the condition
Group condition
Never enter the condition
Exception thrown by __cxa_guard_acquire
Crope
Provides a layer of compatibility for C/POSIX
Provides a layer of compatibility for C
Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code
Allocator throwing via limit condition
Allocator throwing via random condition
Class with exception generation control. Intended to be used as a value_type in templatized code
Type throwing via limit condition
Type throwing via random condition
GNU debug classes for public use
Safe class dealing with some allocator dependent operations
Special iterators swap and invalidation for forward_list because of the before_begin iterator
Safe iterator wrapper
Basic functionality for a safe iterator
Safe iterator wrapper
Basic functionality for a safe iterator
Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence
Base class for constructing a safe sequence type that tracks iterators that reference it
Base class that supports tracking of iterators that reference a sequence
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
Base class for Debug Mode vector
Class std::basic_string with safety/checking/debug instrumentation
GNU implemenation details, not for public use or export. Used only when anonymous namespaces cannot be substituted
GNU parallel code for public use
General reduction, using a binary operator
Std::accumulate() selector
C__adjacent_difference_selector
Selector that returns the difference between two adjacent __elements
Test predicate on two adjacent elements
Similar to std::binder1st, but giving the argument types explicitly
Similar to std::binder2nd, but giving the argument types explicitly
Std::count_if () selector
Std::count() selector
Std::fill() selector
Test predicate on several elements
Test predicate on a single element, used for std::find() and std::find_if ()
Std::for_each() selector
Std::generate() selector
Base class of all __gnu_parallel::__find_template selectors
Generic __selector for embarrassingly parallel functions
Selector that just returns the passed iterator
Std::inner_product() selector
Reduction for finding the maximum element, using a comparator
Reduction for finding the maximum element, using a comparator
Test inverted predicate on a single element
C__multiway_merge_3_variant_sentinel_switch
Switch for 3-way merging with __sentinels turned off
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
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
Switch for k-way merging with __sentinels turned off
Std::replace() selector
Std::replace() selector
Std::transform() __selector, one input sequence variant
Std::transform() __selector, two input sequences variant
Similar to std::unary_negate, but giving the argument types explicitly
Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
Reduction function doing nothing
Constructs predicate for equality from strict weak ordering predicate
Similar to std::equal_to, but allows two different types
_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
A pair of iterators. The usual iterator operations are applied to both child iterators
A triple of iterators. The usual iterator operations are applied to all three child iterators
C_Job
One __job for a certain thread
Similar to std::less, but allows two different types
Compare __a pair of types lexicographically, ascending
Compare __a pair of types lexicographically, descending
Stable _LoserTree variant
C_LoserTree< false, _Tp, _Compare >
Unstable _LoserTree variant
Guarded loser/tournament tree
Internal representation of a _LoserTree element
Stable _LoserTree implementation
C_LoserTreePointer< false, _Tp, _Compare >
Unstable _LoserTree implementation
Base class of _Loser Tree implementation using pointers
Internal representation of _LoserTree __elements
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
Traits for determining whether the loser tree should use pointers or copies
Stable implementation of unguarded _LoserTree
C_LoserTreeUnguarded< false, _Tp, _Compare >
Non-Stable implementation of unguarded _LoserTree
Base class for unguarded _LoserTree implementation
Similar to std::multiplies, but allows two different types
Functor doing nothing
Subsequence description
Similar to std::plus, but allows two different types
Data accessed by all threads
Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
Information local to one thread in the parallel quicksort run
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
Stable sorting functor
C_SamplingSorter< false, _RAIter, _StrictWeakOrdering >
Non-__stable sorting functor
Class _Settings Run-time settings for the parallel mode including all tunable parameters
Split consistently
C_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >
Split by sampling
C_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >
Split by exact splitting
Forces parallel sorting using balanced quicksort at compile time
Recommends parallel execution using dynamic load-balancing at compile time
Selects the constant block size variant for std::find()
Recommends parallel execution using the default parallel algorithm
Selects the equal splitting variant for std::find()
Forces parallel merging with exact splitting, at compile time
Base class for for std::find() variants
Selects the growing block size variant for std::find()
Forces parallel sorting using multiway mergesort with exact splitting at compile time
Cmultiway_mergesort_sampling_tag
Forces parallel sorting using multiway mergesort with splitting by sampling at compile time
Forces parallel sorting using multiway mergesort at compile time
Recommends parallel execution using OpenMP static load-balancing at compile time
Recommends parallel execution using OpenMP dynamic load-balancing at compile time
Recommends parallel execution at compile time, optionally using a user-specified number of threads
Forces parallel sorting using unbalanced quicksort at compile time
Forces parallel merging with exact splitting, at compile time
Forces sequential execution at compile time
Recommends parallel execution using static load-balancing at compile time
GNU extensions for policy-based data structures for public use
Basic associative-container
Basic branch structure
Basic hash structure
Binary-heap (array-based)
Binomial-heap
Ccc_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
Collision-chaining hash
Base class for exceptions
Base data structure tag
Container traits
Primary template, container traits base
Ccontainer_traits_base< binary_heap_tag >
Specialization, binary heap
Ccontainer_traits_base< binomial_heap_tag >
Specialization, binomial heap
Ccontainer_traits_base< cc_hash_tag >
Specialization, cc hash
Ccontainer_traits_base< gp_hash_tag >
Specialization, gp hash
Ccontainer_traits_base< list_update_tag >
Specialization, list update
Ccontainer_traits_base< ov_tree_tag >
Specialization, ov tree
Ccontainer_traits_base< pairing_heap_tag >
Specialization, pairing heap
Ccontainer_traits_base< pat_trie_tag >
Specialization, pat trie
Ccontainer_traits_base< rb_tree_tag >
Specialization, rb tree
Ccontainer_traits_base< rc_binomial_heap_tag >
Specialization, rc binomial heap
Ccontainer_traits_base< splay_tree_tag >
Specialization, splay tree
Ccontainer_traits_base< thin_heap_tag >
Specialization, thin heap
A mask range-hashing class (uses a bitmask)
A mod range-hashing class (uses the modulo function)
General-probing hash
A size policy whose sequence of sizes form an exponential sequence (typically powers of 2
Chash_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
A size policy whose sequence of sizes form a nearly-exponential sequence of primes
A resize policy which delegates operations to size and trigger policies
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)
A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps
A probe sequence policy using fixed increments
List-update
A null node updator, indicating that no node updates are required
Represents no type, or absence of type, for template tricks
Ordered-vector tree
Pairing-heap
PATRICIA trie
Basic priority-queue
A probe sequence policy using square increments
Red-black tree
Redundant-counter binomial-heap
A container cannot be resized
A sample probe policy
A sample range-hashing functor
A sample ranged-hash functor
A sample ranged-probe functor
A sample resize policy
A sample resize trigger policy
A sample size policy
A sample node updator
A sample trie element access traits
A sample node updator
A sample list-update policy
Basic sequence
Splay tree
Basic string container, inclusive of strings, ropes, etc
Thin heap
Ctree
Ctree_order_statistics_node_update
Functor updating ranks of entrees
Basic tree structure
Ctrie
Ctrie_order_statistics_node_update
Functor updating ranks of entrees
Ctrie_prefix_search_node_update
A node updator that allows tries to be searched for the range of values that match a certain prefix
Basic trie structure
A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
GNU sequential classes for public use
Nabi
The cross-vendor C++ Application Binary Interface. A namespace alias to __cxxabiv1, but user programs should use the alias 'abi'
▼Nstd
ISO C++ entities toplevel namespace is std
▼N__debug
GNU debug code, replaces standard behavior with debug behavior
Class std::bitset with additional safety/checking/debug instrumentation
Class std::deque with safety/checking/debug instrumentation
Class std::forward_list with safety/checking/debug instrumentation
Clist
Class std::list with safety/checking/debug instrumentation
Cmap
Class std::map with safety/checking/debug instrumentation
Class std::multimap with safety/checking/debug instrumentation
Class std::multiset with safety/checking/debug instrumentation
Cset
Class std::set with safety/checking/debug instrumentation
Class std::unordered_map with safety/checking/debug instrumentation
Class std::unordered_multimap with safety/checking/debug instrumentation
Class std::unordered_multiset with safety/checking/debug instrumentation
Class std::unordered_set with safety/checking/debug instrumentation
Class std::vector with safety/checking/debug instrumentation
▼N__detail
Implementation details not part of the namespace std interface
Matches a character range (bracket expression)
Builds an NFA from an input iterator range
Takes a regex and an input string and does the matching
Common part of a node in the list
The list node header
Struct for delimited strings
Scans an input range for regex tokens
Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction
GNU parallel code, replaces standard behavior with parallel behavior
Functor wrapper for std::rand()
▼Nchrono
ISO C++ 2011 namespace for date and time utilities
chrono::duration represents a distance between two points in time
Duration_values
Monotonic clock
System clock
chrono::time_point represents a point in time as measured by a clock
▼Ndecimal
ISO/IEC TR 24733 Decimal floating-point arithmetic
3.2.4 Class decimal128
3.2.2 Class decimal32
3.2.3 Class decimal64
Namespace for features defined in ISO Technical Specifications
Cany
A type-safe container of any type
Exception class thrown by a failed any_cast
Exception class thrown when a disengaged optional object is dereferenced
A non-owning reference to a string
Tag type for in-place construction
Tag type to disengage optional objects
Class template for optional values
Output iterator that inserts a delimiter between elements
Cowner_less< shared_ptr< _Tp > >
Partial specialization of owner_less for shared_ptr
Cowner_less< weak_ptr< _Tp > >
Partial specialization of owner_less for weak_ptr
Const-propagating wrapper
ISO C++ 2017 namespace for File System library
The value type used by directory iterators
Iterator type for traversing the entries in a single directory
Information about a file's type and permissions
Exception type thrown by the Filesystem library
▼Cpath
A filesystem path
An iterator for the components of a path
Iterator type for recursively traversing a directory hierarchy
Information about free space on a disk
▼Nliterals
ISO C++ inline namespace for literal suffixes
ISO C++ 2011 namespace for std::bind placeholders
ISO C++ 2011 namespace for options and flags used with std::regex
The generated relational operators are sequestered here
ISO C++ 2011 namespace for interacting with the current thread
▼Ntr1
ISO C++ TR1 entities toplevel namespace is std::tr1
Implementation details not part of the namespace std::tr1 interface
▼Ntr2
Namespace for non-standard "TR2" extensions
Implementation details not part of the namespace std::tr2 interface
C__reflection_typelist< _First, _Rest... >
Partial specialization
Specialization for an empty typelist
Sequence abstraction metafunctions for manipulating a typelist
Enumerate all the direct base classes of a class. Form of a typelist
The dynamic_bitset class represents a sequence of bits
Add_pointer
Common implementation for future and shared_future
Common base for codecvt functions
Common base for ctype facet
C__is_member_object_pointer_helper
Is_member_object_pointer
An allocator that uses global new, as per C++03 [20.4.1]
Part of std::numeric_limits
Remove_pointer
Type of the function object returned from bind()
Type of the function object returned from bind()
A deque::iterator
Base class of all polymorphic function object wrappers
Base class for forward_list
A forward_list::const_iterator
A forward_list::iterator
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
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
See bits/stl_deque.h's _Deque_base for an explanation
A list::const_iterator
A list::iterator
An actual node in the list
Node handle type for maps
C_Node_handle< _Value, _Value, _NodeAlloc >
Node handle type for sets
Base class for node handle types of maps and sets
Return type of insert(node_handle&&) on unique maps/sets
Generalized negator
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
See bits/stl_deque.h's _Deque_base for an explanation
Add_const
Add_cv
Add_lvalue_reference
Add_rvalue_reference
Add_volatile
Assume the calling thread has already obtained mutex ownership and manage it
Alignment type
Provide aligned storage for types
Alignment_of
The standard allocator, as per C++03 [20.4.1]
Uniform interface to all allocator types
Callocator_traits< allocator< _Tp > >
Partial specialization for std::allocator
Callocator_traits< allocator< void > >
Explicit specialization for std::allocator<void>
Callocator_traits< pmr::polymorphic_allocator< _Tp > >
Partial specialization for std::pmr::polymorphic_allocator
A standard container for storing a fixed size sequence of elements
Generic atomic type, primary class template
Partial specialization for pointer types
Atomic
Explicit specialization for char
Explicit specialization for char16_t
Explicit specialization for char32_t
Explicit specialization for int
Explicit specialization for long
Explicit specialization for long long
Explicit specialization for short
Explicit specialization for signed char
Explicit specialization for unsigned char
Explicit specialization for unsigned int
Explicit specialization for unsigned long
Explicit specialization for unsigned long long
Explicit specialization for unsigned short
Explicit specialization for wchar_t
Atomic_flag
A simple smart pointer providing strict ownership semantics
Turns assignment into insertion
Exception possibly thrown by new
Thrown during incorrect typecasting
Exception class thrown when class template function's operator() is called with an empty target
Thrown when a NULL pointer in a typeid expression is used
Exception possibly thrown by shared_ptr
The actual work of input and output (for files)
Controlling input and output for files
Controlling input for files
Template class basic_ios, virtual base class for all stream classes
Template class basic_iostream
Template class basic_istream
Performs setup work for input streams
Controlling input for std::string
Controlling output for files
Template class basic_ostream
Performs setup work for output streams
Controlling output for std::string
A regular expression
The actual work of input and output (interface)
Managing sequences of characters and character-like objects
A non-owning reference to a string
The actual work of input and output (for std::string)
Controlling input and output for std::string
A Bernoulli random number distribution
Bidirectional iterators support a superset of forward iterator operations
One of the negation functors
One of the binder functors
One of the binder functors
A discrete binomial random number distribution
▼Cbitset
The bitset class represents a fixed-size sequence of bits
A cauchy_distribution random number distribution
Basis for explicit traits specializations
Cchar_traits< __gnu_cxx::character< _Value, _Int, _St > >
Char_traits<__gnu_cxx::character> specialization
21.1.3.1 char_traits specializations
21.1.3.2 char_traits specializations
A chi_squared_distribution random number distribution
Primary class template codecvt
Ccodecvt< _InternT, _ExternT, encoding_state >
Codecvt<InternT, _ExternT, encoding_state> specialization
Ccodecvt< char, char, mbstate_t >
Class codecvt<char, char, mbstate_t> specialization
Ccodecvt< char16_t, char, mbstate_t >
Class codecvt<char16_t, char, mbstate_t> specialization
Ccodecvt< char32_t, char, mbstate_t >
Class codecvt<char32_t, char, mbstate_t> specialization
Ccodecvt< wchar_t, char, mbstate_t >
Class codecvt<wchar_t, char, mbstate_t> specialization
Empty base class for codecvt facet [22.2.1.5]
Class codecvt_byname [22.2.1.6]
Facet for localized string comparison
Class collate_byname [22.2.4.2]
An iterator/sentinel adaptor for representing a non-common range
Common_type
Ccommon_type< chrono::duration< _Rep, _Period > >
Specialization of common_type for one chrono::duration type
Ccommon_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > >
Specialization of common_type for two identical chrono::duration types
Ccommon_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > >
Ccommon_type< chrono::time_point< _Clock, _Duration > >
Specialization of common_type for one chrono::time_point type
Ccommon_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > >
Specialization of common_type for two identical chrono::time_point types
Ccommon_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > >
[cmp.result], result of three-way comparison
26.2.3 complex specializations complex specialization
26.2.3 complex specializations complex specialization
26.2.3 complex specializations complex specialization
Condition_variable
Condition_variable_any
Define a member typedef type to one of two argument types
One of the adaptors for member pointers
One of the adaptors for member pointers
One of the adaptors for member pointers
One of the adaptors for member pointers
Contiguous iterators point to objects stored contiguously in memory
An iterator adaptor that keeps track of the distance to the end
Primary class template ctype facet
The ctype specialization
The ctype<wchar_t> specialization
Base class for ctype
Class ctype_byname [22.2.1.2]
22.2.1.4 Class ctype_byname specializations
Decay
Do not acquire ownership of the mutex
A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
Tag type used to declare a class-specific operator delete that can invoke the destructor before deallocating the memory
A discrete_distribution random number distribution
One of the math functors
One of the math functors
Define a member typedef type only if a boolean constant is true
Base class allowing use of the member function shared_from_this
One of the comparison functors
One of the comparison functors
Base class for all library exceptions
An exponential continuous distribution for random numbers
Extent
A extreme_value_distribution random number distribution
A fisher_f_distribution random number distribution
Forward iterators support a superset of input iterator operations
A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
Cfpos
Class representing stream positions
Result type of std::from_chars
Turns assignment into insertion
Cfunction< _Res(_ArgTypes...)>
Polymorphic function wrapper
Primary template for future
Partial specialization for future<R&>
Explicit specialization for future
Exception type thrown by futures
A gamma continuous distribution for random numbers
A discrete geometric random number distribution
One of the comparison functors
One of the comparison functors
One of the comparison functors
One of the comparison functors
Class defining multi-dimensional subset of an array
Reference to multi-dimensional subset of an array
Has_virtual_destructor
Chash
Primary class template hash
Chash< __debug::bitset< _Nb > >
Std::hash specialization for bitset
Chash< __debug::vector< bool, _Alloc > >
Std::hash specialization for vector
Chash< __gnu_cxx::__u16vstring >
Std::hash specialization for __u16vstring
Chash< __gnu_cxx::__u32vstring >
Std::hash specialization for __u32vstring
Std::hash specialization for __vstring
Chash< __gnu_cxx::__wvstring >
Std::hash specialization for __wvstring
Chash< __gnu_cxx::throw_value_limit >
Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
Chash< __gnu_cxx::throw_value_random >
Explicit specialization of std::hash for __gnu_cxx::throw_value_random
Chash< __gnu_debug::basic_string< _CharT > >
Std::hash specialization for __gnu_debug::basic_string
Chash< __shared_ptr< _Tp, _Lp > >
Std::hash specialization for __shared_ptr
Partial specializations for pointer types
Chash< basic_string< char, char_traits< char >, _Alloc > >
Std::hash specialization for string
Chash< basic_string< char16_t, char_traits< char16_t >, _Alloc > >
Std::hash specialization for u16string
Chash< basic_string< char32_t, char_traits< char32_t >, _Alloc > >
Std::hash specialization for u32string
Chash< basic_string< wchar_t, char_traits< wchar_t >, _Alloc > >
Std::hash specialization for wstring
Explicit specialization for bool
Explicit specialization for char
Explicit specialization for char16_t
Explicit specialization for char32_t
Specialization for double
Std::hash specialization for error_code
Std::hash specialization for error_condition
Chash< experimental::optional< _Tp > >
Std::hash partial specialization for experimental::optional
Chash< experimental::shared_ptr< _Tp > >
Std::hash specialization for shared_ptr
Specialization for float
Explicit specialization for int
Explicit specialization for long
Specialization for long double
Explicit specialization for long long
Std::hash specialization for shared_ptr
Explicit specialization for short
Explicit specialization for signed char
Std::hash specialization for thread::id
Std::hash specialization for type_index
Chash< unique_ptr< _Tp, _Dp > >
Std::hash specialization for unique_ptr
Explicit specialization for unsigned char
Explicit specialization for unsigned int
Explicit specialization for unsigned long
Explicit specialization for unsigned long long
Explicit specialization for unsigned short
Explicit specialization for wchar_t
Std::hash specialization for bitset
Chash<::vector< bool, _Alloc > >
Std::hash specialization for vector
[func.identity] The identity function
Reference to arbitrary subset of an array
Initializer_list
Marking input iterators
Turns assignment into insertion
Class template integer_sequence
Integral_constant
▼Cios_base
The base of the I/O class hierarchy
These are thrown to indicate problems with io
Is_abstract
Is_arithmetic
Is_array
Is_assignable
Is_base_of
Trait that identifies a bind expression
Cis_bind_expression< _Bind< _Signature > >
Class template _Bind is always a bind expression
Cis_bind_expression< _Bind_result< _Result, _Signature > >
Class template _Bind_result is always a bind expression
Cis_bind_expression< const _Bind< _Signature > >
Class template _Bind is always a bind expression
Cis_bind_expression< const _Bind_result< _Result, _Signature > >
Class template _Bind_result is always a bind expression
Cis_bind_expression< const volatile _Bind< _Signature > >
Class template _Bind is always a bind expression
Cis_bind_expression< const volatile _Bind_result< _Result, _Signature > >
Class template _Bind_result is always a bind expression
Cis_bind_expression< volatile _Bind< _Signature > >
Class template _Bind is always a bind expression
Cis_bind_expression< volatile _Bind_result< _Result, _Signature > >
Class template _Bind_result is always a bind expression
Is_class
Is_compound
Is_const
Is_constructible
Is_convertible
Is_copy_assignable
Is_copy_constructible
Is_default_constructible
Is_destructible
Is_empty
Is_enum
Is_error_code_enum
Cis_error_code_enum< future_errc >
Specialization that allows future_errc to convert to error_code
Is_error_condition_enum
Is_floating_point
Is_function
Is_fundamental
Is_integral
Is_lvalue_reference
Is_member_function_pointer
Is_member_pointer
Is_move_assignable
Is_move_constructible
Is_nothrow_assignable
Is_nothrow_constructible
Is_nothrow_copy_assignable
Cis_nothrow_copy_constructible
Is_nothrow_copy_constructible
Cis_nothrow_default_constructible
Is_nothrow_default_constructible
Is_nothrow_destructible
Is_nothrow_move_assignable
Cis_nothrow_move_constructible
Is_nothrow_move_constructible
Is_object
Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is
Cis_placeholder< _Placeholder< _Num > >
Is_pointer
Cis_pointer_interconvertible_base_of
True if _Derived is standard-layout and has a base class of type _Base
Is_polymorphic
Is_reference
Is_rvalue_reference
Is_same
Is_scalar
Is_signed
Is_standard_layout
Is_trivial
Is_trivially_assignable
Is_trivially_constructible
Is_trivially_copy_assignable
Cis_trivially_copy_constructible
Is_trivially_copy_constructible
Is_trivially_copyable
Cis_trivially_default_constructible
Is_trivially_default_constructible
Is_trivially_destructible
Is_trivially_move_assignable
Cis_trivially_move_constructible
Is_trivially_move_constructible
Is_union
Is_unsigned
Is_void
Is_volatile
Provides input iterator semantics for streams
Provides input iterator semantics for streambufs
Common iterator class
Traits class for iterators
Partial specialization for object pointer types
Cless
One of the comparison functors
One of the comparison functors
One of the comparison functors
One of the comparison functors
A model of a linear congruential random number generator
Clist
A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
▼Clocale
Container class for localization functionality
Localization functionality base class
Cid
Facet ID class
A simple scoped lock type
One of two subclasses of exception
One of the Boolean operations functors
One of the Boolean operations functors
One of the Boolean operations functors
One of the Boolean operations functors
One of the Boolean operations functors
One of the Boolean operations functors
A lognormal_distribution random number distribution
Make_signed
Make_unsigned
Cmap
A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
Reference to selected subset of an array
The results of a match or search operation
One of the adaptors for member pointers
One of the adaptors for member pointers
One of the adaptors for member pointers
One of the adaptors for member pointers
Primary class template messages
Messages facet base class providing catalog typedef
Class messages_byname [22.2.7.2]
One of the math functors
One of the math functors
One of the math functors
One of the math functors
Money format ordering data
Primary class template money_get
Primary class template money_put
Primary class template moneypunct
Class moneypunct_byname [22.2.6.4]
Cmove_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>
Polymorphic function wrapper
A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
One of the math functors
One of the math functors
A standard container made up of elements, which can be retrieved in logarithmic time
One of the math functors
One of the math functors
▼Cnegative_binomial_distribution
A negative_binomial_distribution random number distribution
A normal continuous distribution for random numbers
Tag type indicating a stop_source should have no shared-stop-state
One of the comparison functors
One of the comparison functors
Primary class template num_get
Primary class template num_put
Properties of fundamental types
Numeric_limits specialization
Numeric_limits specialization
Numeric_limits<char16_t> specialization
Numeric_limits<char32_t> specialization
Numeric_limits specialization
Numeric_limits specialization
Numeric_limits specialization
Numeric_limits specialization
Cnumeric_limits< long double >
Numeric_limits specialization
Numeric_limits specialization
Numeric_limits specialization
Cnumeric_limits< signed char >
Numeric_limits specialization
Cnumeric_limits< unsigned char >
Numeric_limits specialization
Cnumeric_limits< unsigned int >
Numeric_limits specialization
Cnumeric_limits< unsigned long >
Numeric_limits specialization
Cnumeric_limits< unsigned long long >
Numeric_limits specialization
Cnumeric_limits< unsigned short >
Numeric_limits specialization
Numeric_limits<wchar_t> specialization
Primary class template numpunct
Class numpunct_byname [22.2.3.2]
Flag type used by std::call_once
Provides output iterator semantics for streams
Provides output iterator semantics for streambufs
Marking output iterators
Primary template owner_less
Cowner_less< shared_ptr< _Tp > >
Partial specialization of owner_less for shared_ptr
Void specialization of owner_less compares either shared_ptr or weak_ptr
Cowner_less< weak_ptr< _Tp > >
Partial specialization of owner_less for weak_ptr
Cpackaged_task< _Res(_ArgTypes...)>
Packaged_task
Cpair
Struct holding two objects of arbitrary type
▼Cpiecewise_constant_distribution
A piecewise_constant_distribution random number distribution
Tag type for piecewise construction of std::pair objects
▼Cpiecewise_linear_distribution
A piecewise_linear_distribution random number distribution
Cplus
One of the math functors
One of the adaptors for function pointers
One of the adaptors for function pointers
Uniform interface to all pointer-like types
Partial specialization for built-in pointers
A discrete Poisson random number distribution
A standard container automatically sorting its contents
Primary template for promise
Partial specialization for promise<R&>
Explicit specialization for promise
A standard container giving FIFO behavior
Random-access iterators support a superset of bidirectional iterator operations
Crank
Rank
Provides compile-time rational arithmetic
Ratio_equal
Ratio_greater
Ratio_greater_equal
Ratio_less
Ratio_less_equal
Ratio_not_equal
Primary class template for reference_wrapper
A regular expression exception class
Describes aspects of a regular expression
Remove_all_extents
Remove_const
Remove_cv
Remove_extent
Remove_reference
Remove_volatile
Result_of
One of two subclasses of exception
An adaptor to recursively pass an allocator to the objects it constructs
Generates sequences of seeds for random number generators
Cset
A standard container made up of unique keys, which can be retrieved in logarithmic time
Primary template for shared_future
Partial specialization for shared_future<R&>
Explicit specialization for shared_future
Shared_lock
A smart pointer with reference-counted copy semantics
The standard shared timed mutex type
Produces random numbers by reordering random numbers from some base engine
Class defining one-dimensional subset of an array
Reference to one-dimensional subset of an array
A standard container giving FILO behavior
A wrapper for callbacks to be run when a stop request is made
A type that allows a stop request to be made
Allow testing whether a stop request has been made on a stop_source
A student_t_distribution random number distribution
The Marsaglia-Zaman generator
An exception type that includes an error_code value
▼Cthread
Cid
Time format ordering data
Primary class template time_get
Class time_get_byname [22.2.5.2]
Primary class template time_put
Class time_put_byname [22.2.5.4]
Result type of std::to_chars
Try to acquire ownership of the mutex without blocking
Primary class template, tuple
Partial specialization, 2-element tuple. Includes construction and assignment from a pair
Gives the type of the ith element of a given tuple type
Ctuple_element< 0, pair< _Tp1, _Tp2 > >
Partial specialization for std::pair
Ctuple_element< 1, pair< _Tp1, _Tp2 > >
Partial specialization for std::pair
Ctuple_element< __i, tuple< _Types... > >
Trait to get the Ith element type from a tuple
Ctuple_element< _Ind, array< _Tp, _Nm > >
Partial specialization for std::array
Finds the size of a given tuple type
Ctuple_size< array< _Tp, _Nm > >
Partial specialization for std::array
Ctuple_size< pair< _Tp1, _Tp2 > >
Partial specialization for std::pair
Ctuple_size< tuple< _Elements... > >
Class tuple_size
Class type_index
Part of RTTI
One of the negation functors
The underlying type of an enum
Uniform discrete distribution for random numbers. A discrete random distribution on the range ![$[min, max]$](https://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/form_125.png)
with equal probability throughout the range
Uniform continuous distribution for random numbers
A movable scoped lock type
A move-only smart pointer that manages unique ownership of a resource
A move-only smart pointer that manages unique ownership of an array
A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys
A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
Declare uses_allocator so it can be specialized in <queue> etc
Cuses_allocator< tuple< _Types... >, _Alloc >
Partial specialization for tuples
Smart array designed to support numeric processing
A standard container which offers fixed time access to individual elements in any order
A specialization of vector for booleans which offers fixed time access to individual elements in any order
Buffer conversions
A non-owning observer for a pointer owned by a shared_ptr
A weibull_distribution random number distribution
String conversions