libstdc++: Class Hierarchy (original) (raw)

C__gnu_parallel::__accumulate_binop_reduct< _BinOp >

General reduction, using a binary operator

Cstd::__add_pointer_helper< _Tp, typename >

Add_pointer

▼Cstd::__basic_future< _Res >

Common implementation for future and shared_future

Cstd::future< _Res >

Primary template for future

Cstd::shared_future< _Res >

Primary template for shared_future

▼Cstd::__basic_future< _Res & >

Cstd::future< _Res & >

Partial specialization for future<R&>

Cstd::shared_future< _Res & >

Partial specialization for shared_future<R&>

▼Cstd::__basic_future< void >

Cstd::future< void >

Explicit specialization for future

Cstd::shared_future< void >

Explicit specialization for shared_future

C__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >

Policy for shared __pool objects

▼Cstd::tr2::__dynamic_bitset_base< _WordT, _Alloc >

Cstd::tr2::dynamic_bitset< _WordT, _Alloc >

The dynamic_bitset class represents a sequence of bits

Cstd::tr2::__dynamic_bitset_base< unsigned long long, std::allocator< unsigned long long > >

C__cxxabiv1::__forced_unwind

Thrown as part of forced unwinding

▼C__gnu_parallel::__generic_find_selector

Base class of all __gnu_parallel::__find_template selectors

C__gnu_parallel::__adjacent_find_selector

Test predicate on two adjacent elements

C__gnu_parallel::__find_first_of_selector< _FIterator >

Test predicate on several elements

C__gnu_parallel::__find_if_selector

Test predicate on a single element, used for std::find() and std::find_if ()

C__gnu_parallel::__mismatch_selector

Test inverted predicate on a single element

▼C__gnu_parallel::__generic_for_each_selector< _It >

Generic __selector for embarrassingly parallel functions

C__gnu_parallel::__accumulate_selector< _It >

Std::accumulate() selector

C__gnu_parallel::__adjacent_difference_selector< _It >

Selector that returns the difference between two adjacent __elements

C__gnu_parallel::__count_if_selector< _It, _Diff >

Std::count_if () selector

C__gnu_parallel::__count_selector< _It, _Diff >

Std::count() selector

C__gnu_parallel::__fill_selector< _It >

Std::fill() selector

C__gnu_parallel::__for_each_selector< _It >

Std::for_each() selector

C__gnu_parallel::__generate_selector< _It >

Std::generate() selector

C__gnu_parallel::__identity_selector< _It >

Selector that just returns the passed iterator

C__gnu_parallel::__inner_product_selector< _It, _It2, _Tp >

Std::inner_product() selector

C__gnu_parallel::__replace_if_selector< _It, _Op, _Tp >

Std::replace() selector

C__gnu_parallel::__replace_selector< _It, _Tp >

Std::replace() selector

C__gnu_parallel::__transform1_selector< _It >

Std::transform() __selector, one input sequence variant

C__gnu_parallel::__transform2_selector< _It >

Std::transform() __selector, two input sequences variant

Cstd::__is_fast_hash< _Hash >

Cstd::__is_fast_hash< hash< std::basic_string< _CharT > > >

Cstd::__is_location_invariant< _Tp >

Cstd::__is_member_object_pointer_helper< typename >

Is_member_object_pointer

C__gnu_parallel::__max_element_reduct< _Compare, _It >

Reduction for finding the maximum element, using a comparator

C__gnu_parallel::__min_element_reduct< _Compare, _It >

Reduction for finding the maximum element, using a comparator

C__gnu_cxx::__detail::__mini_vector< _Tp >

__mini_vector<> is a stripped down version of the full-fledged std::vector<>

▼C__gnu_cxx::__mt_alloc_base< _Tp >

Base class for _Tp dependent member functions

C__gnu_cxx::__mt_alloc< _Tp, _Poolp >

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__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for 3-way merging with __sentinels turned off

C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for 3-way merging with __sentinels turned on

C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for 4-way merging with __sentinels turned off

C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for 4-way merging with __sentinels turned on

C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for k-way merging with __sentinels turned on

C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >

Switch for k-way merging with __sentinels turned off

▼Cstd::__new_allocator< _Tp >

An allocator that uses global new, as per C++03 [20.4.1]

Cstd::allocator< value_type >

C__gnu_cxx::new_allocator< _Tp >

An allocator that uses global new, as per C++03 [20.4.1]

Cstd::allocator< _Tp >

The standard allocator, as per C++03 [20.4.1]

▼Cstd::__numeric_limits_base

Part of std::numeric_limits

Cstd::numeric_limits< _Tp >

Properties of fundamental types

C__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread >

Policy for individual __pool objects

C__gnu_cxx::__pool< _Thread >

Data describing the underlying memory pool, parameterized on threading support

▼C__gnu_cxx::__pool_alloc_base

Base class for __pool_alloc

C__gnu_cxx::__pool_alloc< _Tp >

Allocator using a memory pool with a single lock

▼C__gnu_cxx::__pool_base

Base class for pool object

C__gnu_cxx::__pool< false >

Specialization for single thread

C__gnu_cxx::__pool< true >

Specialization for thread enabled, via gthreads.h

C__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >

Cstd::tr2::__reflection_typelist< _Elements >

Cstd::tr2::__reflection_typelist< _First, _Rest... >

Partial specialization

Cstd::tr2::__reflection_typelist<>

Specialization for an empty typelist

Cstd::__remove_pointer_helper< _Tp, typename >

Remove_pointer

Cstd::__remove_pointer_helper< _Tp, __remove_cv_t< _Tp > >

C__gnu_cxx::__scoped_lock

Scoped lock idiom

C__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >

Template class __versa_string

C__gnu_debug::_After_nth_from< _Iterator >

Cstd::_Base_bitset< _Nw >

Cstd::_Base_bitset< 0 >

Cstd::_Base_bitset< 1 >

▼Cstd::_Base_bitset<((_Nb)/(__CHAR_BIT__ *__SIZEOF_LONG__)+((_Nb) %(__CHAR_BIT__ *__SIZEOF_LONG__)==0 ? 0 :1))>

Cstd::bitset< _Nb >

The bitset class represents a fixed-size sequence of bits

C__gnu_debug::_BeforeBeginHelper< _Sequence >

Cstd::_Bind< _Signature >

Type of the function object returned from bind()

Cstd::_Bind_result< _Result, _Signature >

Type of the function object returned from bind()

C__gnu_cxx::__detail::_Bitmap_counter< _Tp >

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__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >

Cstd::__detail::_BracketMatcher< _TraitsT, __icase, __collate >

Matches a character range (bracket expression)

C__gnu_cxx::_Caster< _ToType >

C__gnu_cxx::_Char_types< _CharT >

Mapping from character type to associated types

▼C__gnu_pbds::detail::pat_trie_base::_CIter< Node, Leaf, Head, Inode, Is_Forward_Iterator >

Const iterator

C__gnu_pbds::detail::pat_trie_base::_Iter< Node, Leaf, Head, Inode, Is_Forward_Iterator >

Iterator

Cstd::__detail::_Compiler< _TraitsT >

Builds an NFA from an input iterator range

Cstd::__parallel::_CRandNumber< _MustBeInt >

Functor wrapper for std::rand()

▼Cstd::_Deque_base< _Tp, _Alloc >

Cstd::deque< _StateSeqT >

Cstd::deque< _Tp, _Alloc >

A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end

Cstd::_Deque_base< _StateSeqT, std::allocator< _StateSeqT > >

Cstd::_Deque_base< _Tp, std::allocator< _Tp > >

Cstd::_Deque_iterator< _Tp, _Ref, _Ptr >

A deque::iterator

Cstd::_Deque_iterator< _Tp, _Tp &, _Ptr >

C__gnu_parallel::_DRandomShufflingGlobalData< _RAIter >

Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()

C__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator >

Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()

C__gnu_parallel::_DummyReduct

Reduction function doing nothing

C__gnu_debug::_Equal_to< _Type >

Cstd::__detail::_Executor< _BiIter, _Alloc, _TraitsT, __dfs_mode >

Takes a regex and an input string and does the matching

C__gnu_cxx::_ExtPtr_allocator< _Tp >

An example allocator which uses a non-standard pointer type

C__gnu_cxx::__detail::_Ffit_finder< _Tp >

The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator

▼Cstd::_Function_base

Base class of all polymorphic function object wrappers

Cstd::function< _Res(_ArgTypes...)>

Polymorphic function wrapper

▼Cstd::_Fwd_list_base< _Tp, _Alloc >

Base class for forward_list

Cstd::forward_list< _Tp, _Alloc >

A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence

Cstd::_Fwd_list_base< _Tp, allocator< _Tp > >

Cstd::_Fwd_list_const_iterator< _Tp >

A forward_list::const_iterator

Cstd::_Fwd_list_iterator< _Tp >

A forward_list::iterator

▼Cstd::_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

Cstd::_Fwd_list_node< _Tp >

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__gnu_parallel::_GuardedIterator< _RAIter, _Compare >

_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons

C__gnu_cxx::_Invalid_type

C__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory >

A triple of iterators. The usual iterator operations are applied to all three child iterators

C__gnu_parallel::_Job< _DifferenceTp >

One __job for a certain thread

▼Cstd::_List_base< _Tp, _Alloc >

See bits/stl_deque.h's _Deque_base for an explanation

Cstd::list< __inp, __rebind_inp >

Cstd::list< _Tp, _Alloc >

A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence

Cstd::_List_base< __inp, __rebind_inp >

Cstd::_List_base< _Tp, std::allocator< _Tp > >

Cstd::_List_const_iterator< _Tp >

A list::const_iterator

Cstd::_List_iterator< _Tp >

A list::iterator

▼Cstd::__detail::_List_node_base

Common part of a node in the list

Cstd::_List_node< _Tp >

An actual node in the list

Cstd::__detail::_List_node_header

The list node header

C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_Loser

Internal representation of a _LoserTree element

C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_Loser

Internal representation of _LoserTree __elements

▼C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >

Guarded loser/tournament tree

C__gnu_parallel::_LoserTree< __stable, _Tp, _Compare >

Stable _LoserTree variant

C__gnu_parallel::_LoserTree< false, _Tp, _Compare >

Unstable _LoserTree variant

▼C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >

Base class of _Loser Tree implementation using pointers

C__gnu_parallel::_LoserTreePointer< __stable, _Tp, _Compare >

Stable _LoserTree implementation

C__gnu_parallel::_LoserTreePointer< false, _Tp, _Compare >

Unstable _LoserTree implementation

▼C__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare >

Unguarded loser tree, keeping only pointers to the elements in the tree structure

C__gnu_parallel::_LoserTreePointerUnguarded< __stable, _Tp, _Compare >

Stable unguarded _LoserTree variant storing pointers

C__gnu_parallel::_LoserTreePointerUnguarded< false, _Tp, _Compare >

Unstable unguarded _LoserTree variant storing pointers

C__gnu_parallel::_LoserTreeTraits< _Tp >

Traits for determining whether the loser tree should use pointers or copies

▼C__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >

Base class for unguarded _LoserTree implementation

C__gnu_parallel::_LoserTreeUnguarded< __stable, _Tp, _Compare >

Stable implementation of unguarded _LoserTree

C__gnu_parallel::_LoserTreeUnguarded< false, _Tp, _Compare >

Non-Stable implementation of unguarded _LoserTree

C__gnu_pbds::detail::pat_trie_base::_Metadata< Metadata, _Alloc >

Metadata base primary template

C__gnu_pbds::detail::pat_trie_base::_Metadata< null_type, _Alloc >

Specialization for null metadata

▼C__gnu_pbds::detail::pat_trie_base::_Node_base< _ATraits, Metadata >

Node base

C__gnu_pbds::detail::pat_trie_base::_Head< _ATraits, Metadata >

Head node for PATRICIA tree

C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >

Internal node type, PATRICIA tree

C__gnu_pbds::detail::pat_trie_base::_Leaf< _ATraits, Metadata >

Leaf node for PATRICIA tree

▼C__gnu_pbds::detail::pat_trie_base::_Node_citer< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc >

Node const iterator

C__gnu_pbds::detail::pat_trie_base::_Node_iter< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc >

Node iterator

Cstd::_Node_handle_common< _Val, _NodeAlloc >

Base class for node handle types of maps and sets

▼Cstd::_Node_handle_common< _Value, _NodeAlloc >

Cstd::_Node_handle< _Key, _Value, _NodeAlloc >

Node handle type for maps

Cstd::_Node_handle< _Value, _Value, _NodeAlloc >

Node handle type for sets

Cstd::_Node_insert_return< _Iterator, _NodeHandle >

Return type of insert(node_handle&&) on unique maps/sets

C__gnu_debug::_Not_equal_to< _Type >

Cstd::_Not_fn< _Fn >

Generalized negator

C__gnu_parallel::_Nothing

Functor doing nothing

C__gnu_parallel::_Piece< _DifferenceTp >

Subsequence description

Cstd::_Placeholder< _Num >

The type of placeholder objects defined by libstdc++

C__gnu_parallel::_PMWMSSortingData< _RAIter >

Data accessed by all threads

C__gnu_cxx::_Pointer_adapter< _Storage_policy >

C__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp >

Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course

C__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp >

_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality

C__gnu_parallel::_QSBThreadLocal< _RAIter >

Information local to one thread in the parallel quicksort run

Cstd::__detail::_Quoted_string< _String, _CharT >

Struct for delimited strings

C__gnu_parallel::_RandomNumber

Random number generator, based on the Mersenne twister

C__gnu_cxx::_Relative_pointer_impl< _Tp >

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__gnu_cxx::_Relative_pointer_impl< const _Tp >

C__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >

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__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >

▼C__gnu_debug::_Safe_container< _SafeContainer, _Alloc, _SafeBase, _IsCxx11AllocatorAware >

Safe class dealing with some allocator dependent operations

C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >

Class std::basic_string with safety/checking/debug instrumentation

Cstd::__debug::deque< _Tp, _Allocator >

Class std::deque with safety/checking/debug instrumentation

Cstd::__debug::forward_list< _Tp, _Alloc >

Class std::forward_list with safety/checking/debug instrumentation

Cstd::__debug::list< _Tp, _Allocator >

Class std::list with safety/checking/debug instrumentation

Cstd::__debug::map< _Key, _Tp, _Compare, _Allocator >

Class std::map with safety/checking/debug instrumentation

Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator >

Class std::multimap with safety/checking/debug instrumentation

Cstd::__debug::multiset< _Key, _Compare, _Allocator >

Class std::multiset with safety/checking/debug instrumentation

Cstd::__debug::set< _Key, _Compare, _Allocator >

Class std::set with safety/checking/debug instrumentation

Cstd::__debug::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >

Class std::unordered_map with safety/checking/debug instrumentation

Cstd::__debug::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >

Class std::unordered_multimap with safety/checking/debug instrumentation

Cstd::__debug::unordered_multiset< _Value, _Hash, _Pred, _Alloc >

Class std::unordered_multiset with safety/checking/debug instrumentation

Cstd::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc >

Class std::unordered_set with safety/checking/debug instrumentation

Cstd::__debug::vector< _Tp, _Allocator >

Class std::vector with safety/checking/debug instrumentation

C__gnu_debug::_Safe_container< basic_string< _CharT, std::char_traits< _CharT >, std::allocator< _CharT > >, std::allocator< _CharT >, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>

C__gnu_debug::_Safe_container< deque< _Tp, std::allocator< _Tp > >, std::allocator< _Tp >, __gnu_debug::_Safe_sequence >

C__gnu_debug::_Safe_container< forward_list< _Tp, std::allocator< _Tp > >, std::allocator< _Tp >, __gnu_debug::_Safe_forward_list >

C__gnu_debug::_Safe_container< list< _Tp, std::allocator< _Tp > >, std::allocator< _Tp >, __gnu_debug::_Safe_node_sequence >

C__gnu_debug::_Safe_container< map< _Key, _Tp, std::less< _Key >, std::allocator< std::pair< const _Key, _Tp > > >, std::allocator< std::pair< const _Key, _Tp > >, __gnu_debug::_Safe_node_sequence >

C__gnu_debug::_Safe_container< multimap< _Key, _Tp, std::less< _Key >, std::allocator< std::pair< const _Key, _Tp > > >, std::allocator< std::pair< const _Key, _Tp > >, __gnu_debug::_Safe_node_sequence >

C__gnu_debug::_Safe_container< multiset< _Key, std::less< _Key >, std::allocator< _Key > >, std::allocator< _Key >, __gnu_debug::_Safe_node_sequence >

C__gnu_debug::_Safe_container< set< _Key, std::less< _Key >, std::allocator< _Key > >, std::allocator< _Key >, __gnu_debug::_Safe_node_sequence >

C__gnu_debug::_Safe_container< unordered_map< _Key, _Tp, std::hash< _Key >, std::equal_to< _Key >, std::allocator< std::pair< const _Key, _Tp > > >, std::allocator< std::pair< const _Key, _Tp > >, __gnu_debug::_Safe_unordered_container >

C__gnu_debug::_Safe_container< unordered_multimap< _Key, _Tp, std::hash< _Key >, std::equal_to< _Key >, std::allocator< std::pair< const _Key, _Tp > > >, std::allocator< std::pair< const _Key, _Tp > >, __gnu_debug::_Safe_unordered_container >

C__gnu_debug::_Safe_container< unordered_multiset< _Value, std::hash< _Value >, std::equal_to< _Value >, std::allocator< _Value > >, std::allocator< _Value >, __gnu_debug::_Safe_unordered_container >

C__gnu_debug::_Safe_container< unordered_set< _Value, std::hash< _Value >, std::equal_to< _Value >, std::allocator< _Value > >, std::allocator< _Value >, __gnu_debug::_Safe_unordered_container >

C__gnu_debug::_Safe_container< vector< _Tp, std::allocator< _Tp > >, std::allocator< _Tp >, __gnu_debug::_Safe_sequence >

▼C__gnu_debug::_Safe_iterator_base

Basic functionality for a safe iterator

C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, std::forward_iterator_tag >

C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, std::bidirectional_iterator_tag >

C__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >

Safe iterator wrapper

▼C__gnu_debug::_Safe_local_iterator_base

Basic functionality for a safe iterator

C__gnu_debug::_Safe_local_iterator< _Iterator, _Sequence >

Safe iterator wrapper

▼C__gnu_debug::_Safe_sequence_base

Base class that supports tracking of iterators that reference a sequence

▼C__gnu_debug::_Safe_sequence< _SafeSequence >

C__gnu_debug::_Safe_forward_list< _SafeSequence >

Special iterators swap and invalidation for forward_list because of the before_begin iterator

▼C__gnu_debug::_Safe_sequence< _Sequence >

Base class for constructing a safe sequence type that tracks iterators that reference it

C__gnu_debug::_Safe_node_sequence< _Sequence >

Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence

▼C__gnu_debug::_Safe_unordered_container_base

Base class that supports tracking of local iterators that reference an unordered container

C__gnu_debug::_Safe_unordered_container< _Container >

Base class for constructing a safe unordered container type that tracks iterators that reference it

▼C__gnu_debug::_Safe_vector< _SafeSequence, _BaseSequence >

Base class for Debug Mode vector

Cstd::__debug::vector< _Tp, _Allocator >

Class std::vector with safety/checking/debug instrumentation

C__gnu_debug::_Safe_vector< vector< _Tp, std::allocator< _Tp > >, ::vector< _Tp, std::allocator< _Tp > > >

C__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >

Stable sorting functor

C__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >

Non-__stable sorting functor

Cstd::__detail::_Scanner< _CharT >

Scans an input range for regex tokens

C__gnu_debug::_Sequence_traits< _Sequence >

C__gnu_parallel::_Settings

Class _Settings Run-time settings for the parallel mode including all tunable parameters

Cstd::_Sp_ebo_helper< _Nm, _Tp, false >

Specialization not using EBO

Cstd::_Sp_ebo_helper< _Nm, _Tp, true >

Specialization using EBO

C__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator >

Split consistently

C__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >

Split by sampling

C__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >

Split by exact splitting

Cstd::__detail::_StateSeq< _TraitsT >

Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction

C__gnu_cxx::_Std_pointer_impl< _Tp >

A storage policy for use with _Pointer_adapter<> which yields a standard pointer

▼Cstd::_Temporary_buffer< _ForwardIterator, _Tp >

C__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp >

Cstd::_Temporary_buffer< _ForwardIterator, typename std::iterator_traits< _ForwardIterator >::value_type >

C__gnu_cxx::_Unqualified_type< _Tp >

▼Cstd::_Vector_base< _Tp, _Alloc >

See bits/stl_deque.h's _Deque_base for an explanation

Cstd::vector< _State< _TraitsT::char_type > >

Cstd::vector< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > >

Cstd::vector< block_type, allocator_type >

Cstd::vector< _Node *, _Nodeptr_Alloc >

Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > >

Cstd::vector< Catalog_info * >

Cstd::vector< _CharT >

Cstd::vector< _StringT >

Cstd::vector< std::pair< _StrTransT, _StrTransT > >

Cstd::vector< _CharClassT >

Cstd::vector< sub_match< _BiIter >, _Alloc >

Cstd::vector< std::pair< _BiIter, int > >

Cstd::vector< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > > >

Cstd::vector< size_t >

Cstd::vector< time_zone >

Cstd::vector< time_zone_link >

Cstd::vector< leap_second >

Cstd::vector< double >

Cstd::vector< _Cmpt >

Cstd::vector< __diff_type >

Cstd::vector< _RealType >

Cstd::vector< _BigBlock >

Cstd::vector< int >

Cstd::vector< result_type >

▼Cstd::vector< _Tp, _Alloc >

A standard container which offers fixed time access to individual elements in any order

Cstd::match_results< _Bi_iter, _Alloc >

The results of a match or search operation

Cstd::_Vector_base< __diff_type, std::allocator< __diff_type > >

Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > >

Cstd::_Vector_base< _BigBlock, std::allocator< _BigBlock > >

Cstd::_Vector_base< _CharClassT, std::allocator< _CharClassT > >

Cstd::_Vector_base< _CharT, std::allocator< _CharT > >

Cstd::_Vector_base< _Cmpt, std::allocator< _Cmpt > >

Cstd::_Vector_base< _Node *, _Nodeptr_Alloc >

Cstd::_Vector_base< _RealType, std::allocator< _RealType > >

Cstd::_Vector_base< _State< _TraitsT::char_type >, std::allocator< _State< _TraitsT::char_type > > >

Cstd::_Vector_base< _StringT, std::allocator< _StringT > >

Cstd::_Vector_base< _Tp, std::allocator< _Tp > >

Cstd::_Vector_base< block_type, allocator_type >

Cstd::_Vector_base< Catalog_info *, std::allocator< Catalog_info * > >

Cstd::_Vector_base< double, std::allocator< double > >

Cstd::_Vector_base< int, std::allocator< int > >

Cstd::_Vector_base< leap_second, std::allocator< leap_second > >

Cstd::_Vector_base< result_type, std::allocator< result_type > >

Cstd::_Vector_base< size_t, std::allocator< size_t > >

Cstd::_Vector_base< std::pair< _BiIter, int >, std::allocator< std::pair< _BiIter, int > > >

Cstd::_Vector_base< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > >, std::allocator< std::pair< _StateIdT, vector< sub_match< _BiIter >, _Alloc > > > >

Cstd::_Vector_base< std::pair< _StrTransT, _StrTransT >, std::allocator< std::pair< _StrTransT, _StrTransT > > >

Cstd::_Vector_base< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > >

Cstd::_Vector_base< sub_match< _BiIter >, _Alloc >

Cstd::_Vector_base< time_zone, std::allocator< time_zone > >

Cstd::_Vector_base< time_zone_link, std::allocator< time_zone_link > >

Cstd::add_const< _Tp >

Add_const

Cstd::add_cv< _Tp >

Add_cv

Cstd::add_lvalue_reference< _Tp >

Add_lvalue_reference

Cstd::add_rvalue_reference< _Tp >

Add_rvalue_reference

Cstd::add_volatile< _Tp >

Add_volatile

Cstd::adopt_lock_t

Assume the calling thread has already obtained mutex ownership and manage it

Cstd::aligned_storage< _Len, _Align >

Alignment type

Cstd::aligned_storage< sizeof(_M_ptr), alignof(void *)>

Cstd::aligned_union< _Len, _Types >

Provide aligned storage for types

Cstd::allocator< void >

▼Cstd::allocator_traits< _Alloc >

Uniform interface to all allocator types

C__gnu_cxx::__alloc_traits< _Tp_alloc_type >

C__gnu_cxx::__alloc_traits< _Alloc, typename >

Uniform interface to C++98 and C++11 allocators

Cstd::allocator_traits< _Tp_alloc_type >

Cstd::allocator_traits< allocator< _Tp > >

Partial specialization for std::allocator

Cstd::allocator_traits< allocator< void > >

Explicit specialization for std::allocator<void>

Cstd::allocator_traits< pmr::polymorphic_allocator< _Tp > >

Partial specialization for std::pmr::polymorphic_allocator

C__gnu_cxx::limit_condition::always_adjustor

Always enter the condition

C__gnu_cxx::random_condition::always_adjustor

Always enter the condition

▼C__gnu_cxx::annotate_base

Base class for checking address and label information about allocations. Create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size

▼C__gnu_cxx::throw_allocator_base< _Tp, limit_condition >

C__gnu_cxx::throw_allocator_limit< _Tp >

Allocator throwing via limit condition

▼C__gnu_cxx::throw_allocator_base< _Tp, random_condition >

C__gnu_cxx::throw_allocator_random< _Tp >

Allocator throwing via random condition

C__gnu_cxx::throw_allocator_base< _Tp, _Cond >

Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code

Cstd::experimental::any

A type-safe container of any type

Cstd::experimental::fundamentals_v1::any

A type-safe container of any type

Cstd::array< _Tp, _Nm >

A standard container for storing a fixed size sequence of elements

Cstd::array< value_type, 4/sizeof(_ToFmt)>

Cstd::atomic< _Tp >

Generic atomic type, primary class template

Cstd::atomic< _Tp * >

Partial specialization for pointer types

Cstd::atomic< bool >

Atomic

Cstd::atomic< char >

Explicit specialization for char

Cstd::atomic< char16_t >

Explicit specialization for char16_t

Cstd::atomic< char32_t >

Explicit specialization for char32_t

Cstd::atomic< int >

Explicit specialization for int

Cstd::atomic< long >

Explicit specialization for long

Cstd::atomic< long long >

Explicit specialization for long long

Cstd::atomic< short >

Explicit specialization for short

Cstd::atomic< signed char >

Explicit specialization for signed char

Cstd::atomic< unsigned char >

Explicit specialization for unsigned char

Cstd::atomic< unsigned int >

Explicit specialization for unsigned int

Cstd::atomic< unsigned long >

Explicit specialization for unsigned long

Cstd::atomic< unsigned long long >

Explicit specialization for unsigned long long

Cstd::atomic< unsigned short >

Explicit specialization for unsigned short

Cstd::atomic< value_type >

Cstd::atomic< wchar_t >

Explicit specialization for wchar_t

Cstd::atomic_flag

Atomic_flag

Cstd::auto_ptr< _Tp >

A simple smart pointer providing strict ownership semantics

Cstd::auto_ptr_ref< _Tp1 >

Cstd::tr2::bases< _Tp >

Sequence abstraction metafunctions for manipulating a typelist

▼C__gnu_pbds::basic_branch< Key, Mapped, Tag, Node_Update, Policy_Tl, _Alloc >

C__gnu_pbds::tree< Key, Mapped, Cmp_Fn, Tag, Node_Update, _Alloc >

C__gnu_pbds::trie< Key, Mapped, _ATraits, Tag, Node_Update, _Alloc >

C__gnu_pbds::basic_branch< Key, Mapped, pat_trie_tag, detail::trie_traits< Key, Mapped, typename detail::default_trie_access_traits< Key >::type, null_node_update, pat_trie_tag, std::allocator< char > > ::node_update, __gnu_cxx::typelist::create2< typename detail::default_trie_access_traits< Key >::type, detail::trie_traits< Key, Mapped, typename detail::default_trie_access_traits< Key >::type, null_node_update, pat_trie_tag, std::allocator< char > > >::type, std::allocator< char > >

C__gnu_pbds::basic_branch< Key, Mapped, rb_tree_tag, detail::tree_traits< Key, Mapped, std::less< Key >, null_node_update, rb_tree_tag, std::allocator< char > > ::node_update, __gnu_cxx::typelist::create2< std::less< Key >, detail::tree_traits< Key, Mapped, std::less< Key >, null_node_update, rb_tree_tag, std::allocator< char > > >::type, std::allocator< char > >

▼C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, Tag, Policy_Tl, _Alloc >

C__gnu_pbds::cc_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Hash_Fn, Resize_Policy, Store_Hash, _Alloc >

C__gnu_pbds::gp_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Probe_Fn, Probe_Fn, Resize_Policy, Store_Hash, _Alloc >

C__gnu_pbds::basic_hash_table< Key, Mapped, typename detail::default_hash_fn< Key >::type, typename detail::default_eq_fn< Key >::type, typename detail::default_resize_policy< detail::default_comb_hash_fn::type >::type, detail::default_store_hash, cc_hash_tag, __gnu_cxx::typelist::create1< detail::default_comb_hash_fn::type >::type, std::allocator< char > >

C__gnu_pbds::basic_hash_table< Key, Mapped, typename detail::default_hash_fn< Key >::type, typename detail::default_eq_fn< Key >::type, typename detail::default_resize_policy< detail::default_comb_hash_fn::type >::type, detail::default_store_hash, gp_hash_tag, __gnu_cxx::typelist::create2< detail::default_comb_hash_fn::type, typename detail::default_probe_fn< detail::default_comb_hash_fn::type >::type >::type, std::allocator< char > >

▼C__gnu_pbds::basic_invalidation_guarantee

▼C__gnu_pbds::point_invalidation_guarantee

C__gnu_pbds::range_invalidation_guarantee

Cstd::basic_regex< _Ch_type, _Rx_traits >

A regular expression

▼Cstd::basic_streambuf< _CharT, _Traits >

The actual work of input and output (interface)

▼Cstd::basic_filebuf< _CharT, encoding_char_traits< _CharT > >

C__gnu_cxx::enc_filebuf< _CharT >

Class enc_filebuf

Cstd::basic_filebuf< _CharT, std::char_traits< _CharT > >

Cstd::basic_filebuf< char_type, traits_type >

C__gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >

Provides a layer of compatibility for C

▼Cstd::basic_filebuf< _CharT, _Traits >

The actual work of input and output (for files)

C__gnu_cxx::stdio_filebuf< _CharT, _Traits >

Provides a layer of compatibility for C/POSIX

Cstd::basic_stringbuf< _CharT, _Traits, _Alloc >

The actual work of input and output (for std::string)

Cstd::wbuffer_convert< _Codecvt, _Elem, _Tr >

Buffer conversions

Cstd::basic_streambuf< _CharT, encoding_char_traits< _CharT > >

Cstd::basic_streambuf< _CharT, std::char_traits< _CharT > >

Cstd::basic_streambuf< char, _Traits >

Cstd::basic_streambuf< char, char_traits< char > >

Cstd::basic_streambuf< char_type, traits_type >

Cstd::basic_streambuf< wchar_t, char_traits< wchar_t > >

▼Cstd::basic_string< _CharT, _Traits, _Alloc >

Managing sequences of characters and character-like objects

C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >

Class std::basic_string with safety/checking/debug instrumentation

Cstd::basic_string< _CharT >

Cstd::basic_string< _CharT, std::char_traits< _CharT >, std::allocator< _CharT > >

Cstd::basic_string< char >

Cstd::basic_string< char, char_traits< char >, allocator< char > >

Cstd::basic_string< char_type, _Traits, _Alloc >

Cstd::basic_string< value_type >

Cstd::basic_string< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >

Cstd::basic_string_view< _CharT, _Traits >

A non-owning reference to a string

Cstd::experimental::basic_string_view< _CharT, _Traits >

A non-owning reference to a string

Cstd::experimental::fundamentals_v1::basic_string_view< _CharT, _Traits >

A non-owning reference to a string

Cstd::basic_string_view< _CharT, _Traits >

Cstd::bernoulli_distribution

A Bernoulli random number distribution

▼C__gnu_pbds::detail::bin_search_tree_const_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc >

Const iterator

C__gnu_pbds::detail::bin_search_tree_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc >

Iterator

▼C__gnu_pbds::detail::bin_search_tree_const_node_it_< Node, Const_Iterator, Iterator, _Alloc >

Const node iterator

C__gnu_pbds::detail::bin_search_tree_node_it_< Node, Const_Iterator, Iterator, _Alloc >

Node iterator

C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Node, _Alloc >

Binary search tree traits, primary template

▼C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >

C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc >

Specialization

▼C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >

C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc >

Specialization

C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc >

Specialization

▼C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >

C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc >

Specialization

▼C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >

C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc >

Specialization

▼Cstd::binary_function< _Arg1, _Arg2, _Result >

Cstd::equal_to< _Key >

Cstd::equal_to< _Value >

Cstd::less< typename _Sequence::value_type >

C__gnu_parallel::_Multiplies< _Tp1, _Tp2, _Result >

Similar to std::multiplies, but allows two different types

C__gnu_parallel::_Plus< _Tp1, _Tp2, _Result >

Similar to std::plus, but allows two different types

Cstd::pointer_to_binary_function< _Arg1, _Arg2, _Result >

One of the adaptors for function pointers

Cstd::binary_function< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool >

Cstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool >

Cstd::binary_function< _Arg1, _Arg2, _Arg1 >

Cstd::binary_function< _Arg1, _Arg2, _Arg2 >

Cstd::binary_function< _Key, _Key, bool >

▼Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool >

Cstd::binary_negate< _Predicate >

One of the negation functors

▼Cstd::binary_function< _T1, _T2, bool >

C__gnu_parallel::_EqualFromLess< _T1, _T2, _Compare >

Constructs predicate for equality from strict weak ordering predicate

C__gnu_parallel::_EqualTo< _T1, _T2 >

Similar to std::equal_to, but allows two different types

C__gnu_parallel::_Less< _T1, _T2 >

Similar to std::less, but allows two different types

C__gnu_parallel::_LexicographicReverse< _T1, _T2, _Compare >

Compare __a pair of types lexicographically, descending

▼Cstd::binary_function< _Tp *, _Arg, _Ret >

Cstd::mem_fun1_t< _Ret, _Tp, _Arg >

One of the adaptors for member pointers

Cstd::binary_function< _Tp *, _Tp *, bool >

▼Cstd::binary_function< _Tp, _Arg, _Ret >

Cstd::const_mem_fun1_ref_t< _Ret, _Tp, _Arg >

One of the adaptors for member pointers

Cstd::mem_fun1_ref_t< _Ret, _Tp, _Arg >

One of the adaptors for member pointers

▼Cstd::binary_function< _Tp, _Tp, _Tp >

Cstd::divides< _Tp >

One of the math functors

Cstd::minus< _Tp >

One of the math functors

Cstd::modulus< _Tp >

One of the math functors

Cstd::multiplies< _Tp >

One of the math functors

Cstd::plus< _Tp >

One of the math functors

▼Cstd::binary_function< _Tp, _Tp, bool >

Cstd::equal_to< _Tp >

One of the comparison functors

Cstd::greater< _Tp >

One of the comparison functors

Cstd::greater_equal< _Tp >

One of the comparison functors

Cstd::less< _Tp >

One of the comparison functors

Cstd::less_equal< _Tp >

One of the comparison functors

Cstd::logical_and< _Tp >

One of the Boolean operations functors

Cstd::logical_or< _Tp >

One of the Boolean operations functors

Cstd::not_equal_to< _Tp >

One of the comparison functors

Cstd::binary_function< _Tp1, _Tp2, __typeof__(*static_cast< _Tp1 * >(0) **static_cast< _Tp2 * >(0)) >

Cstd::binary_function< _Tp1, _Tp2, __typeof__(*static_cast< _Tp1 * >(0)+*static_cast< _Tp2 * >(0)) >

Cstd::binary_function< _Value, _Value, bool >

▼Cstd::binary_function< const _Tp *, _Arg, _Ret >

Cstd::const_mem_fun1_t< _Ret, _Tp, _Arg >

One of the adaptors for member pointers

Cstd::binary_function< rope< _CharT, _Alloc >, rope< _CharT, _Alloc >, rope< _CharT, _Alloc > >

Cstd::binary_function< shared_ptr< _Tp >, shared_ptr< _Tp >, bool >

▼Cstd::binary_function< std::pair< _T1, _T2 >, std::pair< _T1, _T2 >, bool >

C__gnu_parallel::_Lexicographic< _T1, _T2, _Compare >

Compare __a pair of types lexicographically, ascending

Cstd::binary_function< typename _Sequence::value_type, typename _Sequence::value_type, bool >

Cstd::binary_function< value_type, value_type, bool >

Cstd::binary_function< void, void, bool >

Cstd::binary_function< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >

▼C__gnu_pbds::detail::binary_heap_point_const_iterator_< Value_Type, Entry, Simple, _Alloc >

Const point-type iterator

C__gnu_pbds::detail::binary_heap_const_iterator_< Value_Type, Entry, Simple, _Alloc >

Const point-type iterator

Cstd::binomial_distribution< _IntType >

A discrete binomial random number distribution

Cstd::__debug::bitset< _Nb >

Class std::bitset with additional safety/checking/debug instrumentation

Cstd::tr2::bool_set

▼C__gnu_pbds::detail::branch_policy< Node_CItr, Node_Itr, _Alloc >

Primary template, base class for branch structure policies

▼C__gnu_pbds::detail::trie_policy_base< Node_CItr, Node_Itr, _ATraits, _Alloc >

Base class for trie policies

C__gnu_pbds::trie_order_statistics_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >

Functor updating ranks of entrees

C__gnu_pbds::trie_prefix_search_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >

A node updator that allows tries to be searched for the range of values that match a certain prefix

C__gnu_pbds::tree_order_statistics_node_update< Node_CItr, Node_Itr, Cmp_Fn, _Alloc >

Functor updating ranks of entrees

C__gnu_pbds::detail::branch_policy< Node_CItr, Node_CItr, _Alloc >

Specialization for const iterators

Cstd::cauchy_distribution< _RealType >

A cauchy_distribution random number distribution

C__gnu_pbds::cc_hash_max_collision_check_resize_trigger< External_Load_Access, Size_Type >

A resize trigger policy based on collision checks. It keeps the simulated load factor lower than some given load factor

▼C__gnu_cxx::char_traits< _CharT >

Base class used to implement std::char_traits

▼Cstd::char_traits< _CharT >

Basis for explicit traits specializations

C__gnu_cxx::encoding_char_traits< _CharT >

Encoding_char_traits

Cstd::char_traits< __gnu_cxx::character< _Value, _Int, _St > >

Char_traits<__gnu_cxx::character> specialization

Cstd::char_traits< char >

21.1.3.1 char_traits specializations

Cstd::char_traits< wchar_t >

21.1.3.2 char_traits specializations

C__gnu_cxx::character< _Value, _Int, _St >

A POD class that serves as a character abstraction class

Cstd::chi_squared_distribution< _RealType >

A chi_squared_distribution random number distribution

▼Cstd::codecvt_base

Empty base class for codecvt facet [22.2.1.5]

▼Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >

Cstd::codecvt< _InternT, _ExternT, encoding_state >

Codecvt<InternT, _ExternT, encoding_state> specialization

▼Cstd::__codecvt_abstract_base< char, char, mbstate_t >

Cstd::codecvt< char, char, mbstate_t >

Class codecvt<char, char, mbstate_t> specialization

▼Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t >

Cstd::codecvt< char16_t, char, mbstate_t >

Class codecvt<char16_t, char, mbstate_t> specialization

▼Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t >

Cstd::codecvt< char32_t, char, mbstate_t >

Class codecvt<char32_t, char, mbstate_t> specialization

▼Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >

Cstd::codecvt< wchar_t, char, mbstate_t >

Class codecvt<wchar_t, char, mbstate_t> specialization

Cstd::__codecvt_abstract_base< _Elem, char, mbstate_t >

▼Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >

Common base for codecvt functions

Cstd::codecvt< _Elem, char, mbstate_t >

▼Cstd::codecvt< _InternT, _ExternT, _StateT >

Primary class template codecvt

Cstd::codecvt_byname< _InternT, _ExternT, _StateT >

Class codecvt_byname [22.2.1.6]

Cstd::common_iterator< _It, _Sent >

An iterator/sentinel adaptor for representing a non-common range

Cstd::common_type< _Tp >

Common_type

Cstd::common_type< _Types... >

Cstd::common_type< chrono::duration< _Rep, _Period > >

Specialization of common_type for one chrono::duration type

Cstd::common_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > >

Specialization of common_type for two identical chrono::duration types

Cstd::common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > >

Cstd::common_type< chrono::time_point< _Clock, _Duration > >

Specialization of common_type for one chrono::time_point type

Cstd::common_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > >

Specialization of common_type for two identical chrono::time_point types

Cstd::common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > >

Cstd::compare_three_way_result< _Tp, _Up >

[cmp.result], result of three-way comparison

Cstd::complex< _Tp >

Cstd::complex< double >

26.2.3 complex specializations complex specialization

Cstd::complex< float >

26.2.3 complex specializations complex specialization

Cstd::complex< long double >

26.2.3 complex specializations complex specialization

C__gnu_pbds::detail::cond_dealtor< Entry, _Alloc >

Conditional deallocate constructor argument

C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >::cond_dtor< Size_Type >

Conditional destructor

▼C__gnu_cxx::condition_base

Base struct for condition policy

▼C__gnu_cxx::limit_condition

Base class for incremental control and throw

C__gnu_cxx::throw_allocator_base< _Tp, limit_condition >

▼C__gnu_cxx::throw_value_base< limit_condition >

C__gnu_cxx::throw_value_limit

Type throwing via limit condition

▼C__gnu_cxx::random_condition

Base class for random probability control and throw

C__gnu_cxx::throw_allocator_base< _Tp, random_condition >

▼C__gnu_cxx::throw_value_base< random_condition >

C__gnu_cxx::throw_value_random

Type throwing via random condition

Cstd::condition_variable

Condition_variable

Cstd::condition_variable_any

Condition_variable_any

Cstd::conditional< _Cond, _Iftrue, _Iffalse >

Define a member typedef type to one of two argument types

▼C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::const_iterator

Constant child iterator

C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::iterator

Child iterator

Cstd::chrono::tzdb_list::const_iterator

C__gnu_cxx::constant_binary_fun< _Result, _Arg1, _Arg2 >

An SGI extension

C__gnu_cxx::constant_unary_fun< _Result, _Argument >

An SGI extension

C__gnu_cxx::constant_void_fun< _Result >

An SGI extension

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, Tag, Policy_Tl >

Dispatch mechanism, primary template for associative types

C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type >

Specialization for binary_heap

C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type >

Specialization for binomial_heap

C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type >

Specialization for pairing_heap

C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type >

Specialization for rc_binary_heap

C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type >

Specialization for thin_heap

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl >

Specialization colision-chaining hash map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl >

Specialization general-probe hash map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl >

Specialization for list-update map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl >

Specialization ordered-vector tree map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl >

Specialization for PATRICIA trie map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl >

Specialization for R-B tree map

C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl >

Specialization splay tree map

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl >

Specialization colision-chaining hash set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl >

Specialization general-probe hash set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl >

Specialization for list-update set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl >

Specialization ordered-vector tree set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl >

Specialization for PATRICIA trie set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl >

Specialization for R-B tree set

C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl >

Specialization splay tree set

▼C__gnu_pbds::container_tag

Base data structure tag

▼C__gnu_pbds::associative_tag

Basic associative-container

▼C__gnu_pbds::basic_branch_tag

Basic branch structure

▼C__gnu_pbds::tree_tag

Basic tree structure

C__gnu_pbds::ov_tree_tag

Ordered-vector tree

C__gnu_pbds::rb_tree_tag

Red-black tree

C__gnu_pbds::splay_tree_tag

Splay tree

▼C__gnu_pbds::trie_tag

Basic trie structure

C__gnu_pbds::pat_trie_tag

PATRICIA trie

▼C__gnu_pbds::basic_hash_tag

Basic hash structure

C__gnu_pbds::cc_hash_tag

Collision-chaining hash

C__gnu_pbds::gp_hash_tag

General-probing hash

C__gnu_pbds::list_update_tag

List-update

▼C__gnu_pbds::priority_queue_tag

Basic priority-queue

C__gnu_pbds::binary_heap_tag

Binary-heap (array-based)

C__gnu_pbds::binomial_heap_tag

Binomial-heap

C__gnu_pbds::pairing_heap_tag

Pairing-heap

C__gnu_pbds::rc_binomial_heap_tag

Redundant-counter binomial-heap

C__gnu_pbds::thin_heap_tag

Thin heap

▼C__gnu_pbds::sequence_tag

Basic sequence

C__gnu_pbds::string_tag

Basic string container, inclusive of strings, ropes, etc

C__gnu_pbds::container_traits_base< _Tag >

Primary template, container traits base

C__gnu_pbds::container_traits_base< binary_heap_tag >

Specialization, binary heap

C__gnu_pbds::container_traits_base< binomial_heap_tag >

Specialization, binomial heap

C__gnu_pbds::container_traits_base< cc_hash_tag >

Specialization, cc hash

▼C__gnu_pbds::container_traits_base< Cntnr::container_category >

C__gnu_pbds::container_traits< Cntnr >

Container traits

C__gnu_pbds::container_traits_base< gp_hash_tag >

Specialization, gp hash

C__gnu_pbds::container_traits_base< list_update_tag >

Specialization, list update

C__gnu_pbds::container_traits_base< ov_tree_tag >

Specialization, ov tree

C__gnu_pbds::container_traits_base< pairing_heap_tag >

Specialization, pairing heap

C__gnu_pbds::container_traits_base< pat_trie_tag >

Specialization, pat trie

C__gnu_pbds::container_traits_base< rb_tree_tag >

Specialization, rb tree

C__gnu_pbds::container_traits_base< rc_binomial_heap_tag >

Specialization, rc binomial heap

C__gnu_pbds::container_traits_base< splay_tree_tag >

Specialization, splay tree

C__gnu_pbds::container_traits_base< thin_heap_tag >

Specialization, thin heap

Cstd::counted_iterator< _It >

An iterator adaptor that keeps track of the distance to the end

▼Cstd::ctype_base

Base class for ctype

▼Cstd::__ctype_abstract_base< wchar_t >

Cstd::ctype< wchar_t >

The ctype<wchar_t> specialization

▼Cstd::__ctype_abstract_base< _CharT >

Common base for ctype facet

▼Cstd::ctype< _CharT >

Primary class template ctype facet

Cstd::ctype_byname< _CharT >

Class ctype_byname [22.2.1.2]

▼Cstd::ctype< char >

The ctype specialization

Cstd::ctype_byname< char >

22.2.1.4 Class ctype_byname specializations

C__gnu_cxx::debug_allocator< _Alloc >

A meta-allocator with debugging bits

Cstd::decay< _Tp >

Decay

Cstd::decimal::decimal128

3.2.4 Class decimal128

Cstd::decimal::decimal32

3.2.2 Class decimal32

Cstd::decimal::decimal64

3.2.3 Class decimal64

Csimd_abi::deduce< _Tp, _Np,... >

C__gnu_pbds::detail::default_comb_hash_fn

Primary template, default_comb_hash_fn

Cstd::default_delete< _Tp >

Cstd::default_delete< _Tp[]>

C__gnu_pbds::detail::default_eq_fn< Key >

Primary template, default_eq_fn

C__gnu_pbds::detail::default_hash_fn< Key >

Primary template, default_hash_fn

C__gnu_pbds::detail::default_probe_fn< Comb_Probe_Fn >

Primary template, default_probe_fn

C__gnu_pbds::detail::default_resize_policy< Comb_Hash_Fn >

Primary template, default_resize_policy

Cstd::default_sentinel_t

C__gnu_pbds::detail::default_trie_access_traits< Key >

Primary template, default_trie_access_traits

C__gnu_pbds::detail::default_trie_access_traits< std::basic_string< Char, Char_Traits, std::allocator< char > > >

Partial specialization, default_trie_access_traits

C__gnu_pbds::detail::default_update_policy

Default update policy

Cstd::defer_lock_t

Do not acquire ownership of the mutex

Cstd::destroying_delete_t

Tag type used to declare a class-specific operator delete that can invoke the destructor before deallocating the memory

Cstd::tr2::direct_bases< _Tp >

Enumerate all the direct base classes of a class. Form of a typelist

Cstd::filesystem::directory_entry

The value type used by directory iterators

Cstd::filesystem::directory_iterator

Iterator type for traversing the entries in a single directory

Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >

Cstd::discrete_distribution< _IntType >

A discrete_distribution random number distribution

Cstd::divides< void >

One of the math functors

C__gnu_pbds::detail::dumnode_const_iterator< Key, Data, _Alloc >

Constant node iterator

Cstd::chrono::duration< _Rep, _Period >

chrono::duration represents a distance between two points in time

Cstd::chrono::duration< int64_t >

Cstd::chrono::duration< int64_t, ratio< 3600 > >

Cstd::chrono::duration< int64_t, ratio< 60 > >

Cstd::chrono::duration< std::ratio< 1 > >

Cstd::chrono::duration< std::ratio< 60 > >

Cstd::chrono::duration_values< _Rep >

Duration_values

Cstd::enable_if< bool, _Tp >

Define a member typedef type only if a boolean constant is true

Cstd::enable_shared_from_this< _Tp >

Base class allowing use of the member function shared_from_this

C__gnu_cxx::encoding_state

Extension to use iconv for dealing with character encodings

C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, No_Throw >

Entry compare, primary template

C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >

Specialization, false

C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, true >

Specialization, true

C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, No_Throw >

Entry predicate primary class template

C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, false >

Specialization, false

C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, true >

Specialization, true

C__gnu_pbds::detail::eq_by_less< Key, Cmp_Fn >

Equivalence function

Cstd::ranges::equal_to

Ranges::equal_to function object type

Cstd::equal_to< void >

One of the comparison functors

Cstd::error_category

Cstd::error_code

Cstd::error_condition

▼Cstd::exception

Base class for all library exceptions

C__gnu_cxx::forced_error

Thrown by utilities for testing exception safety

C__gnu_cxx::recursive_init_error

Exception thrown by __cxa_guard_acquire

Cstd::bad_alloc

Exception possibly thrown by new

▼Cstd::bad_cast

Thrown during incorrect typecasting

Cstd::experimental::fundamentals_v1::bad_any_cast

Exception class thrown by a failed any_cast

Cstd::bad_exception

Cstd::bad_function_call

Exception class thrown when class template function's operator() is called with an empty target

Cstd::bad_typeid

Thrown when a NULL pointer in a typeid expression is used

Cstd::bad_weak_ptr

Exception possibly thrown by shared_ptr

Cstd::ios_base::failure

These are thrown to indicate problems with io

▼Cstd::logic_error

One of two subclasses of exception

▼C__gnu_pbds::container_error

Base class for exceptions

C__gnu_pbds::insert_error

An entry cannot be inserted into a container object for logical reasons (not, e.g., if memory is unabvailable, in which case the allocator_type's exception will be thrown)

C__gnu_pbds::join_error

A join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps

C__gnu_pbds::resize_error

A container cannot be resized

Cstd::domain_error

Cstd::experimental::fundamentals_v1::bad_optional_access

Exception class thrown when a disengaged optional object is dereferenced

Cstd::future_error

Exception type thrown by futures

Cstd::invalid_argument

Cstd::length_error

Cstd::out_of_range

▼Cstd::runtime_error

One of two subclasses of exception

Cstd::overflow_error

Cstd::range_error

Cstd::regex_error

A regular expression exception class

▼Cstd::system_error

An exception type that includes an error_code value

Cstd::experimental::filesystem::v1::filesystem_error

Exception type thrown by the Filesystem TS library

Cstd::filesystem::filesystem_error

Exception type thrown by the Filesystem library

Cstd::underflow_error

Cstd::__unspecified__::exception_ptr

An opaque pointer to an arbitrary exception

Cstd::exponential_distribution< _RealType >

An exponential continuous distribution for random numbers

Cstd::extreme_value_distribution< _RealType >

A extreme_value_distribution random number distribution

▼Cstd::locale::facet

Localization functionality base class

Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >

Cstd::__codecvt_abstract_base< char, char, mbstate_t >

Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t >

Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t >

Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >

Cstd::__codecvt_abstract_base< _Elem, char, mbstate_t >

Cstd::__ctype_abstract_base< wchar_t >

Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >

Common base for codecvt functions

Cstd::__ctype_abstract_base< _CharT >

Common base for ctype facet

▼Cstd::collate< _CharT >

Facet for localized string comparison

Cstd::collate_byname< _CharT >

Class collate_byname [22.2.4.2]

Cstd::ctype< char >

The ctype specialization

▼Cstd::messages< _CharT >

Primary class template messages

Cstd::messages_byname< _CharT >

Class messages_byname [22.2.7.2]

Cstd::money_get< _CharT, _InIter >

Primary class template money_get

Cstd::money_put< _CharT, _OutIter >

Primary class template money_put

▼Cstd::moneypunct< _CharT, _Intl >

Primary class template moneypunct

Cstd::moneypunct_byname< _CharT, _Intl >

Class moneypunct_byname [22.2.6.4]

Cstd::num_get< _CharT, _InIter >

Primary class template num_get

Cstd::num_put< _CharT, _OutIter >

Primary class template num_put

▼Cstd::numpunct< _CharT >

Primary class template numpunct

Cstd::numpunct_byname< _CharT >

Class numpunct_byname [22.2.3.2]

▼Cstd::time_get< _CharT, _InIter >

Primary class template time_get

Cstd::time_get_byname< _CharT, _InIter >

Class time_get_byname [22.2.5.2]

▼Cstd::time_put< _CharT, _OutIter >

Primary class template time_put

Cstd::time_put_byname< _CharT, _OutIter >

Class time_put_byname [22.2.5.4]

Cstd::filesystem::file_status

Information about a file's type and permissions

▼C__gnu_parallel::find_tag

Base class for for std::find() variants

C__gnu_parallel::constant_size_blocks_tag

Selects the constant block size variant for std::find()

C__gnu_parallel::equal_split_tag

Selects the equal splitting variant for std::find()

C__gnu_parallel::growing_blocks_tag

Selects the growing block size variant for std::find()

Cstd::fisher_f_distribution< _RealType >

A fisher_f_distribution random number distribution

Cstd::fpos< _StateT >

Class representing stream positions

▼C__gnu_cxx::free_list

The free list class for managing chunks of memory to be given to and returned by the bitmap_allocator

C__gnu_cxx::bitmap_allocator< _Tp >

Bitmap Allocator, primary template

Cstd::from_chars_result

Result type of std::from_chars

Cstd::gamma_distribution< _RealType >

A gamma continuous distribution for random numbers

Cstd::gamma_distribution< double >

Cstd::gamma_distribution< result_type >

Cstd::geometric_distribution< _IntType >

A discrete geometric random number distribution

Cstd::chrono::gps_clock

Cstd::ranges::greater

Ranges::greater function object type

Cstd::greater< void >

One of the comparison functors

Cstd::ranges::greater_equal

Ranges::greater_equal function object type

Cstd::greater_equal< void >

One of the comparison functors

C__gnu_cxx::random_condition::group_adjustor

Group condition

Cstd::gslice

Class defining multi-dimensional subset of an array

Cstd::gslice_array< _Tp >

Reference to multi-dimensional subset of an array

Cstd::has_virtual_destructor< _Tp >

Has_virtual_destructor

Cstd::hash< _Tp >

Primary class template hash

Cstd::hash< __debug::bitset< _Nb > >

Std::hash specialization for bitset

Cstd::hash< __debug::vector< bool, _Alloc > >

Std::hash specialization for vector

Cstd::hash< __gnu_cxx::__u16vstring >

Std::hash specialization for __u16vstring

Cstd::hash< __gnu_cxx::__u32vstring >

Std::hash specialization for __u32vstring

Cstd::hash< __gnu_cxx::__vstring >

Std::hash specialization for __vstring

Cstd::hash< __gnu_cxx::__wvstring >

Std::hash specialization for __wvstring

Cstd::hash< __shared_ptr< _Tp, _Lp > >

Std::hash specialization for __shared_ptr

Cstd::hash< _Tp * >

Partial specializations for pointer types

Cstd::hash< basic_string< char, char_traits< char >, _Alloc > >

Std::hash specialization for string

Cstd::hash< basic_string< char16_t, char_traits< char16_t >, _Alloc > >

Std::hash specialization for u16string

Cstd::hash< basic_string< char32_t, char_traits< char32_t >, _Alloc > >

Std::hash specialization for u32string

Cstd::hash< basic_string< wchar_t, char_traits< wchar_t >, _Alloc > >

Std::hash specialization for wstring

Cstd::hash< bool >

Explicit specialization for bool

Cstd::hash< char >

Explicit specialization for char

Cstd::hash< char16_t >

Explicit specialization for char16_t

Cstd::hash< char32_t >

Explicit specialization for char32_t

Cstd::hash< double >

Specialization for double

Cstd::hash< error_code >

Std::hash specialization for error_code

Cstd::hash< error_condition >

Std::hash specialization for error_condition

Cstd::hash< experimental::optional< _Tp > >

Std::hash partial specialization for experimental::optional

Cstd::hash< experimental::shared_ptr< _Tp > >

Std::hash specialization for shared_ptr

Cstd::hash< float >

Specialization for float

Cstd::hash< int >

Explicit specialization for int

Cstd::hash< long >

Explicit specialization for long

Cstd::hash< long double >

Specialization for long double

Cstd::hash< long long >

Explicit specialization for long long

Cstd::hash< shared_ptr< _Tp > >

Std::hash specialization for shared_ptr

Cstd::hash< short >

Explicit specialization for short

Cstd::hash< signed char >

Explicit specialization for signed char

▼Cstd::hash< std::basic_string< _CharT > >

Cstd::hash< __gnu_debug::basic_string< _CharT > >

Std::hash specialization for __gnu_debug::basic_string

Cstd::hash< thread::id >

Std::hash specialization for thread::id

Cstd::hash< type_index >

Std::hash specialization for type_index

Cstd::hash< unique_ptr< _Tp, _Dp > >

Std::hash specialization for unique_ptr

Cstd::hash< unsigned char >

Explicit specialization for unsigned char

Cstd::hash< unsigned int >

Explicit specialization for unsigned int

Cstd::hash< unsigned long >

Explicit specialization for unsigned long

Cstd::hash< unsigned long long >

Explicit specialization for unsigned long long

Cstd::hash< unsigned short >

Explicit specialization for unsigned short

Cstd::hash< wchar_t >

Explicit specialization for wchar_t

Cstd::hash<::bitset< _Nb > >

Std::hash specialization for bitset

Cstd::hash<::vector< bool, _Alloc > >

Std::hash specialization for vector

▼C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, Store_Hash >

Primary template

C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >

C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >

C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, false >

Specialization 1 - The client requests that hash values not be stored

C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, true >

Specialization 2 - The client requests that hash values be stored

▼C__gnu_pbds::hash_exponential_size_policy< Size_Type >

A size policy whose sequence of sizes form an exponential sequence (typically powers of 2

C__gnu_pbds::hash_standard_resize_policy< Size_Policy, Trigger_Policy, External_Size_Access, Size_Type >

A resize policy which delegates operations to size and trigger policies

▼C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, Hold_Size >

Primary template

▼C__gnu_pbds::hash_load_check_resize_trigger< External_Load_Access, Size_Type >

A resize trigger policy based on a load check. It keeps the load factor between some load factors load_min and load_max

C__gnu_pbds::hash_standard_resize_policy< Size_Policy, Trigger_Policy, External_Size_Access, Size_Type >

A resize policy which delegates operations to size and trigger policies

C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, true >

Specializations

C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< std::size_t, false >

C__gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >

C__gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >

C__gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc >

C__gnu_pbds::hash_prime_size_policy

A size policy whose sequence of sizes form a nearly-exponential sequence of primes

C__gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc >

Cstd::chrono::hh_mm_ss< _Duration >

Cstd::locale::id

Facet ID class

Cstd::thread::id

Cstd::identity

[func.identity] The identity function

Cstd::experimental::fundamentals_v1::in_place_t

Tag type for in-place construction

Cstd::experimental::in_place_t

Tag type for in-place construction

Cstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >

Cstd::indirect_array< _Tp >

Reference to arbitrary subset of an array

Cstd::initializer_list< _E >

Initializer_list

▼Cstd::input_iterator_tag

Marking input iterators

▼Cstd::forward_iterator_tag

Forward iterators support a superset of input iterator operations

▼Cstd::bidirectional_iterator_tag

Bidirectional iterators support a superset of forward iterator operations

▼Cstd::random_access_iterator_tag

Random-access iterators support a superset of bidirectional iterator operations

Cstd::contiguous_iterator_tag

Contiguous iterators point to objects stored contiguously in memory

Cstd::integer_sequence< _Tp, _Idx >

Class template integer_sequence

Cstd::integral_constant< _Tp, __v >

Integral_constant

▼Cstd::integral_constant< bool, !ratio_equal< _R1, _R2 >::value >

Cstd::ratio_not_equal< _R1, _R2 >

Ratio_not_equal

▼Cstd::integral_constant< bool, !ratio_less< _R1, _R2 >::value >

Cstd::ratio_greater_equal< _R1, _R2 >

Ratio_greater_equal

▼Cstd::integral_constant< bool, !ratio_less< _R2, _R1 >::value >

Cstd::ratio_less_equal< _R1, _R2 >

Ratio_less_equal

▼Cstd::integral_constant< bool, _R1::num==_R2::num &&_R1::den==_R2::den >

Cstd::ratio_equal< _R1, _R2 >

Ratio_equal

▼Cstd::integral_constant< bool, ratio_less< _R2, _R1 >::value >

Cstd::ratio_greater< _R1, _R2 >

Ratio_greater

▼Cstd::integral_constant< int, 0 >

Cstd::is_placeholder< _Tp >

Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is

▼Cstd::integral_constant< int, _Num >

Cstd::is_placeholder< _Placeholder< _Num > >

▼Cstd::integral_constant< size_t, 0 >

Cstd::extent< typename, _Uint >

Extent

▼Cstd::integral_constant< size_t, 2 >

Cstd::tuple_size< pair< _Tp1, _Tp2 > >

Partial specialization for std::pair

▼Cstd::integral_constant< size_t, _Nm >

Cstd::tuple_size< array< _Tp, _Nm > >

Partial specialization for std::array

Cstd::integral_constant< size_t, _Size >

▼Cstd::integral_constant< size_t, sizeof...(_Elements)>

Cstd::tuple_size< tuple< _Elements... > >

Class tuple_size

▼Cstd::integral_constant< std::size_t, 0 >

Cstd::rank< typename >

Rank

Cstd::integral_constant< std::size_t, 1+rank< _Tp >::value >

▼Cstd::integral_constant< std::size_t, alignof(_Tp)>

Cstd::alignment_of< _Tp >

Alignment_of

Cstd::integral_constant< unsigned, 0 >

Cstd::integral_constant< unsigned, 1 >

Cstd::integral_constant< unsigned, _Val >

▼Cstd::ios_base

The base of the I/O class hierarchy

Cstd::basic_ios< char, _Traits >

▼Cstd::basic_ios< _CharT, _Traits >

Template class basic_ios, virtual base class for all stream classes

Cstd::basic_istream< char >

Cstd::basic_istream< char, _Traits >

Cstd::basic_ostream< char, _Traits >

Cstd::basic_ostream< char >

▼Cstd::basic_istream< _CharT, _Traits >

Template class basic_istream

Cstd::basic_iostream< char >

Cstd::basic_ifstream< _CharT, _Traits >

Controlling input for files

▼Cstd::basic_iostream< _CharT, _Traits >

Template class basic_iostream

Cstd::basic_fstream< _CharT, _Traits >

Controlling input and output for files

Cstd::basic_stringstream< _CharT, _Traits, _Alloc >

Controlling input and output for std::string

Cstd::basic_istringstream< _CharT, _Traits, _Alloc >

Controlling input for std::string

▼Cstd::basic_ostream< _CharT, _Traits >

Template class basic_ostream

Cstd::basic_iostream< char >

Cstd::basic_iostream< _CharT, _Traits >

Template class basic_iostream

Cstd::basic_ofstream< _CharT, _Traits >

Controlling output for files

Cstd::basic_ostringstream< _CharT, _Traits, _Alloc >

Controlling output for std::string

Cstd::is_abstract< _Tp >

Is_abstract

Cstd::is_arithmetic< _Tp >

Is_arithmetic

Cstd::is_array< typename >

Is_array

Cstd::is_assignable< _Tp, _Up >

Is_assignable

Cstd::is_base_of< _Base, _Derived >

Is_base_of

Cstd::is_base_of< random_access_iterator_tag, __iter_category_t< _It > >

Cstd::is_bind_expression< _Tp >

Trait that identifies a bind expression

Cstd::is_bind_expression< _Bind< _Signature > >

Class template _Bind is always a bind expression

Cstd::is_bind_expression< _Bind_result< _Result, _Signature > >

Class template _Bind_result is always a bind expression

Cstd::is_bind_expression< const _Bind< _Signature > >

Class template _Bind is always a bind expression

Cstd::is_bind_expression< const _Bind_result< _Result, _Signature > >

Class template _Bind_result is always a bind expression

Cstd::is_bind_expression< const volatile _Bind< _Signature > >

Class template _Bind is always a bind expression

Cstd::is_bind_expression< const volatile _Bind_result< _Result, _Signature > >

Class template _Bind_result is always a bind expression

Cstd::is_bind_expression< volatile _Bind< _Signature > >

Class template _Bind is always a bind expression

Cstd::is_bind_expression< volatile _Bind_result< _Result, _Signature > >

Class template _Bind_result is always a bind expression

Cstd::is_class< _Tp >

Is_class

Cstd::is_compound< _Tp >

Is_compound

Cstd::is_const< typename >

Is_const

Cstd::is_constructible< _Tp, _Args >

Is_constructible

Cstd::is_convertible< _From, _To >

Is_convertible

Cstd::is_copy_assignable< _Tp >

Is_copy_assignable

Cstd::is_copy_constructible< _Tp >

Is_copy_constructible

Cstd::is_default_constructible< _Tp >

Is_default_constructible

Cstd::is_destructible< _Tp >

Is_destructible

Cstd::is_empty< _Tp >

Is_empty

Cstd::is_enum< _Tp >

Is_enum

Cstd::is_error_code_enum< _Tp >

Is_error_code_enum

Cstd::is_error_code_enum< future_errc >

Specialization that allows future_errc to convert to error_code

Cstd::is_error_condition_enum< _Tp >

Is_error_condition_enum

Cstd::is_floating_point< _Tp >

Is_floating_point

▼Cstd::is_floating_point< _Rep >

Cstd::chrono::treat_as_floating_point< _Rep >

Cstd::is_function< _Tp >

Is_function

Cstd::is_fundamental< _Tp >

Is_fundamental

Cstd::is_integral< _Tp >

Is_integral

Cstd::is_layout_compatible< _Tp, _Up >

Cstd::is_literal_type< _Tp >

Cstd::is_lvalue_reference< typename >

Is_lvalue_reference

Cstd::is_member_function_pointer< _Tp >

Is_member_function_pointer

Cstd::is_member_pointer< _Tp >

Is_member_pointer

Cstd::is_move_assignable< _Tp >

Is_move_assignable

Cstd::is_move_constructible< _Tp >

Is_move_constructible

Cstd::is_nothrow_assignable< _Tp, _Up >

Is_nothrow_assignable

Cstd::is_nothrow_constructible< _Tp, _Args >

Is_nothrow_constructible

Cstd::is_nothrow_copy_assignable< _Tp >

Is_nothrow_copy_assignable

Cstd::is_nothrow_copy_constructible< _Tp >

Is_nothrow_copy_constructible

Cstd::is_nothrow_default_constructible< _Tp >

Is_nothrow_default_constructible

Cstd::is_nothrow_destructible< _Tp >

Is_nothrow_destructible

Cstd::is_nothrow_move_assignable< _Tp >

Is_nothrow_move_assignable

Cstd::is_nothrow_move_assignable< __debug::vector< _Tp, _Alloc > >

Cstd::is_nothrow_move_assignable<::vector< _Tp, _Alloc > >

Cstd::is_nothrow_move_constructible< _Tp >

Is_nothrow_move_constructible

Cstd::is_object< _Tp >

Is_object

Cstd::is_pod< _Tp >

Cstd::is_pointer< _Tp >

Is_pointer

Cstd::is_pointer_interconvertible_base_of< _Base, _Derived >

True if _Derived is standard-layout and has a base class of type _Base

Cstd::is_polymorphic< _Tp >

Is_polymorphic

Cstd::is_reference< _Tp >

Is_reference

Cstd::is_rvalue_reference< typename >

Is_rvalue_reference

Cstd::is_same< _Tp, _Up >

Is_same

Cstd::is_scalar< _Tp >

Is_scalar

Cstd::is_signed< _Tp >

Is_signed

Cstd::is_standard_layout< _Tp >

Is_standard_layout

Cstd::is_trivial< _Tp >

Is_trivial

Cstd::is_trivially_assignable< _Tp, _Up >

Is_trivially_assignable

Cstd::is_trivially_constructible< _Tp, _Args >

Is_trivially_constructible

Cstd::is_trivially_copy_assignable< _Tp >

Is_trivially_copy_assignable

Cstd::is_trivially_copy_constructible< _Tp >

Is_trivially_copy_constructible

Cstd::is_trivially_copyable< _Tp >

Is_trivially_copyable

Cstd::is_trivially_default_constructible< _Tp >

Is_trivially_default_constructible

Cstd::is_trivially_destructible< _Tp >

Is_trivially_destructible

Cstd::is_trivially_move_assignable< _Tp >

Is_trivially_move_assignable

Cstd::is_trivially_move_constructible< _Tp >

Is_trivially_move_constructible

Cstd::is_union< _Tp >

Is_union

Cstd::is_unsigned< _Tp >

Is_unsigned

Cstd::is_void< _Tp >

Is_void

Cstd::is_volatile< typename >

Is_volatile

Cstd::experimental::filesystem::v1::path::iterator

An iterator for the components of a path

Cstd::filesystem::path::iterator

An iterator for the components of a path

▼Cstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >

Common iterator class

Cstd::istream_iterator< _Tp, _CharT, _Traits, _Dist >

Provides input iterator semantics for streams

▼Cstd::iterator< input_iterator_tag, _CharT, _Traits::off_type, _CharT *, _CharT >

Cstd::istreambuf_iterator< _CharT, _Traits >

Provides input iterator semantics for streambufs

Cstd::iterator< input_iterator_tag, _Tp, ptrdiff_t, const _Tp *, const _Tp & >

▼Cstd::iterator< iterator_traits< _Iterator >::iterator_category, iterator_traits< _Iterator >::value_type, iterator_traits< _Iterator >::difference_type, iterator_traits< _Iterator >::pointer, iterator_traits< _Iterator >::reference >

Cstd::reverse_iterator< _Iterator >

▼Cstd::iterator< output_iterator_tag, void, void, void, void >

Cstd::back_insert_iterator< _Container >

Turns assignment into insertion

Cstd::front_insert_iterator< _Container >

Turns assignment into insertion

Cstd::insert_iterator< _Container >

Turns assignment into insertion

Cstd::ostream_iterator< _Tp, _CharT, _Traits >

Provides output iterator semantics for streams

Cstd::ostreambuf_iterator< _CharT, _Traits >

Provides output iterator semantics for streambufs

Cstd::raw_storage_iterator< _OutputIterator, _Tp >

Cstd::iterator< std::output_iterator_tag, void, void, void, void >

Cstd::iterator< std::random_access_iterator_tag, _CharT >

Cstd::iterator< std::random_access_iterator_tag, bool >

Cstd::iterator_traits< _Iterator >

Traits class for iterators

Cstd::iterator_traits< _It >

Cstd::iterator_traits< _Tp * >

Partial specialization for object pointer types

Cstd::iterator_traits< _Tp >

C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, Node_Metadata, _Alloc >

Base class for a basic heap

▼C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, _Alloc::size_type, _Alloc >

▼C__gnu_pbds::detail::binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >

Base class for binomial heap

C__gnu_pbds::detail::binomial_heap< Value_Type, Cmp_Fn, _Alloc >

C__gnu_pbds::detail::rc_binomial_heap< Value_Type, Cmp_Fn, _Alloc >

C__gnu_pbds::detail::thin_heap< Value_Type, Cmp_Fn, _Alloc >

▼C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, null_type, _Alloc >

C__gnu_pbds::detail::pairing_heap< Value_Type, Cmp_Fn, _Alloc >

C__gnu_pbds::detail::left_child_next_sibling_heap_node_< _Value, _Metadata, _Alloc >

Node

▼C__gnu_pbds::detail::left_child_next_sibling_heap_node_point_const_iterator_< Node, _Alloc >

Const point-type iterator

C__gnu_pbds::detail::left_child_next_sibling_heap_const_iterator_< Node, _Alloc >

Const point-type iterator

Cstd::ranges::less

Ranges::less function object type

Cstd::less< void >

One of the comparison functors

Cstd::ranges::less_equal

Ranges::less_equal function object type

Cstd::less_equal< void >

One of the comparison functors

C__gnu_cxx::limit_condition::limit_adjustor

Enter the nth condition

Cstd::linear_congruential_engine< _UIntType, __a, __c, __m >

A model of a linear congruential random number generator

C__gnu_pbds::linear_probe_fn< Size_Type >

A probe sequence policy using fixed increments

C__gnu_pbds::list_update< Key, Mapped, Eq_Fn, Update_Policy, _Alloc >

Cstd::locale

Container class for localization functionality

Cstd::lock_guard< _Mutex >

A simple scoped lock type

Cstd::logical_and< void >

One of the Boolean operations functors

Cstd::logical_not< void >

One of the Boolean operations functors

Cstd::logical_or< void >

One of the Boolean operations functors

Cstd::lognormal_distribution< _RealType >

A lognormal_distribution random number distribution

C__gnu_pbds::detail::lu_counter_metadata< Size_Type >

A list-update metadata type that moves elements to the front of the list based on the counter algorithm

C__gnu_pbds::detail::lu_counter_policy_base< Size_Type >

Base class for list-update counter policy

▼C__gnu_pbds::detail::lu_counter_policy_base< _Alloc::size_type >

C__gnu_pbds::lu_counter_policy< Max_Count, _Alloc >

C__gnu_pbds::lu_move_to_front_policy< _Alloc >

Cstd::make_signed< _Tp >

Make_signed

Cstd::make_unsigned< _Tp >

Make_unsigned

Cstd::make_unsigned< _DiffT >

C__gnu_cxx::malloc_allocator< _Tp >

An allocator that uses malloc

Cstd::map< _Key, _Tp, _Compare, _Alloc >

A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time

Cstd::mask_array< _Tp >

Reference to selected subset of an array

▼C__gnu_pbds::detail::mask_based_range_hashing< Size_Type >

Range hashing policy

C__gnu_pbds::direct_mask_range_hashing< Size_Type >

A mask range-hashing class (uses a bitmask)

C__gnu_pbds::detail::mask_based_range_hashing< std::size_t >

▼C__gnu_pbds::detail::maybe_null_type< Key, Mapped, _Alloc, Store_Hash >

Base class for conditionally defining a static data member

▼C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, false >

C__gnu_pbds::detail::lu_map< Key, Mapped, Eq_Fn, _Alloc, Update_Policy >

List-based (with updates) associative container. Skip to the lu, my darling

C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >

Ordered-vector tree associative-container

C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc >

PATRICIA trie

▼C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, Store_Hash >

Traits for abstract types

C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >

C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >

C__gnu_pbds::detail::maybe_null_type< Key, null_type, _Alloc, Store_Hash >

Specialization that defines a static data member of type null_type

▼Cstd::pmr::memory_resource

Class memory_resource

Cstd::pmr::monotonic_buffer_resource

A memory resource that allocates from a fixed-size buffer

Cstd::pmr::unsynchronized_pool_resource

A non-thread-safe memory resource that manages pools of fixed-size blocks

Cstd::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f >

Cstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >

▼Cstd::messages_base

Messages facet base class providing catalog typedef

Cstd::messages< _CharT >

Primary class template messages

Cstd::minus< void >

One of the math functors

▼C__gnu_pbds::detail::mod_based_range_hashing< Size_Type >

Mod based range hashing

C__gnu_pbds::direct_mod_range_hashing< Size_Type >

A mod range-hashing class (uses the modulo function)

C__gnu_pbds::detail::mod_based_range_hashing< std::size_t >

Cstd::modulus< void >

One of the math functors

▼Cstd::money_base

Money format ordering data

Cstd::moneypunct< _CharT, _Intl >

Primary class template moneypunct

Cstd::move_iterator< _Iterator >

Cstd::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>

Polymorphic function wrapper

Cstd::multimap< _Key, _Tp, _Compare, _Alloc >

A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time

Cstd::multiplies< void >

One of the math functors

Cstd::multiset< _Key, _Compare, _Alloc >

A standard container made up of elements, which can be retrieved in logarithmic time

Cstd::mutex

Cstd::negate< void >

One of the math functors

Cstd::negative_binomial_distribution< _IntType >

A negative_binomial_distribution random number distribution

Cstd::nested_exception

C__gnu_cxx::limit_condition::never_adjustor

Never enter the condition

C__gnu_cxx::random_condition::never_adjustor

Never enter the condition

C__gnu_pbds::detail::no_throw_copies< Key, Mapped >

Primary template

C__gnu_pbds::detail::no_throw_copies< Key, null_type >

Specialization

Cstd::normal_distribution< _RealType >

A normal continuous distribution for random numbers

Cstd::normal_distribution< double >

Cstd::normal_distribution< result_type >

Cstd::nostopstate_t

Tag type indicating a stop_source should have no shared-stop-state

Cstd::ranges::not_equal_to

Ranges::not_equal_to function object type

Cstd::not_equal_to< void >

One of the comparison functors

▼C__gnu_pbds::null_type

Represents no type, or absence of type, for template tricks

C__gnu_pbds::null_node_update< _Tp1, _Tp2, _Tp3, _Tp4 >

A null node updator, indicating that no node updates are required

Cstd::experimental::fundamentals_v1::nullopt_t

Tag type to disengage optional objects

Cstd::experimental::nullopt_t

Tag type to disengage optional objects

Cstd::numeric_limits< bool >

Numeric_limits specialization

Cstd::numeric_limits< char >

Numeric_limits specialization

Cstd::numeric_limits< char16_t >

Numeric_limits<char16_t> specialization

Cstd::numeric_limits< char32_t >

Numeric_limits<char32_t> specialization

Cstd::numeric_limits< double >

Numeric_limits specialization

Cstd::numeric_limits< float >

Numeric_limits specialization

Cstd::numeric_limits< int >

Numeric_limits specialization

Cstd::numeric_limits< long >

Numeric_limits specialization

Cstd::numeric_limits< long double >

Numeric_limits specialization

Cstd::numeric_limits< long long >

Numeric_limits specialization

Cstd::numeric_limits< short >

Numeric_limits specialization

Cstd::numeric_limits< signed char >

Numeric_limits specialization

Cstd::numeric_limits< unsigned char >

Numeric_limits specialization

Cstd::numeric_limits< unsigned int >

Numeric_limits specialization

Cstd::numeric_limits< unsigned long >

Numeric_limits specialization

Cstd::numeric_limits< unsigned long long >

Numeric_limits specialization

Cstd::numeric_limits< unsigned short >

Numeric_limits specialization

Cstd::numeric_limits< wchar_t >

Numeric_limits<wchar_t> specialization

Cstd::once_flag

Flag type used by std::call_once

Cstd::experimental::fundamentals_v1::optional< _Tp >

Class template for optional values

Cstd::experimental::optional< _Tp >

Class template for optional values

Cstd::experimental::fundamentals_v2::ostream_joiner< _DelimT, _CharT, _Traits >

Output iterator that inserts a delimiter between elements

Cstd::experimental::ostream_joiner< _DelimT, _CharT, _Traits >

Output iterator that inserts a delimiter between elements

Cstd::output_iterator_tag

Marking output iterators

▼C__gnu_pbds::detail::ov_tree_node_const_it_< Value_Type, Metadata_Type, _Alloc >

Const node reference

C__gnu_pbds::detail::ov_tree_node_it_< Value_Type, Metadata_Type, _Alloc >

Node reference

Cstd::owner_less< _Tp >

Primary template owner_less

Cstd::packaged_task< _Res(_ArgTypes...)>

Packaged_task

Cstd::pair< _T1, _T2 >

Struct holding two objects of arbitrary type

▼Cstd::pair< _Iterator1, _Iterator2 >

C__gnu_parallel::_IteratorPair< _Iterator1, _Iterator2, _IteratorCategory >

A pair of iterators. The usual iterator operations are applied to both child iterators

Cstd::pair< _RAIter, _RAIter >

Cstd::pair< char, _TokenT >

Cstd::pair< char, char >

▼C__gnu_parallel::parallel_tag

Recommends parallel execution at compile time, optionally using a user-specified number of threads

C__gnu_parallel::balanced_quicksort_tag

Forces parallel sorting using balanced quicksort at compile time

C__gnu_parallel::balanced_tag

Recommends parallel execution using dynamic load-balancing at compile time

C__gnu_parallel::default_parallel_tag

Recommends parallel execution using the default parallel algorithm

C__gnu_parallel::exact_tag

Forces parallel merging with exact splitting, at compile time

C__gnu_parallel::multiway_mergesort_exact_tag

Forces parallel sorting using multiway mergesort with exact splitting at compile time

C__gnu_parallel::multiway_mergesort_sampling_tag

Forces parallel sorting using multiway mergesort with splitting by sampling at compile time

C__gnu_parallel::multiway_mergesort_tag

Forces parallel sorting using multiway mergesort at compile time

C__gnu_parallel::omp_loop_static_tag

Recommends parallel execution using OpenMP static load-balancing at compile time

C__gnu_parallel::omp_loop_tag

Recommends parallel execution using OpenMP dynamic load-balancing at compile time

C__gnu_parallel::quicksort_tag

Forces parallel sorting using unbalanced quicksort at compile time

C__gnu_parallel::sampling_tag

Forces parallel merging with exact splitting, at compile time

C__gnu_parallel::unbalanced_tag

Recommends parallel execution using static load-balancing at compile time

Cstd::bernoulli_distribution::param_type

Cstd::binomial_distribution< _IntType >::param_type

Cstd::cauchy_distribution< _RealType >::param_type

Cstd::chi_squared_distribution< _RealType >::param_type

Cstd::discrete_distribution< _IntType >::param_type

Cstd::exponential_distribution< _RealType >::param_type

Cstd::extreme_value_distribution< _RealType >::param_type

Cstd::fisher_f_distribution< _RealType >::param_type

Cstd::gamma_distribution< _RealType >::param_type

Cstd::geometric_distribution< _IntType >::param_type

Cstd::lognormal_distribution< _RealType >::param_type

Cstd::negative_binomial_distribution< _IntType >::param_type

Cstd::normal_distribution< _RealType >::param_type

Cstd::piecewise_constant_distribution< _RealType >::param_type

Cstd::piecewise_linear_distribution< _RealType >::param_type

Cstd::poisson_distribution< _IntType >::param_type

Cstd::student_t_distribution< _RealType >::param_type

Cstd::uniform_int_distribution< _IntType >::param_type

Cstd::uniform_real_distribution< _RealType >::param_type

Cstd::weibull_distribution< _RealType >::param_type

▼C__gnu_pbds::detail::pat_trie_base

Base type for PATRICIA trees

C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc >

PATRICIA trie

Cstd::experimental::filesystem::path

A filesystem path

Cstd::experimental::filesystem::v1::path

A filesystem path

Cstd::filesystem::path

A filesystem path

Cstd::piecewise_constant_distribution< _RealType >

A piecewise_constant_distribution random number distribution

Cstd::piecewise_construct_t

Tag type for piecewise construction of std::pair objects

Cstd::piecewise_linear_distribution< _RealType >

A piecewise_linear_distribution random number distribution

Cstd::pointer_traits< _Ptr >

Uniform interface to all pointer-like types

Cstd::pointer_traits< _Tp * >

Partial specialization for built-in pointers

Cstd::poisson_distribution< _IntType >

A discrete Poisson random number distribution

Cstd::pmr::polymorphic_allocator< _Tp >

Class template polymorphic_allocator

Cstd::pmr::pool_options

Parameters for tuning a pool resource's behaviour

C__gnu_pbds::priority_queue< _Tv, Cmp_Fn, Tag, _Alloc >

Cstd::priority_queue< _Tp, _Sequence, _Compare >

A standard container automatically sorting its contents

C__gnu_pbds::detail::probe_fn_base< _Alloc >

Probe functor base

Cstd::promise< _Res >

Primary template for promise

Cstd::promise< _Res & >

Partial specialization for promise<R&>

Cstd::promise< void >

Explicit specialization for promise

Cstd::experimental::fundamentals_v2::propagate_const< _Tp >

Const-propagating wrapper

Cstd::experimental::propagate_const< _Tp >

Const-propagating wrapper

C__gnu_pbds::quadratic_probe_fn< Size_Type >

A probe sequence policy using square increments

Cstd::queue< _Tp, _Sequence >

A standard container giving FIFO behavior

Cstd::random_device

▼C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, Store_Hash >

Primary template

C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >

C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false >

C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true >

C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false >

C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true >

▼C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash >

Primary template

C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >

C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false >

C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true >

C__gnu_pbds::detail::ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false >

Cstd::ratio< _Num, _Den >

Provides compile-time rational arithmetic

Cstd::ratio< 1 >

Cstd::ratio< 60 >

Cstd::ratio_less< _R1, _R2 >

Ratio_less

C__gnu_cxx::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc >

C__gnu_pbds::detail::rb_tree_node_< Value_Type, Metadata, _Alloc >

Node for Red-Black trees

C__gnu_pbds::detail::rc< _Node, _Alloc >

Redundant binary counter

C__gnu_pbds::detail::rc< typename binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >::node, _Alloc >

C__gnu_pbds::detail::rebind_traits< _Alloc, T >

Consistent API for accessing allocator-related types

C__gnu_pbds::detail::rebind_traits< _Alloc, _Node_base >

C__gnu_pbds::detail::rebind_traits< _Alloc, entry >

C__gnu_pbds::detail::rebind_traits< _Alloc, Entry >

C__gnu_pbds::detail::rebind_traits< _Alloc, Metadata_Type >

C__gnu_pbds::detail::rebind_traits< _Alloc, node >

C__gnu_pbds::detail::rebind_traits< _Alloc, Node >

C__gnu_pbds::detail::rebind_traits< _Alloc, rb_tree_node_ >

C__gnu_pbds::detail::rebind_traits< _Alloc, splay_tree_node_ >

C__gnu_pbds::detail::rebind_traits< _Alloc, this_type >

C__gnu_pbds::detail::rebind_traits< _Alloc, Value_Type >

Cstd::filesystem::recursive_directory_iterator

Iterator type for recursively traversing a directory hierarchy

Cstd::recursive_mutex

Cstd::recursive_timed_mutex

Cstd::bitset< _Nb >::reference

Cstd::tr2::dynamic_bitset< _WordT, _Alloc >::reference

Cstd::reference_wrapper< _Tp >

Primary class template for reference_wrapper

Cstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >

Cstd::regex_iterator< _Bi_iter, typename iterator_traits< _Bi_iter >::value_type, regex_traits< typename iterator_traits< _Bi_iter >::value_type > >

Cstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >

Cstd::regex_traits< _Ch_type >

Describes aspects of a regular expression

Cstd::regex_traits< _CharType >

Cstd::remove_all_extents< _Tp >

Remove_all_extents

Cstd::remove_const< _Tp >

Remove_const

Cstd::remove_cv< _Tp >

Remove_cv

Cstd::remove_extent< _Tp >

Remove_extent

Cstd::remove_reference< _Tp >

Remove_reference

Cstd::remove_volatile< _Tp >

Remove_volatile

C__gnu_pbds::detail::resize_policy< _Tp >

Resize policy for binary heap

▼C__gnu_pbds::detail::resize_policy< _Alloc::size_type >

C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >

Cstd::result_of< _Signature >

Result_of

C__gnu_cxx::rope< _CharT, _Alloc >

C__gnu_pbds::sample_probe_fn

A sample probe policy

C__gnu_pbds::sample_range_hashing

A sample range-hashing functor

C__gnu_pbds::sample_ranged_hash_fn

A sample ranged-hash functor

C__gnu_pbds::sample_ranged_probe_fn

A sample ranged-probe functor

C__gnu_pbds::sample_resize_policy

A sample resize policy

C__gnu_pbds::sample_resize_trigger

A sample resize trigger policy

C__gnu_pbds::sample_size_policy

A sample size policy

C__gnu_pbds::sample_tree_node_update< Const_Node_Iter, Node_Iter, Cmp_Fn, _Alloc >

A sample node updator

C__gnu_pbds::sample_trie_access_traits

A sample trie element access traits

C__gnu_pbds::sample_trie_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >

A sample node updator

C__gnu_pbds::sample_update_policy

A sample list-update policy

Cstd::scoped_allocator_adaptor< _OuterAlloc, _InnerAllocs >

An adaptor to recursively pass an allocator to the objects it constructs

Cstd::seed_seq

Generates sequences of seeds for random number generators

C__gnu_pbds::detail::select_value_type< Key, Mapped >

Choose value_type to be a key/value pair or just a key

C__gnu_pbds::detail::select_value_type< Key, null_type >

Specialization for sets where the key is the value_type

Cstd::basic_istream< _CharT, _Traits >::sentry

Performs setup work for input streams

Cstd::basic_ostream< _CharT, _Traits >::sentry

Performs setup work for output streams

C__gnu_parallel::sequential_tag

Forces sequential execution at compile time

Cstd::set< _Key, _Compare, _Alloc >

A standard container made up of unique keys, which can be retrieved in logarithmic time

Cstd::shared_lock< _Mutex >

Shared_lock

Cstd::shared_ptr< _Tp >

A smart pointer with reference-counted copy semantics

Cstd::shared_ptr< _Dir >

Cstd::shared_ptr< _Dir_stack >

Cstd::shared_ptr< _Node >

Cstd::shared_ptr< _RegexT >

Cstd::shared_ptr< _State >

Cstd::shared_ptr< _State_base >

Cstd::shared_ptr< _State_type >

Cstd::shared_ptr< const __detail::_NFA< regex_traits< _Ch_type > > >

Cstd::shared_ptr< std::mutex >

Cstd::shared_timed_mutex

The standard shared timed mutex type

Cstd::shuffle_order_engine< _RandomNumberEngine, __k >

Produces random numbers by reordering random numbers from some base engine

Cstd::slice

Class defining one-dimensional subset of an array

Cstd::slice_array< _Tp >

Reference to one-dimensional subset of an array

C__gnu_cxx::slist< _Tp, _Alloc >

Cstd::experimental::filesystem::space_info

Information about free space on a disk

Cstd::experimental::filesystem::v1::space_info

Information about free space on a disk

Cstd::filesystem::space_info

Information about free space on a disk

C__gnu_pbds::detail::splay_tree_node_< Value_Type, Metadata, _Alloc >

Node for splay tree

Cstd::stack< _Tp, _Sequence >

A standard container giving FILO behavior

Cstd::stack< _StateSeqT >

Cstd::chrono::steady_clock

Monotonic clock

Cstd::stop_callback< _Callback >

A wrapper for callbacks to be run when a stop request is made

Cstd::stop_source

A type that allows a stop request to be made

Cstd::stop_token

Allow testing whether a stop request has been made on a stop_source

▼C__gnu_pbds::detail::stored_hash< _Th >

Stored hash

C__gnu_pbds::detail::stored_data< _Tv, _Th, Store_Hash >

Primary template for representation of stored data. Two types of data can be stored: value and hash

▼C__gnu_pbds::detail::stored_value< _Tv >

Stored value

C__gnu_pbds::detail::stored_data< _Tv, _Th, Store_Hash >

Primary template for representation of stored data. Two types of data can be stored: value and hash

C__gnu_pbds::detail::stored_data< _Tv, _Th, false >

Specialization for representation of stored data of just value type

Cstd::student_t_distribution< _RealType >

A student_t_distribution random number distribution

Cstd::sub_match< _BiIter >

Cstd::sub_match< _Bi_iter >

Cstd::subtract_with_carry_engine< _UIntType, __w, __s, __r >

The Marsaglia-Zaman generator

C__gnu_pbds::detail::synth_access_traits< Type_Traits, Set, _ATraits >

Synthetic element access traits

Cstd::chrono::system_clock

System clock

Cstd::chrono::tai_clock

Cstd::thread

C__gnu_cxx::throw_value_base< _Cond >

Class with exception generation control. Intended to be used as a value_type in templatized code

▼Cstd::time_base

Time format ordering data

Cstd::time_get< _CharT, _InIter >

Primary class template time_get

Cstd::chrono::time_point< _Clock, _Dur >

chrono::time_point represents a point in time as measured by a clock

Cstd::chrono::time_point< duration >

Cstd::chrono::time_point< seconds >

Cstd::timed_mutex

Cstd::to_chars_result

Result type of std::to_chars

C__gnu_pbds::detail::tree_metadata_helper< Node_Update, _BTp >

Tree metadata helper

C__gnu_pbds::detail::tree_metadata_helper< Node_Update, false >

Specialization, false

C__gnu_pbds::detail::tree_metadata_helper< Node_Update, true >

Specialization, true

C__gnu_pbds::detail::tree_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >

Tree node metadata dispatch

C__gnu_pbds::detail::tree_traits< Key, Data, Cmp_Fn, Node_Update, Tag, _Alloc >

Tree traits class, primary template

C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >

Tree traits

C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >

Specialization

C__gnu_pbds::detail::trie_metadata_helper< Node_Update, _BTp >

Trie metadata helper

C__gnu_pbds::detail::trie_metadata_helper< Node_Update, false >

Specialization, false

C__gnu_pbds::detail::trie_metadata_helper< Node_Update, true >

Specialization, true

C__gnu_pbds::detail::trie_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >

Trie node metadata dispatch

C__gnu_pbds::trie_string_access_traits< String, Min_E_Val, Max_E_Val, Reverse, _Alloc >

C__gnu_pbds::detail::trie_traits< Key, Data, _ATraits, Node_Update, Tag, _Alloc >

Trie traits class, primary template

C__gnu_pbds::detail::trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc >

Specialization

C__gnu_pbds::detail::trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc >

Specialization

C__gnu_pbds::trivial_iterator_tag

A trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities

Cstd::try_to_lock_t

Try to acquire ownership of the mutex without blocking

Cstd::tuple< _Elements >

Primary class template, tuple

Cstd::tuple< _Bound_args... >

Cstd::tuple< _ForwardIterator1, _ForwardIterator1, equal_to<> >

Cstd::tuple< _T1, _T2 >

Partial specialization, 2-element tuple. Includes construction and assignment from a pair

Cstd::tuple< std::array< _Tp, _Len >, _Pred >

Cstd::tuple_element< __i, _Tp >

Gives the type of the ith element of a given tuple type

Cstd::tuple_element< 0, pair< _Tp1, _Tp2 > >

Partial specialization for std::pair

Cstd::tuple_element< 1, pair< _Tp1, _Tp2 > >

Partial specialization for std::pair

Cstd::tuple_element< __i, tuple< _Types... > >

Trait to get the Ith element type from a tuple

Cstd::tuple_element< _Ind, array< _Tp, _Nm > >

Partial specialization for std::array

Cstd::tuple_size< _Tp >

Finds the size of a given tuple type

C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >::type

Compare plus entry

Cstd::type_index

Class type_index

Cstd::type_info

Part of RTTI

Cstd::chrono::tzdb_list

▼Cstd::unary_function< _Arg, _Result >

Cstd::pointer_to_unary_function< _Arg, _Result >

One of the adaptors for function pointers

▼Cstd::unary_function< __gnu_cxx::throw_value_limit, size_t >

Cstd::hash< __gnu_cxx::throw_value_limit >

Explicit specialization of std::hash for __gnu_cxx::throw_value_limit

▼Cstd::unary_function< __gnu_cxx::throw_value_random, size_t >

Cstd::hash< __gnu_cxx::throw_value_random >

Explicit specialization of std::hash for __gnu_cxx::throw_value_random

▼Cstd::unary_function< _FirstArgumentType, _ResultType >

C__gnu_parallel::__binder2nd< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >

Similar to std::binder2nd, but giving the argument types explicitly

▼Cstd::unary_function< _Operation2::argument_type, _Operation1::result_type >

C__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 >

An SGI extension

C__gnu_cxx::unary_compose< _Operation1, _Operation2 >

An SGI extension

▼Cstd::unary_function< _Operation::first_argument_type, _Operation::result_type >

Cstd::binder2nd< _Operation >

One of the binder functors

▼Cstd::unary_function< _Operation::second_argument_type, _Operation::result_type >

Cstd::binder1st< _Operation >

One of the binder functors

Cstd::unary_function< _Pair, _Pair::first_type >

Cstd::unary_function< _Pair, _Pair::second_type >

▼Cstd::unary_function< _Predicate::argument_type, bool >

Cstd::unary_negate< _Predicate >

One of the negation functors

▼Cstd::unary_function< _SecondArgumentType, _ResultType >

C__gnu_parallel::__binder1st< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >

Similar to std::binder1st, but giving the argument types explicitly

▼Cstd::unary_function< _Tp *, _Ret >

Cstd::mem_fun_t< _Ret, _Tp >

One of the adaptors for member pointers

▼Cstd::unary_function< _Tp, _Ret >

Cstd::const_mem_fun_ref_t< _Ret, _Tp >

One of the adaptors for member pointers

Cstd::mem_fun_ref_t< _Ret, _Tp >

One of the adaptors for member pointers

▼Cstd::unary_function< _Tp, _Tp >

Cstd::negate< _Tp >

One of the math functors

▼Cstd::unary_function< _Tp, bool >

Cstd::logical_not< _Tp >

One of the Boolean operations functors

Cstd::unary_function< _Value, _Value >

▼Cstd::unary_function< argument_type, bool >

C__gnu_parallel::__unary_negate< _Predicate, argument_type >

Similar to std::unary_negate, but giving the argument types explicitly

▼Cstd::unary_function< const _Tp *, _Ret >

Cstd::const_mem_fun_t< _Ret, _Tp >

One of the adaptors for member pointers

Cstd::unary_function< pair< const _Key, _Tp >, _Pair::first_type >

▼Cstd::unary_function< unsigned int, unsigned int >

C__gnu_cxx::subtractive_rng

Cstd::underlying_type< _Tp >

The underlying type of an enum

Cstd::uniform_int_distribution< _IntType >

Uniform discrete distribution for random numbers. A discrete random distribution on the range with equal probability throughout the range

Cstd::uniform_real_distribution< _RealType >

Uniform continuous distribution for random numbers

Cstd::unique_lock< _Mutex >

A movable scoped lock type

Cstd::unique_ptr< _Tp, _Dp >

A move-only smart pointer that manages unique ownership of a resource

Cstd::unique_ptr< _Impl >

Cstd::unique_ptr< _Impl, _Impl_deleter >

Cstd::unique_ptr< _Tp[], _Dp >

A move-only smart pointer that manages unique ownership of an array

Cstd::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >

A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys

Cstd::unordered_map< _Key, _Tp, _Hash, _Pred >

Cstd::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >

A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys

Cstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >

A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves

Cstd::unordered_set< _Value, _Hash, _Pred, _Alloc >

A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves

Cstd::uses_allocator< typename, typename >

Declare uses_allocator so it can be specialized in <queue> etc

Cstd::uses_allocator< tuple< _Types... >, _Alloc >

Partial specialization for tuples

Cstd::chrono::utc_clock

Cstd::valarray< _Tp >

Smart array designed to support numeric processing

Cstd::valarray< size_t >

Cstd::vector< bool, _Alloc >

A specialization of vector for booleans which offers fixed time access to individual elements in any order

▼Cstd::ranges::view_interface< _Derived >

The ranges::view_interface class template

Cstd::ranges::subrange< _It, _Sent, _Kind >

The ranges::subrange class template

Cstd::ranges::view_interface< _Grapheme_cluster_view< _View > >

Cstd::ranges::view_interface< _Utf_view< _ToFormat, _Range > >

Cstd::ranges::view_interface< subrange< _It, _It, sized_sentinel_for< _It, _It > ? subrange_kind::sized :subrange_kind::unsized > >

Cstd::weak_ptr< _Tp >

A non-owning observer for a pointer owned by a shared_ptr

Cstd::weibull_distribution< _RealType >

A weibull_distribution random number distribution

Cstd::wstring_convert< _Codecvt, _Elem, _Wide_alloc, _Byte_alloc >

String conversions