Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Nchrono
C_Duration_div_mod
C_Duration_div_mod1
C_Duration_div_mod1< _CR, _Period1, _Rep2, false >
C_Duration_div_mod< _Rep1, _Period1, _Rep2, false >
C_Is_duration
C_Is_duration< duration< _Rep, _Period > >
C_Is_ratio
C_Is_ratio< ratio< _R1, _R2 > >
Cduration
Cduration_values
Csteady_clock
Csystem_clock
Ctime_point
Ctreat_as_floating_point
►Ncliext
►Nimpl
C_Get_sizeof
C_Get_sizeof< _Value_t^>
Cdeque_base
Cdeque_impl
Cdeque_select
Cdeque_select< _Value_t, true >
Chash
Chash_map_base
Chash_map_base0
Chash_map_select
Chash_map_select< _Key1_t, _Mapped_t, false, true >
Chash_map_select< _Key1_t, _Mapped_t, true, false >
Chash_map_select< _Key1_t, _Mapped_t, true, true >
Chash_map_traits
Chash_multimap_base
Chash_multimap_base0
Chash_multimap_select
Chash_multimap_select< _Key1_t, _Mapped_t, false, true >
Chash_multimap_select< _Key1_t, _Mapped_t, true, false >
Chash_multimap_select< _Key1_t, _Mapped_t, true, true >
Chash_multiset_base
Chash_multiset_select
Chash_multiset_select< _Key1_t, true >
Chash_set_base
Chash_set_select
Chash_set_select< _Key1_t, true >
Chash_set_traits
CHashKVPEnumerator
Clist_base
Clist_impl
Clist_node
Clist_select
Clist_select< _Value_t, true >
Cmap_base
Cmap_base0
Cmap_select
Cmap_select< _Key1_t, _Mapped_t, false, true >
Cmap_select< _Key1_t, _Mapped_t, true, false >
Cmap_select< _Key1_t, _Mapped_t, true, true >
Cmap_traits
Cmultimap_base
Cmultimap_base0
Cmultimap_select
Cmultimap_select< _Key1_t, _Mapped_t, false, true >
Cmultimap_select< _Key1_t, _Mapped_t, true, false >
Cmultimap_select< _Key1_t, _Mapped_t, true, true >
Cmultiset_base
Cmultiset_select
Cmultiset_select< _Key1_t, true >
Cpriority_queue_base
Cpriority_queue_select
Cpriority_queue_select< _Value_t, _Cont_t, true >
Cqueue_base
Cqueue_select
Cqueue_select< _Value_t, _Cont_t, true >
Crange_base
Crange_enumerator
Crange_enumerator_base
Crange_impl
Crange_select
Crange_select< _Iter_t, _Value_t, true >
Cset_base
Cset_select
Cset_select< _Key1_t, true >
Cset_traits
Cstack_base
Cstack_select
Cstack_select< _Value_t, _Cont_t, true >
Ctree
Ctree_node
CTreeKVPEnumerator
Cvector_base
Cvector_impl
Cvector_select
Cvector_select< _Value_t, true >
C_Binary_fun
C_Binary_fun_noreturn
C_Cont_make_value
C_Cont_make_value< _Value_t, true >
C_Container_traits
C_Container_traits< _Cont_t^>
C_Dehandle
C_Dehandle< _Value_t^>
C_Fix_handle
C_Fix_handle< _To_t, _From_t^>
C_Fix_handle< _To_t^, _From_t >
C_Fix_handle< _To_t^, _From_t^>
C_Generic_type
C_Generic_type< _Value_t, false >
C_Generic_type< _Value_t, true >
C_Int_iterator_tag
C_ISort
C_Map_iter_cat
C_Map_iter_cat< std::bidirectional_iterator_tag >
C_Map_iter_cat< std::forward_iterator_tag >
C_Map_iter_cat< std::input_iterator_tag >
C_Map_iter_cat< std::output_iterator_tag >
C_Map_iter_cat< std::random_access_iterator_tag >
C_Pick_pair
C_Pick_pair< false, _Value1_t, _Value2_t >
C_Pick_pair< true, _Value1_t, _Value2_t >
C_Pick_tbuf
C_Pick_tbuf< false, _Value_t >
C_Pick_tbuf< true, _Value_t >
C_Temp_gc_iterator
►C_Temp_iterator
C_Bufpar
C_Unary_fun
C_Unary_fun_noreturn
CArrayContainer
CBCL_iterator
CBCL_reference
CBCL_reference_base
CBCL_reference_base< _Cont_t, true >
Cbidirectional_iterator_tag
CBidirectionalIterator
Cbinary_function
Cbinary_negate
Cbinder1st
Cbinder2nd
Ccollection_adapter
Ccollection_adapter< System::Collections::Generic::ICollection< _Value_t > >
Ccollection_adapter< System::Collections::Generic::IDictionary< _Key_t, _Mapped_t > >
Ccollection_adapter< System::Collections::Generic::IEnumerable< _Value_t > >
Ccollection_adapter< System::Collections::Generic::IList< _Value_t > >
Ccollection_adapter< System::Collections::ICollection >
Ccollection_adapter< System::Collections::IDictionary >
Ccollection_adapter< System::Collections::IEnumerable >
Ccollection_adapter< System::Collections::IList >
Ccomparer_less
CConstBidirectionalIterator
CConstRandomAccessIterator
CConstUncheckedBidirectionalIterator
CConstUncheckedRandomAccessIterator
Cdeque
Cdivides
CEnum_iterator
Cequal_to
Cforward_iterator_tag
Cgreater
Cgreater_equal
Chash_map
Chash_multimap
Chash_multiset
Chash_set
Cinput_iterator_tag
Cis_handle
Cis_handle< _Value_t^>
Citerator_traits
Citerator_traits< __int64 >
Citerator_traits< _Iter_t^>
Citerator_traits< _STLCLR Generic::ConstContainerBidirectionalIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ConstContainerRandomAccessIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ConstReverseBidirectionalIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ConstReverseRandomAccessIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ContainerBidirectionalIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ContainerRandomAccessIterator< _Ty > >
Citerator_traits< _STLCLR Generic::IBidirectionalIterator< _Ty > >
Citerator_traits< _STLCLR Generic::IForwardIterator< _Ty > >
Citerator_traits< _STLCLR Generic::IInputIterator< _Ty > >
Citerator_traits< _STLCLR Generic::IOutputIterator< _Ty > >
Citerator_traits< _STLCLR Generic::IRandomAccessIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ReverseBidirectionalIterator< _Ty > >
Citerator_traits< _STLCLR Generic::ReverseRandomAccessIterator< _Ty > >
Citerator_traits< _Ty * >
Citerator_traits< bool >
Citerator_traits< char >
Citerator_traits< const _Ty * >
Citerator_traits< int >
Citerator_traits< long >
Citerator_traits< short >
Citerator_traits< signed char >
Citerator_traits< unsigned __int64 >
Citerator_traits< unsigned char >
Citerator_traits< unsigned int >
Citerator_traits< unsigned long >
Citerator_traits< unsigned short >
Citerator_traits< wchar_t >
Cless
Cless_equal
Clight_pair
Clist
Clogical_and
Clogical_not
Clogical_or
Cmap
Cminus
Cmodulus
Cmultimap
Cmultiplies
Cmultiset
Cnegate
Cnot_equal_to
Coutput_iterator_tag
Cpair
Cplus
Cpriority_queue
Cqueue
Crandom_access_iterator_tag
CRandomAccessIterator
Crange_adapter
Cref_binary_negate
Cref_binder1st
Cref_binder2nd
Cref_divides
Cref_equal_to
Cref_greater
Cref_greater_equal
Cref_less
Cref_less_equal
Cref_logical_and
Cref_logical_not
Cref_logical_or
Cref_minus
Cref_modulus
Cref_multiplies
Cref_negate
Cref_not_equal_to
Cref_plus
Cref_unary_negate
CReverseBidirectionalIterator
CReverseRandomAccessIterator
Cselect_pair
Cselect_pair< _Value1_t, _Value2_t, false >
Cset
Cstack
Cunary_function
Cunary_negate
CUncheckedBCL_iterator
CUncheckedBidirectionalIterator
CUncheckedRandomAccessIterator
Cvector
►NConcurrency	The Concurrency namespace provides classes and functions that provide access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.
►Ndetails
►Nstd
C_Is_checked_helper< _Concurrent_queue_iterator< _Container, _Value > >
C_Is_checked_helper< _Vector_iterator< _Container, _Value > >
C_Accelerator_view_hasher
C_Aggregated_operation	_Aggregated_operation base class
C_Aggregator	An aggregator for collecting operations coming from multiple sources and executing them serially on a single thread. _Operation_type must be derived from _Aggregated_operation. The parameter _Handler_type is a functor that will be passed the list of operations and is expected to handle each operation appropriately, setting the status of each operation to non-zero.
C_Allocator_base
C_AllocBase
C_Amp_runtime_trace
C_AnonymousOriginator
C_arithmetic_op_helper
C_arithmetic_op_helper< _T, opAdd >
C_arithmetic_op_helper< _T, opDiv >
C_arithmetic_op_helper< _T, opMod >
C_arithmetic_op_helper< _T, opMul >
C_arithmetic_op_helper< _T, opSub >
C_arithmetic_op_loop_helper
C_arithmetic_op_loop_helper< _T, _Kind, 1, false >
C_arithmetic_op_loop_helper< _T, _Kind, _Rank, false >
C_arithmetic_op_loop_helper< _T, _Kind, _Rank, true >
C_Array_copy_desc
C_Array_flatten_helper
C_Array_flatten_helper< 1, _T1, _T2 >
C_Array_flatten_helper< 2, _T1, _T2 >
C_Array_flatten_helper< 3, _T1, _T2 >
C_Array_init_helper
C_Array_init_helper< _T1, _T2, 1 >
C_Array_init_helper< _T1, _T2, 2 >
C_Array_init_helper< _T1, _T2, 3 >
C_Array_init_helper< _T1, _T2, 4 >
C_Array_projection_helper
C_Array_projection_helper< _T, 1 >
C_Array_view_base
C_Array_view_projection_helper
C_Array_view_projection_helper< _T, 1 >
C_Array_view_shape
C_AsyncOriginator
C_AsyncTaskCollection	Async Task collections is a thin wrapper over task collection to cater to the execution of asynchronous chores (or tasks defined in ppltasks.h). Specifically, they manage their own lifetime by using reference counts. Scheduling a chore acquires a reference and on completion of its execution the reference is released.
C_BadArgType
C_BadContinuationParamType
C_Beacon_reference	Internal maintenance structure for beacons.
C_Buffer
C_Buffer_descriptor
C_Cancellation_beacon	A cancellation beacon is a flag which can be polled in an inlinable fashion using the is_signaled method in lieu of polling on the more expensive non inlinable is_current_task_group_canceling method.
C_CancellationTokenCallback
C_CancellationTokenRegistration
►C_CancellationTokenState
►CTokenRegistrationContainer
C_Node
C_Chore
C_cmp_op_helper
C_cmp_op_helper< _T, opEq >
C_cmp_op_helper< _T, opNeq >
C_cmp_op_loop_helper
C_cmp_op_loop_helper< _T, _Kind, 1, false >
C_cmp_op_loop_helper< _T, _Kind, _Rank, false >
C_cmp_op_loop_helper< _T, _Kind, _Rank, true >
C_compound_assign_op_helper
C_compound_assign_op_helper< _T, opAddEq >
C_compound_assign_op_helper< _T, opAssign >
C_compound_assign_op_helper< _T, opDivEq >
C_compound_assign_op_helper< _T, opModEq >
C_compound_assign_op_helper< _T, opMulEq >
C_compound_assign_op_helper< _T, opSubEq >
C_compound_assign_op_loop_helper
C_compound_assign_op_loop_helper< _T, _Kind, 1, false >
C_compound_assign_op_loop_helper< _T, _Kind, _Rank, false >
C_compound_assign_op_loop_helper< _T, _Kind, _Rank, true >
C_compound_assign_op_loop_helper< _T, opAssign, 1, false >
C_compound_assign_op_loop_helper< _T, opAssign, 2, true >
C_compound_assign_op_loop_helper< _T, opAssign, 3, true >
C_compound_assign_op_loop_helper< _T, opAssign, 4, true >
C_CONCRT_TRACE_INFO
C_Concurrent_hash
►C_Concurrent_queue_base_v4
C_Page
C_Concurrent_queue_iterator
C_Concurrent_queue_iterator_base_v4
C_Concurrent_queue_rep
►C_Concurrent_unordered_map_traits
C_Value_compare
C_Concurrent_unordered_set_traits
►C_Concurrent_vector_base_v4
C_Internal_segments_table
C_Segment_t
C_Const_array_projection_helper
C_Const_array_projection_helper< _T, 1 >
C_Const_array_view_projection_helper
C_Const_array_view_projection_helper< _T, 1 >
C_contains
C_contains< _EXT, _IDX, 1 >
C_contains< _EXT, _IDX, 2 >
C_contains< _EXT, _IDX, 3 >
C_Context
C_ContextCallback
C_ContinuationArgTypeHelper
C_ContinuationArgTypeHelper< _Ty, std::true_type >
C_ContinuationTaskHandleBase
C_ContinuationTypeTraits
C_CurrentScheduler
C_D3D_interop
►C_DefaultPPLTaskScheduler
C_PPLTaskChore
C_DefaultTaskHelper
C_DPC_call_handle
C_Dynamic_array
C_Event
C_ExceptionHolder
C_Falsifier
C_FunctionTypeTraits
C_FunctionTypeTraits< _Function, void >
C_Hash_compare
C_Host_Scheduling_info
C_index_helper
C_InitFunctorTypeTraits
C_InitFunctorTypeTraits< _Ty, _Ty >
C_Internal_task_options
C_Interruption_exception
C_Is_container
C_Is_extent_or_index
C_Is_extent_or_index< extent< N > >
C_Is_extent_or_index< index< N > >
C_IsIAsyncInfo
C_IsUnwrappedAsyncSelector
C_IsUnwrappedAsyncSelector< _TypeSelectorNoAsync >
C_MallocaArrayHolder
►C_MallocaListHolder
C_ElemNodeType
C_map_index
C_map_index< _T1, 1 >
C_map_index< _T1, 2 >
C_map_index< _T1, 3 >
C_map_index< _T1, 4 >
C_Micro_queue
►C_NonReentrantBlockingLock
C_Scoped_lock
►C_NonReentrantPPLLock
C_Scoped_lock
C_NormalizeVoidToUnitType
C_NormalizeVoidToUnitType< void >
C_Originator
C_PPLTaskHandle	The _PPLTaskHandle is the strong-typed task handle base. All user task functions need to be wrapped in this task handler to be executable by PPL. By deriving from a different _BaseTaskHandle, it can be used for both initial tasks and continuation tasks. For initial tasks, _PPLTaskHandle will be derived from _UnrealizedChore_t, and for continuation tasks, it will be derived from _ContinuationTaskHandleBase. The life time of the _PPLTaskHandle object is be managed by runtime if task handle is scheduled.
C_product_helper
C_product_helper< _T, 1, false >
C_product_helper< _T, _Rank, false >
C_product_helper< _T, _Rank, true >
C_ProgressReporterCtorArgType
C_project0
C_project0< _RES_EXT, _SRC_EXT, _RES_IDX, _SRC_IDX, 2 >
C_project0< _RES_EXT, _SRC_EXT, _RES_IDX, _SRC_IDX, 3 >
C_Projection_result_type
C_Projection_result_type< _T, 1 >
C_Queue
►C_ReaderWriterLock
C_Scoped_lock
C_Scoped_lock_read
►C_ReentrantBlockingLock
C_Scoped_lock
►C_ReentrantLock
C_Scoped_lock
►C_ReentrantPPLLock
C_Scoped_lock
C_RefCounter
C_RefCounterBase
C_Reference_counted_obj_ptr
C_Reference_counter
C_ResultHolder
C_ResultHolder< std::vector< bool > >
C_Runtime_object
C_Sampler
C_Sampler_descriptor
C_Scheduler
C_Solist_const_iterator
C_Solist_iterator
C_SpinCount
C_SpinLock
C_SpinWait	Implements busy wait with no backoff
►C_Split_order_list_node
C_Node
C_Split_order_list_value
C_Split_ordered_list
C_StackGuard	RAII wrapper used to maintain and limit ppltask maximum inline schedule depth. This class will keep a reference to the depth slot on current context.
C_StructuredTaskCollection	Structured task collections represent groups of work which follow a strictly LIFO ordered paradigm queueing and waiting respectively. They can only be waited on once and can only be used from a single thread of execution.
C_Subatomic
C_Subatomic_impl
C_Subatomic_impl< 4 >
C_SyncOriginator
C_Task_completion_event_impl
C_Task_generator_oversubscriber
C_Task_impl	The implementation of a first-class task. This structure contains the task group used to execute the task function and handles the scheduling. The _Task_impl is created as a shared_ptr member of the public task class, so its destruction is handled automatically.
C_Task_impl_base	The base implementation of a first-class task. This class contains all the non-type specific implementation details of the task.
C_Task_ptr
C_TaskCollection	Task collections represent groups of work which step outside the strict structuring of the _StructuredTaskCollection definition. Any groups of work which do not follow LIFO ordering, are waited on multiple times, or are passed between arbitrary threads require utilization of this definition of a task collection. It has additional overhead over the _StructuredTaskCollection.
C_TaskCollectionBase
C_TaskCollectionBaseImpl
C_TaskCreationCallstack	Callstack container, which is used to capture and preserve callstacks in ppltasks. Members of this class is examined by vc debugger, thus there will be no public access methods. Please note that names of this class should be kept stable for debugger examining.
C_TaskEventLogger
C_TaskProcHandle
►C_TaskProcThunk	Helper object used for LWT invocation.
C_Holder
C_TaskTypeFromParam
C_TaskTypeTraits
C_TaskTypeTraits< void >
C_TaskWorkItemRAIILogger
C_Texture
C_Texture_descriptor
C_Texture_predefined_sample_helper
C_Texture_predefined_sample_helper< _T, 1 >
C_Texture_predefined_sample_helper< _T, 2 >
C_Texture_predefined_sample_helper< _T, 3 >
C_Texture_read_helper
C_Texture_read_helper< _T, 1 >
C_Texture_read_helper< _T, 2 >
C_Texture_read_helper< _T, 3 >
C_Texture_sample_helper
C_Texture_sample_helper< _T, 1 >
C_Texture_sample_helper< _T, 2 >
C_Texture_sample_helper< _T, 3 >
C_Texture_write_helper
C_Texture_write_helper< _T, 1 >
C_Texture_write_helper< _T, 2 >
C_Texture_write_helper< _T, 3 >
C_ThenImplOptions
C_Threadpool_chore
C_Threadpool_task
C_Timer
C_TypeSelectorAsyncAction
C_TypeSelectorAsyncActionWithProgress
C_TypeSelectorAsyncOperation
C_TypeSelectorAsyncOperationOrTask
C_TypeSelectorAsyncOperationWithProgress
C_TypeSelectorAsyncTask
C_TypeSelectorNoAsync
C_Ubiquitous_buffer
C_UnrealizedChore
C_UnwrapTaskType
C_UnwrapTaskType< task< _Ty > >
C_Vector_iterator
C_View_shape
CCancellationTokenRegistration_TaskProc
►Ndirect3d
Cadopt_d3d_access_lock_t	Tag type to indicate the D3D access lock should be adopted rather than acquired.
Cscoped_d3d_access_lock	RAII wrapper for a D3D access lock on an accelerator_view.
►Ngraphics
►Ndetails
C_Is_iterator
C_Short_vector_type_traits
C_Short_vector_type_traits< double >
C_Short_vector_type_traits< double_2 >
C_Short_vector_type_traits< double_3 >
C_Short_vector_type_traits< double_4 >
C_Short_vector_type_traits< float >
C_Short_vector_type_traits< float_2 >
C_Short_vector_type_traits< float_3 >
C_Short_vector_type_traits< float_4 >
C_Short_vector_type_traits< int >
C_Short_vector_type_traits< int_2 >
C_Short_vector_type_traits< int_3 >
C_Short_vector_type_traits< int_4 >
C_Short_vector_type_traits< norm >
C_Short_vector_type_traits< norm_2 >
C_Short_vector_type_traits< norm_3 >
C_Short_vector_type_traits< norm_4 >
C_Short_vector_type_traits< uint_2 >
C_Short_vector_type_traits< uint_3 >
C_Short_vector_type_traits< uint_4 >
C_Short_vector_type_traits< unorm >
C_Short_vector_type_traits< unorm_2 >
C_Short_vector_type_traits< unorm_3 >
C_Short_vector_type_traits< unorm_4 >
C_Short_vector_type_traits< unsigned int >
C_Texture_base
Ctexture_traits
Ctexture_traits< const texture< _Value_type, _Rank > >
Ctexture_traits< const texture_view< _Value_type, _Rank > >
Ctexture_traits< const texture_view< const _Value_type, _Rank > >
Ctexture_traits< const writeonly_texture_view< _Value_type, _Rank > >
Ctexture_traits< texture< _Value_type, _Rank > >
Ctexture_traits< texture_view< _Value_type, _Rank > >
Ctexture_traits< texture_view< const _Value_type, _Rank > >
Ctexture_traits< writeonly_texture_view< _Value_type, _Rank > >
Cdouble_2	Represent a short vector of 2 double's.
Cdouble_3	Represent a short vector of 3 double's.
Cdouble_4	Represent a short vector of 4 double's.
Cfloat_2	Represent a short vector of 2 float's.
Cfloat_3	Represent a short vector of 3 float's.
Cfloat_4	Represent a short vector of 4 float's.
Cint_2	Represent a short vector of 2 int's.
Cint_3	Represent a short vector of 3 int's.
Cint_4	Represent a short vector of 4 int's.
Cnorm	Represent a norm number. Each element is a floating point number in the range of [-1.0f, 1.0f].
Cnorm_2	Represent a short vector of 2 norm's.
Cnorm_3	Represent a short vector of 3 norm's.
Cnorm_4	Represent a short vector of 4 norm's.
Csampler	A sampler class aggregates sampling configuration information to be used for texture sampling.
Cshort_vector	short_vector provides metaprogramming definitions which are useful for programming short vectors generically.
Cshort_vector< double, 1 >
Cshort_vector< double, 2 >
Cshort_vector< double, 3 >
Cshort_vector< double, 4 >
Cshort_vector< float, 1 >
Cshort_vector< float, 2 >
Cshort_vector< float, 3 >
Cshort_vector< float, 4 >
Cshort_vector< int, 1 >
Cshort_vector< int, 2 >
Cshort_vector< int, 3 >
Cshort_vector< int, 4 >
Cshort_vector< norm, 1 >
Cshort_vector< norm, 2 >
Cshort_vector< norm, 3 >
Cshort_vector< norm, 4 >
Cshort_vector< unorm, 1 >
Cshort_vector< unorm, 2 >
Cshort_vector< unorm, 3 >
Cshort_vector< unorm, 4 >
Cshort_vector< unsigned int, 1 >
Cshort_vector< unsigned int, 2 >
Cshort_vector< unsigned int, 3 >
Cshort_vector< unsigned int, 4 >
Cshort_vector_traits	short_vector_traits allows retrival of the underlying vector length and scalar type of a short vector type or a scalar type
Cshort_vector_traits< double >
Cshort_vector_traits< double_2 >
Cshort_vector_traits< double_3 >
Cshort_vector_traits< double_4 >
Cshort_vector_traits< float >
Cshort_vector_traits< float_2 >
Cshort_vector_traits< float_3 >
Cshort_vector_traits< float_4 >
Cshort_vector_traits< int >
Cshort_vector_traits< int_2 >
Cshort_vector_traits< int_3 >
Cshort_vector_traits< int_4 >
Cshort_vector_traits< norm >
Cshort_vector_traits< norm_2 >
Cshort_vector_traits< norm_3 >
Cshort_vector_traits< norm_4 >
Cshort_vector_traits< uint_2 >
Cshort_vector_traits< uint_3 >
Cshort_vector_traits< uint_4 >
Cshort_vector_traits< unorm >
Cshort_vector_traits< unorm_2 >
Cshort_vector_traits< unorm_3 >
Cshort_vector_traits< unorm_4 >
Cshort_vector_traits< unsigned int >
Ctexture	A texture is a data aggregate on an accelerator_view in the extent domain. It is a collection of variables, one for each element in an extent domain. Each variable holds a value corresponding to C++ primitive type (unsigned int, int, float, double), or scalar type norm, or unorm (defined in concurrency::graphics), or eligible short vector types defined in concurrency::graphics.
Ctexture_view	A texture_view provides read and write access to a texture. Note that currently texture_view can only be used to read textures whose value type is int, unsigned int and float with default 32 bit bpse. To read other texture formats, use texture_view<const _Value_type, _Rank>.
Ctexture_view< const _Value_type, _Rank >	A texture_view<const _Value_type, _Rank> provides read-only access and sampling capability to a texture.
Cuint_2	Represent a short vector of 2 unsigned int's.
Cuint_3	Represent a short vector of 3 unsigned int's.
Cuint_4	Represent a short vector of 4 unsigned int's.
Cunorm	Represent a unorm number. Each element is a floating point number in the range of [0.0f, 1.0f].
Cunorm_2	Represent a short vector of 2 unorm's.
Cunorm_3	Represent a short vector of 3 unorm's.
Cunorm_4	Represent a short vector of 4 unorm's.
Cwriteonly_texture_view
C_AllocatedBufferHolder
C_Binary_transform_impl_helper
C_Binary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag, std::random_access_iterator_tag >
C_Continuation_func_transformer	A helper class template that transforms a continuation lambda that either takes or returns void, or both, into a lambda that takes and returns a non-void type (details::_Unit_type is used to substitute for void). This is to minimize the special handling required for 'void'.
C_Continuation_func_transformer< _InType, void >
C_Continuation_func_transformer< void, _OutType >
C_Continuation_func_transformer< void, void >
C_Greedy_node	Helper class used in multi-type greedy join blocks Ordered node is a single-target, single-source ordered propagator block
C_Init_func_transformer
C_Init_func_transformer< void >
C_Iterator_helper
C_Iterator_helper< _Random_iterator, std::random_access_iterator_tag >
C_Join_node	Defines a block allowing sources of distinct types to be joined. Join node is a single-target, multi-source ordered propagator block
C_Network_link_iterator	Const iterator for network link registry. Message blocks should use the link_registry::iterator type for iteration.
C_Non_greedy_node	Helper class used in multi-type non-greedy join blocks Ordered node is a single-target, single-source ordered propagator block
►C_Order_combinable
C_Bucket
C_Order_node_base	Base class for Helper node used in multi-type join and choice blocks Order node is a single-target, single-source ordered propagator block The main property of an order node is that it accepts a message of _Type and outputs a message of int, with some unique assigned index number.
C_Parallel_chunk_helper
C_Parallel_chunk_helper_invoke
C_Parallel_chunk_helper_invoke< _Random_iterator, _Index_type, _Function, false >
C_Parallel_fixed_chunk_helper
C_Parallel_for_each_helper
C_Parallel_localized_chunk_helper
C_Parallel_reduce_fixed_worker
C_Parallel_reduce_forward_executor_helper
C_Parallel_transform_binary_helper
C_Parallel_transform_unary_helper
C_Radix_sort_default_function
C_Range
C_Reduce_functor_helper
C_Reserving_node	Helper class used in multi-type choice blocks Ordered node is a single-target, single-source ordered propagator block
C_Source_link_iterator	Const Iterator for referenced link manager.
C_Tiled_index_base	A _Tiled_index_base is the base class of all three kinds of tiled_index to share the common code.
C_Unary_transform_impl_helper
C_Unary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag >
C_Unwrap
C_Unwrap< std::tuple< _Types...> >	Template specialization used to unwrap the types from within a tuple.
C_Worker_proxy
Caccelerator	Class represents a accelerator abstraction for C++ AMP data-parallel devices
Caccelerator_view	Class represents a virtual device abstraction on a C++ AMP data-parallel accelerator
Caccelerator_view_removed	Exception thrown when an underlying DirectX call fails due to the Windows timeout detection and recovery mechanism
Caffinity_partitioner	The affinity_partitioner class is similar to the static_partitioner class, but it improves cache affinity by its choice of mapping subranges to worker threads. It can improve performance significantly when a loop is re-executed over the same data set, and the data fits in cache. Note that the same affinity_partitioner object must be used with subsequent iterations of a parallel loop that is executed over a particular data set, to benefit from data locality.
Cagent	A class intended to be used as a base class for all independent agents. It is used to hide state from other agents and interact using message-passing.
Carray	An array is a multi-dimensional data aggregate on a accelerator_view.
Carray_view	An array_view is an N-dimensional view over data held in another container (such as array<T,N> or other container. It exposes an indexing interface congruent to that of array<T,N>).
Carray_view< const _Value_type, _Rank >
Cauto_partitioner	The auto_partitioner class represents the default method parallel_for, parallel_for_each and parallel_transform use to partition the range they iterates over. This method of partitioning employes range stealing for load balancing as well as per-iterate cancellation.
►Cawait_resume_context
C_Callback
C_CallbackChain
CThreadpoolContext
Cbad_target	This class describes an exception thrown when a messaging block is given a pointer to a target which is invalid for the operation being performed.
Ccall	A call messaging block is a multi-source, ordered target_block that invokes a specified function when receiving a message.
Ccancellation_token	The cancellation_token class represents the ability to determine whether some operation has been requested to cancel. A given token can be associated with a task_group, structured_task_group, or task to provide implicit cancellation. It can also be polled for cancellation or have a callback registered for if and when the associated cancellation_token_source is canceled.
Ccancellation_token_registration	The cancellation_token_registration class represents a callback notification from a cancellation_token. When the register method on a cancellation_token is used to receive notification of when cancellation occurs, a cancellation_token_registration object is returned as a handle to the callback so that the caller can request a specific callback no longer be made through use of the deregister method.
Ccancellation_token_source	The cancellation_token_source class represents the ability to cancel some cancelable operation.
Cchoice	A choice messaging block is a multi-source, single-target block that represents a control-flow interaction with a set of sources. The choice block will wait for any one of multiple sources to produce a message and will propagate the index of the source that produced the message.
Ccombinable	The combinable<T> object is intended to provide thread-private copies of data, to perform lock-free thread-local sub-computations during parallel algorithms. At the end of the parallel operation, the thread-private sub-computations can then be merged into a final result. This class can be used instead of a shared variable, and can result in a performance improvement if there would otherwise be a lot of contention on that shared variable.
Ccompletion_future	Class represents a future corresponding to a C++ AMP asynchronous operation
►Cconcurrent_priority_queue	The concurrent_priority_queue class is a container that allows multiple threads to concurrently push and pop items. Items are popped in priority order where priority is determined by a functor supplied as a template argument.
C_Cpq_operation
C_My_functor_type
►Cconcurrent_queue	The concurrent_queue class is a sequence container class that allows first-in, first-out access to its elements. It enables a limited set of concurrency-safe operations, such as push and try_pop.
C_Destroyer
Cconcurrent_unordered_map	The concurrent_unordered_map class is a concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access, and iterator traversal operations.
Cconcurrent_unordered_multimap	The concurrent_unordered_multimap class is an concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
Cconcurrent_unordered_multiset	The concurrent_unordered_multiset class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_type. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
Cconcurrent_unordered_set	The concurrent_unordered_set class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_type. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
►Cconcurrent_vector	The concurrent_vector class is a sequence container class that allows random access to any element. It enables concurrency-safe append, element access, iterator access, and iterator traversal operations.
C_Internal_loop_guide
C_Is_integer_tag
Ccontext_self_unblock	This class describes an exception thrown when the Unblock method of a Context object is called from the same context. This would indicate an attempt by a given context to unblock itself.
Ccontext_unblock_unbalanced	This class describes an exception thrown when calls to the Block and Unblock methods of a Context object are not properly paired.
►Ccritical_section	A non-reentrant mutex which is explicitly aware of the Concurrency Runtime.
Cscoped_lock	An exception safe RAII wrapper for a critical_section object.
Cdefault_scheduler_exists	This class describes an exception thrown when the Scheduler::SetDefaultSchedulerPolicy method is called when a default scheduler already exists within the process.
Cevent	A manual reset event which is explicitly aware of the Concurrency Runtime.
Cextent	The extent<N> type represents an N-dimensional vector of int which specifies the bounds of an N-dimensional space with an origin of 0. The values in the coordinate vector are ordered from most-significant to least-significant. Thus, in 2-dimensional space, the extent vector (5,3) represents a space with 5 rows and 3 columns
Cimproper_lock	This class describes an exception thrown when a lock is acquired improperly.
Cimproper_scheduler_attach	This class describes an exception thrown when the Attach method is called on a Scheduler object which is already attached to the current context.
Cimproper_scheduler_detach	This class describes an exception thrown when the CurrentScheduler::Detach method is called on a context which has not been attached to any scheduler using the Attach method of a Scheduler object.
Cimproper_scheduler_reference	This class describes an exception thrown when the Reference method is called on a Scheduler object that is shutting down, from a context that is not part of that scheduler.
Cindex	Define an N-dimensional index point; which may also be viewed as a vector based at the origin in N-space
Cinvalid_compute_domain	Exception thrown when the runtime fails to launch a kernel using the compute domain specified at the parallel_for_each call site.
Cinvalid_link_target	This class describes an exception thrown when the link_target method of a messaging block is called and the messaging block is unable to link to the target. This can be the result of exceeding the number of links the messaging block is allowed or attempting to link a specific target twice to the same source.
Cinvalid_multiple_scheduling	This class describes an exception thrown when a task_handle object is scheduled multiple times using the run method of a task_group or structured_task_group object without an intervening call to either the wait or run_and_wait methods.
Cinvalid_operation	This class describes an exception thrown when an invalid operation is performed that is not more accurately described by another exception type thrown by the Concurrency Runtime.
Cinvalid_oversubscribe_operation	This class describes an exception thrown when the Context::Oversubscribe method is called with the _BeginOversubscription parameter set to false without a prior call to the Context::Oversubscribe method with the _BeginOversubscription parameter set to true.
Cinvalid_scheduler_policy_key	This class describes an exception thrown when an invalid or unknown key is passed to a SchedulerPolicy object constructor, or the SetPolicyValue method of a SchedulerPolicy object is passed a key that must be changed using other means such as the SetConcurrencyLimits method.
Cinvalid_scheduler_policy_thread_specification	This class describes an exception thrown when an attempt is made to set the concurrency limits of a SchedulerPolicy object such that the value of the MinConcurrency key is less than the value of the MaxConcurrency key.
Cinvalid_scheduler_policy_value	This class describes an exception thrown when a policy key of a SchedulerPolicy object is set to an invalid value for that key.
CISource	The ISource class is the interface for all source blocks. Source blocks propagate messages to ITarget blocks.
CITarget	The ITarget class is the interface for all target blocks. Target blocks consume messages offered to them by ISource blocks.
►Cjoin	A join messaging block is a single-target, multi-source, ordered propagator_block which combines together messages of type _Type from each of its sources.
C_MessageArray
C_SavedMessageIdArray
Clocation	An abstraction of a physical location on hardware.
Cmessage	The basic message envelope containing the data payload being passed between messaging blocks.
Cmessage_not_found	This class describes an exception thrown when a messaging block is unable to find a requested message.
Cmessage_processor	The message_processor class is the abstract base class for processing of message objects. There is no guarantee on the ordering of the messages.
Cmissing_wait	This class describes an exception thrown when there are tasks still scheduled to a task_group or structured_task_group object at the time that object's destructor executes. This exception will never be thrown if the destructor is reached because of a stack unwinding as the result of an exception.
Cmulti_link_registry	The multi_link_registry object is a network_link_registry that manages multiple source blocks or multiple target blocks.
Cmultitype_join	A multitype_join messaging block is a multi-source, single-target messaging block that combines together messages of different types from each of its sources and offers a tuple of the combined messages to its targets.
Cnested_scheduler_missing_detach	This class describes an exception thrown when the Concurrency Runtime detects that you neglected to call the CurrentScheduler::Detach method on a context that attached to a second scheduler using the Attach method of the Scheduler object.
Cnetwork_link_registry	The network_link_registry abstract base class manages the links between source and target blocks.
Coperation_timed_out	This class describes an exception thrown when an operation has timed out.
Cordered_message_processor	An ordered_message_processor is a message_processor that allows message blocks to process messages in the order they were received.
Cout_of_memory	Exception thrown when an underlying OS/DirectX call fails due to lack of system or device memory
Coverwrite_buffer	An overwrite_buffer messaging block is a multi-target, multi-source, ordered propagator_block capable of storing a single message at a time. New messages overwrite previously held ones.
Cpropagator_block	The propagator_block class is an abstract base class for message blocks that are both a source and target. It combines the functionality of both the source_block and target_block classes.
►Creader_writer_lock	A writer-preference queue-based reader-writer lock with local only spinning. The lock grants first in - first out (FIFO) access to writers and starves readers under a continuous load of writers.
Cscoped_lock	An exception safe RAII wrapper that can be used to acquire reader_writer_lock lock objects as a writer.
Cscoped_lock_read	An exception safe RAII wrapper that can be used to acquire reader_writer_lock lock objects as a reader.
Cruntime_exception	Exception thrown due to a C++ AMP runtime_exception. This is the base type for all C++ AMP exception types.
Cscheduler_not_attached	This class describes an exception thrown when an operation is performed which requires a scheduler to be attached to the current context and one is not.
Cscheduler_ptr	Represents a pointer to a scheduler. This class exists to allow the the specification of a shared lifetime by using shared_ptr or just a plain reference by using raw pointer.
Cscheduler_resource_allocation_error	This class describes an exception thrown because of a failure to acquire a critical resource in the Concurrency Runtime.
Cscheduler_worker_creation_error	This class describes an exception thrown because of a failure to create a worker execution context in the Concurrency Runtime.
Csimple_partitioner	The simple_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into chunks such that each chunk has at least the number of iterations specified by the chunk size.
Csingle_assignment	A single_assignment messaging block is a multi-target, multi-source, ordered propagator_block capable of storing a single, write-once message.
Csingle_link_registry	The single_link_registry object is a network_link_registry that manages only a single source or target block.
Csource_block	The source_block class is an abstract base class for source-only blocks. The class provides basic link management functionality as well as common error checks.
Csource_link_manager	The source_link_manager object manages messaging block network links to ISource blocks.
Cstatic_partitioner	The static_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into as many chunks as there are workers available to the underyling scheduler.
Cstructured_task_group	The structured_task_group class represents a highly structured collection of parallel work. You can queue individual parallel tasks to a structured_task_group using task_handle objects, and wait for them to complete, or cancel the task group before they have finished executing, which will abort any tasks that have not begun execution.
Ctarget_block	The target_block class is an abstract base class that provides basic link management functionality and error checking for target only blocks.
►Ctask	The Parallel Patterns Library (PPL) task class. A task object represents work that can be executed asynchronously, and concurrently with other tasks and parallel work produced by parallel algorithms in the Concurrency Runtime. It produces a result of type _ResultType on successful completion. Tasks of type task<void> produce no result. A task can be waited upon and canceled independently of other tasks. It can also be composed with other tasks using continuations(then), and join(when_all) and choice(when_any) patterns.
C_ContinuationTaskHandle	The task handle type used to create a 'continuation task'.
C_InitialTaskHandle
Ctask< void >	The Parallel Patterns Library (PPL) task class. A task object represents work that can be executed asynchronously, and concurrently with other tasks and parallel work produced by parallel algorithms in the Concurrency Runtime. It produces a result of type _ResultType on successful completion. Tasks of type task<void> produce no result. A task can be waited upon and canceled independently of other tasks. It can also be composed with other tasks using continuations(then), and join(when_all) and choice(when_any) patterns.
Ctask_canceled	This class describes an exception thrown by the PPL tasks layer in order to force the current task to cancel. It is also thrown by the get() method on task, for a canceled task.
Ctask_completion_event	The task_completion_event class allows you to delay the execution of a task until a condition is satisfied, or start a task in response to an external event.
Ctask_completion_event< void >	The task_completion_event class allows you to delay the execution of a task until a condition is satisfied, or start a task in response to an external event.
Ctask_continuation_context	The task_continuation_context class allows you to specify where you would like a continuation to be executed. It is only useful to use this class from a Windows Store app. For non-Windows Store apps, the task continuation's execution context is determined by the runtime, and not configurable.
Ctask_group	The task_group class represents a collection of parallel work which can be waited on or canceled.
Ctask_handle	The task_handle class represents an individual parallel work item. It encapsulates the instructions and the data required to execute a piece of work.
Ctask_options	Represents the allowed options for creating a task
Ctile_barrier	The tile_barrier class is a capability class that is only creatable by the system, and passed to a tiled parallel_for_each lambda as part of the tiled_index parameter. It provides wait methods whose purpose is to synchronize execution of threads running within the thread group (tile).
Ctiled_extent	A tiled_extent is an extent of 1 to 3 dimensions which also subdivides the extent space into 1-, 2-, or 3-dimensional tiles. It has three specialized forms: tiled_extent<_Dim0>, tiled_extent<_Dim0,_Dim1>, and tiled_extent<_Dim0,_Dim1,_Dim2>, where _Dim0-2 specify the length of the tile along each dimension, with _Dim0 being the most-significant dimension and _Dim2 being the least-significant.
Ctiled_extent< _Dim0, 0, 0 >
Ctiled_extent< _Dim0, _Dim1, 0 >
Ctiled_index	A tiled_index is a set of indices of 1 to 3 dimensions which have been subdivided into 1-, 2-, or 3-dimensional tiles in a tiled_extent. It has three specialized forms: tiled_index<_Dim0>, tiled_index<_Dim0, _Dim1>, and tiled_index<_Dim0, _Dim1, _Dim2>, where _Dim0-2 specify the length of the tile along the each dimension, with _Dim0 being the most-significant dimension and _Dim2 being the least-significant.
Ctiled_index< _Dim0, 0, 0 >
Ctiled_index< _Dim0, _Dim1, 0 >
Ctimer	A timer messaging block is a single-target source_block capable of sending a message to its target after a specified time period has elapsed or at specific intervals.
Ctransformer	A transformer messaging block is a single-target, multi-source, ordered propagator_block which can accept messages of one type and is capable of storing an unbounded number of messages of a different type.
Cunbounded_buffer	An unbounded_buffer messaging block is a multi-target, multi-source, ordered propagator_block capable of storing an unbounded number of messages.
Cunsupported_feature	Exception thrown when an unsupported feature is used
Cunsupported_os	This class describes an exception thrown when an unsupported operating system is used.
►Nexperimental
►Nfilesystem
►Nv1
C_Directory_iterator
C_Path_cvt
C_Path_cvt< _Outchar, _Outchar, _Outtraits, _Outalloc >
C_Path_cvt< char, char16_t, _Outtraits, _Outalloc >
C_Path_cvt< char, char32_t, _Outtraits, _Outalloc >
C_Path_cvt< char, char8_t, char_traits< char >, allocator< char > >
C_Path_cvt< char, wchar_t, _Outtraits, _Outalloc >
C_Path_cvt< char16_t, char, _Outtraits, _Outalloc >
C_Path_cvt< char32_t, char, _Outtraits, _Outalloc >
C_Path_cvt< char32_t, wchar_t, _Outtraits, _Outalloc >
C_Path_cvt< char8_t, char, _Outtraits, _Outalloc >
C_Path_cvt< char8_t, wchar_t, _Outtraits, _Outalloc >
C_Path_cvt< wchar_t, char, _Outtraits, _Outalloc >
C_Path_cvt< wchar_t, char32_t, _Outtraits, _Outalloc >
C_Path_cvt< wchar_t, char8_t, char_traits< char >, allocator< char > >
C_Path_iterator
Cdirectory_entry
Cfile_status
Cfilesystem_error
Cpath
Crecursive_directory_iterator
Cspace_info
C_Resumable_helper_traits
Ccoroutine_handle
►Ccoroutine_handle< void >
C_Resumable_frame_prefix
Ccoroutine_traits
►Cgenerator
Citerator
Cpromise_type
Csuspend_always
Csuspend_if
Csuspend_never
►Nliterals
►NMicrosoft
►NVisualC
►Nmsclr
►N_detail
C_auto_gcroot_ref
Ccallback_cdecl_struct0
Ccallback_cdecl_struct1
Ccallback_cdecl_struct10
Ccallback_cdecl_struct11
Ccallback_cdecl_struct12
Ccallback_cdecl_struct13
Ccallback_cdecl_struct14
Ccallback_cdecl_struct15
Ccallback_cdecl_struct2
Ccallback_cdecl_struct3
Ccallback_cdecl_struct4
Ccallback_cdecl_struct5
Ccallback_cdecl_struct6
Ccallback_cdecl_struct7
Ccallback_cdecl_struct8
Ccallback_cdecl_struct9
Ccallback_cdecl_void_struct0
Ccallback_cdecl_void_struct1
Ccallback_cdecl_void_struct10
Ccallback_cdecl_void_struct11
Ccallback_cdecl_void_struct12
Ccallback_cdecl_void_struct13
Ccallback_cdecl_void_struct14
Ccallback_cdecl_void_struct15
Ccallback_cdecl_void_struct2
Ccallback_cdecl_void_struct3
Ccallback_cdecl_void_struct4
Ccallback_cdecl_void_struct5
Ccallback_cdecl_void_struct6
Ccallback_cdecl_void_struct7
Ccallback_cdecl_void_struct8
Ccallback_cdecl_void_struct9
Csmart_com_ptr
►Ncom
Cptr
►Ndelegate_map
►Ninternal
Cdelegate_proxy_factory
►Ninterop
►Ndetails
Cchar_buffer
Ccontext_node
Ccontext_node< BSTR, System::String^>
Ccontext_node< const char *, System::String^>
Ccontext_node< const wchar_t *, System::String^>
Ccontext_node_base
Cerror_reporting_helper
Cerror_reporting_helper< _To_Type, _From_Type, false >
Cerror_reporting_helper< _To_Type, _From_Type, true >
►Cmarshal_context
Cinternal_marshaler
Cinternal_marshaler< _To_Type, _From_Type, false >
Cinternal_marshaler< _To_Type, _From_Type, true >
►C_detail_class
Cdummy_struct
Cauto_gcroot
Cauto_handle
Cgcroot
►Clock
Cis_not
Cis_not< T, T >
►NPlatform
►NDetails
C__abi_CaptureBase
C__abi_CapturePtr
C__abi_FunctorCapture
C__remove_hat
C__remove_hat< T^>
CAgileHelper
CAgileTypeHelper
Carray_helper
Carray_helper< __TArg, false >
Carray_helper< __TArg, true >
CBoxValueType
CBoxValueType< true >
CCustomEnum
CCustomValueType
CEventLock
CRemoveConst
CRemoveConst< const __TArg >
CRemoveCV
CRemoveVolatile
CRemoveVolatile< volatile __TArg >
Csealed
CAgile
CAgile< T, false >
CArray
CArrayReference
CArrayReference< __TArg, 1 >
CEventSource
CModule
Csealed
CStringReference
►CWeakReference
CBoolStruct
CWriteOnlyArray
CWriteOnlyArray< __TArg, 1 >
►Nstd	STL namespace
►Nexperimental
►Ndetails
Cawaitable_traits
►Ccoroutine_traits< ::concurrency::task< _Ty >, _Whatever...>
Cpromise_type
►Ccoroutine_traits< ::concurrency::task< void >, _Whatever...>
Cpromise_type
C__non_rtti_object
Cuses_allocator
Cuses_allocator< function< _Fty >, _Alloc >
Cuses_allocator< packaged_task< _Ty >, _Alloc >
Cuses_allocator< priority_queue< _Ty, _Container, _Pr >, _Alloc >
Cuses_allocator< promise< _Ty >, _Alloc >
Cuses_allocator< queue< _Ty, _Container >, _Alloc >
Cuses_allocator< stack< _Ty, _Container >, _Alloc >
Cuses_allocator< tuple< _Types...>, _Alloc >
►Nstdext
►Nallocators
Callocator_base
►Ccache_chunklist
C_Data_array
C_Data_block
C_Data_node
Ccache_freelist
Ccache_suballoc
►Cfreelist
Cnode
Cmax_fixed_size
Cmax_none
Cmax_unbounded
Cmax_variable_size
Crts_alloc
Csync_none
Csync_per_container
Csync_per_thread
Csync_shared
►Ncvt
C_Cvt_one_byte
C_Cvt_two_byte
C_tab_8859_1
C_tab_8859_10
C_tab_8859_13
C_tab_8859_14
C_tab_8859_15
C_tab_8859_16
C_tab_8859_2
C_tab_8859_3
C_tab_8859_4
C_tab_8859_5
C_tab_8859_6
C_tab_8859_7
C_tab_8859_8
C_tab_8859_9
C_tab_baltic
C_tab_big5
C_tab_cp037
C_tab_cp1006
C_tab_cp1026
C_tab_cp1250
C_tab_cp1251
C_tab_cp1252
C_tab_cp1253
C_tab_cp1254
C_tab_cp1255
C_tab_cp1256
C_tab_cp1257
C_tab_cp1258
C_tab_cp424
C_tab_cp437
C_tab_cp500
C_tab_cp737
C_tab_cp775
C_tab_cp850
C_tab_cp852
C_tab_cp855
C_tab_cp856
C_tab_cp857
C_tab_cp860
C_tab_cp861
C_tab_cp862
C_tab_cp863
C_tab_cp864
C_tab_cp865
C_tab_cp866
C_tab_cp869
C_tab_cp874
C_tab_cp875
C_tab_cp932
C_tab_cp936
C_tab_cp949
C_tab_cp950
C_tab_cyrillic
C_tab_euc
C_tab_gb12345
C_tab_gb2312
C_tab_greek
C_tab_iceland
C_tab_jis
C_tab_jis0201
C_tab_ksc5601
C_tab_latin2
C_tab_roman
C_tab_sjis
C_tab_turkish
Ccodecvt_8859_1
Ccodecvt_8859_10
Ccodecvt_8859_13
Ccodecvt_8859_14
Ccodecvt_8859_15
Ccodecvt_8859_16
Ccodecvt_8859_2
Ccodecvt_8859_3
Ccodecvt_8859_4
Ccodecvt_8859_5
Ccodecvt_8859_6
Ccodecvt_8859_7
Ccodecvt_8859_8
Ccodecvt_8859_9
Ccodecvt_baltic
Ccodecvt_big5
Ccodecvt_cp037
Ccodecvt_cp1006
Ccodecvt_cp1026
Ccodecvt_cp1250
Ccodecvt_cp1251
Ccodecvt_cp1252
Ccodecvt_cp1253
Ccodecvt_cp1254
Ccodecvt_cp1255
Ccodecvt_cp1256
Ccodecvt_cp1257
Ccodecvt_cp1258
Ccodecvt_cp424
Ccodecvt_cp437
Ccodecvt_cp500
Ccodecvt_cp737
Ccodecvt_cp775
Ccodecvt_cp850
Ccodecvt_cp852
Ccodecvt_cp855
Ccodecvt_cp856
Ccodecvt_cp857
Ccodecvt_cp860
Ccodecvt_cp861
Ccodecvt_cp862
Ccodecvt_cp863
Ccodecvt_cp864
Ccodecvt_cp865
Ccodecvt_cp866
Ccodecvt_cp869
Ccodecvt_cp874
Ccodecvt_cp875
Ccodecvt_cp932
Ccodecvt_cp936
Ccodecvt_cp949
Ccodecvt_cp950
Ccodecvt_cyrillic
Ccodecvt_ebcdic
Ccodecvt_euc
Ccodecvt_euc_0208
Ccodecvt_gb12345
Ccodecvt_gb2312
Ccodecvt_greek
Ccodecvt_iceland
Ccodecvt_jis
Ccodecvt_jis0201
Ccodecvt_jis_0208
Ccodecvt_ksc5601
Ccodecvt_latin2
Ccodecvt_one_one
Ccodecvt_roman
Ccodecvt_sjis
Ccodecvt_sjis_0208
Ccodecvt_turkish
Ccodecvt_utf16
Ccodecvt_utf8
Ccodecvt_utf8_utf16
Cwbuffer_convert
Cwstring_convert
►Nthreads
C_Scoped_lock
Cmutex
►C_Hmap_traits
Cvalue_compare
C_Hset_traits
Chash_compare
Chash_map
Chash_multimap
Chash_multiset
Chash_set
►Ntr2
►NWindows
►NUI
►NXaml
►NMedia
C__abi___classObjectEntry
C__abi___FactoryCache
C__abi_dtor_helper
C__abi_FTMWeakRefData
C__abi_MultiThreadedRefCount
C__abi_type_descriptor
C__abi_WinClassInstrumentation
C__n128x2
C__n128x3
C__n128x4
C__n64x2
C__n64x3
C__n64x4
C__non_rtti_object
C__Platform_Details_HSTRING_HEADER
C__std_type_info_data
C_Abs
C_Add_pointer
C_Add_pointer< _Ty, false >
C_Add_reference
C_Add_reference< _Ty, false >
C_Align_type
C_Aligned
C_Aligned< _Len, _Align, _Ty, true >
C_Aligned< _Len, _Align, char, false >
C_Aligned< _Len, _Align, double, false >
C_Aligned< _Len, _Align, int, false >
C_Aligned< _Len, _Align, short, false >
C_Alloc_allocate
C_Alloc_exact_args_t
C_Alloc_max_size
C_Alloc_select
C_Alloc_unpack_tuple_t
C_Always_false
C_Any_tag
C_Are_ratios
C_Are_ratios< ratio< _N1, _D1 >, ratio< _N2, _D2 > >
C_Arg_types
C_Arg_types< _Ty1 >
C_Arg_types< _Ty1, _Ty2 >
C_Array_const_iterator
C_Array_iterator
►C_Associated_state
C_Anon
C_Test_ready
C_Atomic_base
C_Atomic_impl
C_Atomic_impl< 1U >
C_Atomic_impl< 2U >
C_Atomic_impl< 4U >
C_Atomic_impl< 8U >
C_ATOMIC_ITYPE
C_Auto_cnd
C_Auto_mtx
C_Beta_distribution
C_Binder
C_Binder_result_type
C_Bitmap
C_Bitwise_hash
C_Both_or_neither_bool
►C_bstr_t
CData_t
C_Bt_state_t
C_Buf
C_Builder
C_C_double_complex
C_C_float_complex
C_C_ldouble_complex
C_Cat_base
C_Cat_sequences
C_Cat_sequences< integer_sequence< size_t, _Indexes1...>, integer_sequence< size_t, _Indexes2...> >
C_Change_sign
C_Change_sign< const _Ty >
C_Change_sign< const volatile _Ty >
C_Change_sign< volatile _Ty >
C_Char_traits
C_Char_traits_eq
C_Char_traits_lt
C_Choose_conjunction
C_Choose_conjunction< true, _Lhs, _Traits...>
C_Choose_disjunction
C_Choose_disjunction< false, _Lhs, _Traits...>
C_Circ_buf
C_Cl_names
C_Cmp_collate
C_Cmp_cs
C_Cmp_icase
C_Collvec
C_com_error
C_com_IIID
C_com_ptr_t
C_Complex_base
C_Complex_value
C_Compressed_pair
C_Compressed_pair< _Ty1, _Ty2, false >
C_Conjunction
C_Conjunction< _Lhs, _Traits...>
C_Conjunction< _Trait >
C_Conjunction<>
C_Container_base0
C_Container_base12
C_Container_proxy
C_Crt_new_delete
C_Ctraits
C_Ctraits< double >
C_Ctraits< float >
C_Ctraits< long double >
C_Ctypevec
C_Cvtvec
C_Dconst
C_Deferred_async_state
C_Deleter_base
C_Deque_alloc
C_Deque_base_types
C_Deque_const_iterator
C_Deque_iter_types
C_Deque_iterator
C_Deque_simple_types
C_Deque_unchecked_const_iterator
C_Deque_unchecked_iterator
C_Deque_val
C_Device_const_buffer_info
C_Device_resource_info
C_Disjunction
C_Disjunction< _Lhs, _Traits...>
C_Disjunction< _Trait >
C_Disjunction<>
C_Enable_if_seed_seq
C_Equal_memcmp_is_safe_helper
C_Equal_memcmp_is_safe_helper< _Elem, _Elem, _Char_traits_eq< char_traits< _Elem > > >
C_Equal_memcmp_is_safe_helper< _Elem, _Elem, equal_to< _Elem > >
C_Equal_memcmp_is_safe_helper< _Elem1 *, _Elem2 *, equal_to<> >
C_Equal_memcmp_is_safe_helper< _Elem1, _Elem2, equal_to<> >
C_Exact_args_t
C_Extent
C_Extent< _Ty[], _Nx >
C_Extent< _Ty[_Ix], 0 >
C_Extent< _Ty[_Ix], _Nx >
C_Facet_base
C_Facetptr
C_Fake_no_copy_callable_adapter
C_Fill_memset_is_safe_helper
C_Fillobj
C_Flist_alloc
C_Flist_base_types
C_Flist_buy
C_Flist_const_iterator
C_Flist_iter_types
C_Flist_iterator
C_Flist_node
C_Flist_node< _Value_type, void * >
C_Flist_simple_types
C_Flist_unchecked_const_iterator
C_Flist_unchecked_iterator
C_Flist_val
C_Forced
C_Forced_result_type
C_Func_base
C_Future_error_category
C_Gcd
C_Gcd< 0, 0 >
C_GcdX
C_GcdX< _Ax, 0 >
C_General_ptr_iterator_tag
C_Generic_error_category
C_Get_first_parameter
C_Get_first_parameter< _Ty< _First, _Rest...> >
C_Get_function_impl
C_Get_voidptr
C_Get_voidptr< _Alty, _Ty * >
C_Has_allocator_type
C_Has_no_alloc_construct
C_Has_no_alloc_construct< void_t< _Has_no_alloc_construct_tag, decltype(_STD declval< _Alloc & >().construct(_STD declval< _Ptr >(), _STD declval< _Args >()...))>, _Alloc, _Ptr, _Args...>
C_Has_no_alloc_construct_tag
C_Has_no_alloc_destroy
C_Has_no_alloc_destroy< _Alloc, _Ptr, void_t< _Has_no_alloc_destroy_tag, decltype(_STD declval< _Alloc & >().destroy(_STD declval< _Ptr >()))> >
C_Has_no_alloc_destroy_tag
C_Hash
C_Identity
C_If
C_If< true, _Ty1, _Ty2 >
C_Ignore
C_Immortalizer
C_Invoker
C_Invoker1
C_Invoker1< _Callable, _Ty1, _Decayed, false, false >
C_Invoker1< _Callable, _Ty1, _Decayed, false, true >
C_Invoker1< _Callable, _Ty1, _Decayed, true, false >
C_Invoker< _Callable >
C_Invoker< _Callable, _Ty1, _Types2...>
C_Invoker_functor
C_Invoker_pmd_object
C_Invoker_pmd_pointer
C_Invoker_pmf_object
C_Invoker_pmf_pointer
C_Iosb
C_Iostream_error_category
C_Is_character
C_Is_character< char >
C_Is_character< signed char >
C_Is_character< unsigned char >
C_Is_checked_helper
C_Is_checked_helper< _Ty, void_t< typename _Ty::_Unchecked_type > >
C_Is_checked_helper< _Vb_const_iterator< _Alloc > >
C_Is_checked_helper< _Vb_iterator< _Alloc > >
C_Is_checked_helper< back_insert_iterator< _Container > >
C_Is_checked_helper< front_insert_iterator< _Container > >
C_Is_checked_helper< insert_iterator< _Container > >
C_Is_checked_helper< istream_iterator< _Ty, _Elem, _Traits, _Diff > >
C_Is_checked_helper< istreambuf_iterator< _Elem, _Traits > >
C_Is_checked_helper< move_iterator< _RanIt > >
C_Is_checked_helper< ostream_iterator< _Ty, _Elem, _Traits > >
C_Is_checked_helper< ostreambuf_iterator< _Elem, _Traits > >
C_Is_checked_helper< reverse_iterator< _RanIt > >
C_Is_default_allocator
C_Is_default_allocator< allocator< _Ty >, typename allocator< _Ty >::_Not_user_specialized >
C_Is_floating_point
C_Is_floating_point< double >
C_Is_floating_point< float >
C_Is_floating_point< long double >
C_Is_function
C_Is_integral
C_Is_integral< _LONGLONG >
C_Is_integral< _ULONGLONG >
C_Is_integral< bool >
C_Is_integral< char >
C_Is_integral< char16_t >
C_Is_integral< char32_t >
C_Is_integral< signed char >
C_Is_integral< signed int >
C_Is_integral< signed long >
C_Is_integral< signed short >
C_Is_integral< unsigned char >
C_Is_integral< unsigned int >
C_Is_integral< unsigned long >
C_Is_integral< unsigned short >
C_Is_IntType
C_Is_iterator
C_Is_iterator< _Ty, void_t< typename iterator_traits< _Ty >::iterator_category > >
C_Is_member_object_pointer
C_Is_member_object_pointer< _Ty1 _Ty2::*, false >
C_Is_memfunptr
C_Is_nothrow_swappable
C_Is_nothrow_swappable_with
C_Is_pointer
C_Is_pointer< _Ty * >
C_Is_RealType
C_Is_same_size
C_Is_simple_alloc
C_Is_swappable
C_Is_swappable_with
C_Is_UIntType
C_Iterator012
C_Iterator_base0
C_Iterator_base12
C_Iterator_traits_base
C_Iterator_traits_base< _Iter, void_t< typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type, typename _Iter::pointer, typename _Iter::reference > >
C_LaunchPad
C_Lcm
C_Lex_compare_check_element_types_helper
C_Lex_compare_check_element_types_helper< _Elem1, _Elem2, void >
C_Lex_compare_optimize
C_List_alloc
C_List_base_types
C_List_buy
C_List_const_iterator
C_List_iter_types
C_List_iterator
C_List_node
C_List_node< _Value_type, void * >
C_List_simple_types
C_List_unchecked_const_iterator
C_List_unchecked_iterator
C_List_val
C_Locbase
C_Locinfo
C_Loop_vals_t
C_Matcher
C_Maximum
C_Maximum< _First, _Second, _Rest...>
C_Maximum< _Val >
C_Maximum<>
C_Mem_fn
C_Monobj
C_Mpunct
C_Mul_mod
C_Mult_prec
C_Mutable_iterator_tag
C_Mutex_base
C_Nil
C_Node_assert
C_Node_back
C_Node_base
C_Node_capture
C_Node_class
C_Node_end_group
C_Node_end_rep
C_Node_endif
C_Node_if
C_Node_rep
C_Node_str
C_Num_base
C_Num_float_base
C_Num_int_base
C_One_then_variadic_args_t
C_P_arg_type
C_P_arg_type< _Fret & >
C_P_arg_type< void >
C_Packaged_state
C_Packaged_state< _Ret &(_ArgTypes...)>
C_Packaged_state< _Ret(_ArgTypes...)>
C_Packaged_state< void(_ArgTypes...)>
C_Pad
C_Param_tester
C_Parser
C_Ph
C_Promise
C_Ptr_base
C_Ptr_cat_helper
C_Ptr_cat_helper< _Anything *, const _Anything * >
C_Ptr_cat_helper< _Elem, _Elem >
C_Quote_in
C_Quote_out
C_Ratio_add
C_Ratio_divide
C_Ratio_less
C_Ratio_multiply
C_Ratio_multiply_sfinae
C_Ratio_multiply_sfinae< _R1, _R2, _Sfinae, void_t< typename _Ratio_multiply< _R1, _R2 >::_Num::type, typename _Ratio_multiply< _R1, _R2 >::_Den::type > >
C_Ratio_subtract
C_Really_trivial_ptr_iterator_tag
C_Ref_count
C_Ref_count_base
C_Ref_count_del
C_Ref_count_del_alloc
C_Ref_count_obj
C_Ref_count_obj_alloc
C_Regex_base
C_Regex_traits
C_Regex_traits_base
C_Repeat_for
C_Replace_first_parameter
C_Replace_first_parameter< _Newfirst, _Ty< _First, _Rest...> >
C_Result_of
C_Result_of< void_t< _Unique_tag_result_of, decltype(_STD invoke(_STD declval< _Types >()...))>, _Types...>
C_Rng_from_urng
C_Root_node
C_RTC_ALLOCA_NODE
C_RTC_framedesc
C_RTC_vardesc
C_Safe_add
C_Safe_addX
C_Safe_addX< _Ax, _Bx, false, false >
C_Safe_mult
C_Safe_mult< _Ax, _Bx, _Sfinae, false >
C_Scoped_base
C_Scoped_base< _Outer >
C_Scoped_base< _Outer, _Inner0, _Inner...>
C_Scoped_is_always_equal
C_Scoped_is_always_equal< _Outer >
C_Scoped_outermost_allocator
C_Scoped_propagate_on_container_copy
C_Scoped_propagate_on_container_copy< _Outer >
C_Scoped_propagate_on_container_move
C_Scoped_propagate_on_container_move< _Outer >
C_Scoped_propagate_on_container_swap
C_Scoped_propagate_on_container_swap< _Outer >
C_Select
C_Select_fixer
C_Select_fixer< _Cv_TiD, false, false, 0 >
C_Select_fixer< _Cv_TiD, false, false, _Jx >
C_Select_fixer< _Cv_TiD, false, true, 0 >
C_Select_fixer< _Cv_TiD, true, false, 0 >
C_Select_uint
C_Select_uint< _Ty, _Ax, _Cx, _Mx, true >
C_Select_ulong
C_Select_ulong< _Ty, _Ax, _Cx, _Mx, true >
C_Select_ulonglong
C_Select_ulonglong< _Ty, _Ax, _Cx, _Mx, true >
C_Sequence
C_Shared_ptr_spin_lock
C_Sign_base
C_Sign_base< _Ty, false >
C_Sign_of
C_Simple_types
C_Small_poisson_distribution
C_Smanip
C_State_deleter
C_State_manager
C_Storage
C_String_alloc
C_String_base_types
C_String_const_iterator
C_String_iter_types
C_String_iterator
►C_String_val
C_Bxty
C_Swap_cannot_throw
C_Swappable_with_helper
C_Swappable_with_helper< _Ty1, _Ty2, void_t< _Swappable_with_helper_unique_type, decltype(swap(_STD declval< _Ty1 >(), _STD declval< _Ty2 >()))> >
C_Swappable_with_helper_unique_type
C_Swc_base
C_Swc_traits
C_System_error
C_System_error_category
C_Task_async_state
►C_Temp_iterator
C_Bufpar
►C_Tgt_state_t
C_Grp_t
C_Thrd_imp_t
C_Timeobj
C_Timevec
►C_Tmap_traits
Cvalue_compare
►C_Tree
C_Copy_tag
C_Move_tag
C_Tree_base_types
C_Tree_comp_alloc
C_Tree_const_iterator
C_Tree_iter_types
C_Tree_iterator
C_Tree_node
C_Tree_node< _Value_type, void * >
C_Tree_simple_types
C_Tree_unchecked_const_iterator
C_Tree_unchecked_iterator
C_Tree_val
C_Trivially_copyable_ptr_iterator_tag
C_Tset_traits
C_Tuple_alloc_t
C_Tuple_cat1
C_Tuple_cat2
C_Tuple_cat2< tuple< _Types1...>, _Kx_arg, integer_sequence< size_t, _Ix...>, _Ix_next, tuple< _Types2...>, _Rest...>
C_Tuple_convert_copy
C_Tuple_convert_copy< tuple< _This >, _Uty >
C_Tuple_convert_move
C_Tuple_convert_move< tuple< _This >, _Uty >
C_Tuple_element
C_Tuple_element< _This, tuple< _This, _Rest...> >
C_Tuple_element< _Ty, const _Tuple >
C_Tuple_element< _Ty, const volatile _Tuple >
C_Tuple_element< _Ty, tuple< _This, _Rest...> >
C_Tuple_element< _Ty, tuple<> >
C_Tuple_element< _Ty, volatile _Tuple >
C_Tuple_explicit_val
C_Tuple_explicit_val0
C_Tuple_explicit_val0< true, tuple< _Dests...>, _Srcs...>
C_Tuple_implicit_val
C_Tuple_implicit_val0
C_Tuple_implicit_val0< true, tuple< _Dests...>, _Srcs...>
C_Tuple_perfect_val
C_Tuple_perfect_val< _Myt, _This2 >
C_Tuple_val
C_Uhash_compare
►C_Umap_traits
Cvalue_compare
C_Unforced
C_Unique_ptr_base
C_Unique_tag_result_of
C_Unpack_tuple_t
C_Unrefwrap
C_Unrefwrap_helper
C_Unrefwrap_helper< reference_wrapper< _Ty > >
C_Unwrap_alloc
C_Unwrap_alloc< _Wrap_alloc< _Alloc > >
C_Unwrap_enum
C_Unwrap_enum< _Elem, false >
C_Uset_traits
C_Value_equality_is_bitwise_equality
C_variant_t
C_Vb_const_iterator
C_Vb_iter_base
C_Vb_iterator
C_Vb_reference
C_Vb_val
C_Vec_base_types
C_Vec_iter_types
C_Vector_alloc
C_Vector_const_iterator
C_Vector_iterator
C_Vector_val
C_View_as_tuple
C_View_as_tuple< array< _Ty, 0 >, _Types...>
C_View_as_tuple< array< _Ty, _Size >, _Types...>
C_View_as_tuple< pair< _Ty1, _Ty2 > >
C_View_as_tuple< tuple< _Types...> >
C_Weak_argument_type
C_Weak_argument_type< _Ty, void_t< typename _Ty::argument_type > >
C_Weak_binary_args
C_Weak_binary_args< _Ty, void_t< typename _Ty::first_argument_type, typename _Ty::second_argument_type > >
C_Weak_result_type
C_Weak_result_type< _Ty, void_t< typename _Ty::result_type > >
C_Weak_types
C_Winit
C_With_nested
►C_Wrap_alloc
Crebind
C_Wrap_int
C_Wrap_istream
C_Yarn
C_Zero_then_variadic_args_t
Cadd_const
Cadd_cv
Cadd_lvalue_reference
Cadd_pointer
Cadd_rvalue_reference
Cadd_volatile
Cadopt_lock_t
Caligned_storage
Caligned_union
Calignment_of
►Callocator
Crebind
►Callocator< void >
Crebind
Callocator_arg_t
Callocator_traits
Callocator_traits< allocator< _Ty > >
CAnnotesAttribute
Carray
Carray< _Ty, 0 >
CAtAttribute
CAtBufferAttribute
Catomic
Catomic< _ITYPE >
Catomic_flag
Cback_insert_iterator
Cbad_alloc
Cbad_cast
Cbad_exception
Cbad_function_call
Cbad_typeid
Cbad_weak_ptr
Cbasic_filebuf
Cbasic_fstream
Cbasic_ifstream
Cbasic_ios
Cbasic_iostream
►Cbasic_istream
C_Sentry_base
Csentry
Cbasic_istringstream
Cbasic_ofstream
►Cbasic_ostream
C_Sentry_base
Csentry
Cbasic_ostringstream
Cbasic_regex
Cbasic_streambuf
Cbasic_string
Cbasic_stringbuf
Cbasic_stringstream
CBeginAttribute
►Cbernoulli_distribution
Cparam_type
Cbidirectional_iterator_tag
Cbinary_negate
►Cbinomial_distribution
Cparam_type
Cbit_and
Cbit_and< void >
Cbit_not
Cbit_not< void >
Cbit_or
Cbit_or< void >
Cbit_xor
Cbit_xor< void >
Cbitset
►Ccauchy_distribution
Cparam_type
Cchar_traits
Cchar_traits< char >
Cchar_traits< char16_t >
Cchar_traits< char32_t >
Cchar_traits< wchar_t >
Cchecked_array_iterator
►Cchi_squared_distribution
Cparam_type
Ccodecvt
Ccodecvt< char16_t, char, _Mbstatet >
Ccodecvt< char32_t, char, _Mbstatet >
Ccodecvt< wchar_t, char, _Mbstatet >
Ccodecvt_base
Ccodecvt_byname
Ccodecvt_utf16
Ccodecvt_utf8
Ccodecvt_utf8_utf16
Ccollate
Ccollate_byname
Ccommon_type
Ccommon_type< _Ty >
Ccommon_type< _Ty0, _Ty1 >
Ccommon_type< _Ty0, _Ty1, _Ty...>
Ccommon_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > >
Ccommon_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > >
Ccomplex
Ccomplex< double >
Ccomplex< float >
Ccomplex< long double >
Ccondition_variable
Ccondition_variable_any
Cconditional
Cconditional< true, _Ty1, _Ty2 >
Cconjunction
CContextAttribute
Cctype
Cctype< char >
Cctype< wchar_t >
Cctype_base
Cctype_byname
Cctype_byname< char >
Cdbdatetime4
Cdbnumeric
Cdecay
Cdefault_delete
Cdefault_delete< _Ty[]>
Cdefer_lock_t
CDelayLoadInfo
CDelayLoadProc
Cdeque
CDerefAttribute
Cdiscard_block
Cdiscard_block_engine
►Cdiscrete_distribution
►Cparam_type
C_Noinit
Cdisjunction
Cdivides
Cdivides< void >
Cdomain_error
Cenable_if
Cenable_if< true, _Ty >
Cenable_shared_from_this
CEndAttribute
Cequal_to
Cequal_to< void >
Cerror_category
Cerror_code
Cerror_condition
CExceptAttribute
Cexception
Cexception_ptr
►Cexponential_distribution
Cparam_type
Cextent
►Cextreme_value_distribution
Cparam_type
CF32vec4
CF32vec8
CF64vec2
CF64vec4
►Cfisher_f_distribution
Cparam_type
CFormatStringAttribute
Cforward_iterator_tag
Cforward_list
Cfpos
Cfront_insert_iterator
Cfunction
Cfuture
Cfuture< _Ty & >
Cfuture< void >
Cfuture_error
►Cgamma_distribution
Cparam_type
►Cgeometric_distribution
Cparam_type
Cgreater
Cgreater< void >
Cgreater_equal
Cgreater_equal< void >
Cgslice
Cgslice_array
Chas_virtual_destructor
Chash
Chash< _Ty * >
Chash< basic_string< _Elem, _Traits, _Alloc > >
Chash< bitset< _Bits > >
Chash< bool >
Chash< char >
Chash< char16_t >
Chash< char32_t >
Chash< double >
Chash< error_code >
Chash< float >
Chash< int >
Chash< long >
Chash< long double >
Chash< long long >
Chash< shared_ptr< _Ty > >
Chash< short >
Chash< signed char >
Chash< thread::id >
Chash< type_index >
Chash< unique_ptr< _Ty, _Dx > >
Chash< unsigned char >
Chash< unsigned int >
Chash< unsigned long >
Chash< unsigned long long >
Chash< unsigned short >
Chash< vector< bool, _Alloc > >
CI128vec1
CI16vec8
CI32vec4
CI64vec2
CI8vec16
CImgDelayDescr
Cindependent_bits_engine
Cindirect_array
Cinitializer_list
Cinput_iterator_tag
Cinsert_iterator
Cinteger_sequence
Cintegral_constant
CInternalImgDelayDescr
Cinvalid_argument
CInvalidCheckAttribute
►Cios_base
C_Fnarray
C_Iosarray
Cfailure
CInit
CIs16vec8
CIs32vec4
CIs8vec16
Cis_abstract
Cis_arithmetic
Cis_array
Cis_array< _Ty[]>
Cis_array< _Ty[_Nx]>
Cis_assignable
Cis_base_of
Cis_bind_expression
Cis_bind_expression< _Binder< _Ret, _Fx, _Types...> >
Cis_bind_expression< const _Tx >
Cis_bind_expression< const volatile _Tx >
Cis_bind_expression< volatile _Tx >
Cis_class
Cis_compound
Cis_const
Cis_const< const _Ty >
Cis_constructible
Cis_convertible
Cis_copy_assignable
Cis_copy_constructible
Cis_default_constructible
Cis_destructible
Cis_empty
Cis_enum
Cis_error_code_enum
Cis_error_code_enum< _Future_errc >
Cis_error_code_enum< _Io_errc >
Cis_error_condition_enum
Cis_error_condition_enum< _Errc >
Cis_final
Cis_floating_point
Cis_function
Cis_fundamental
Cis_integral
Cis_literal_type
Cis_lvalue_reference
Cis_lvalue_reference< _Ty & >
Cis_member_function_pointer
Cis_member_object_pointer
Cis_member_pointer
Cis_move_assignable
Cis_move_constructible
Cis_nothrow_assignable
Cis_nothrow_constructible
Cis_nothrow_copy_assignable
Cis_nothrow_copy_constructible
Cis_nothrow_default_constructible
Cis_nothrow_destructible
Cis_nothrow_move_assignable
Cis_nothrow_move_constructible
Cis_null_pointer
Cis_object
Cis_placeholder
Cis_placeholder< _Ph< _Nx > >
Cis_placeholder< const _Tx >
Cis_placeholder< const volatile _Tx >
Cis_placeholder< volatile _Tx >
Cis_pod
Cis_pointer
Cis_polymorphic
Cis_reference
Cis_rvalue_reference
Cis_rvalue_reference< _Ty && >
Cis_same
Cis_same< _Ty1, _Ty1 >
Cis_scalar
Cis_signed
Cis_standard_layout
Cis_trivial
Cis_trivially_assignable
Cis_trivially_constructible
Cis_trivially_copy_assignable
Cis_trivially_copy_constructible
Cis_trivially_copyable
Cis_trivially_default_constructible
Cis_trivially_destructible
Cis_trivially_move_assignable
Cis_trivially_move_constructible
Cis_union
Cis_unsigned
Cis_void
Cis_volatile
Cis_volatile< volatile _Ty >
Cistream_iterator
Cistreambuf_iterator
Cistrstream
Citerator
Citerator_traits
Citerator_traits< _Ty * >
Citerator_traits< const _Ty * >
CIu16vec8
CIu32vec4
CIu8vec16
Clength_error
Cless
Cless< void >
Cless_equal
Cless_equal< void >
Clinear_congruential
Clinear_congruential_engine
Clist
►Clocale
C_Locimp
Cfacet
Cid
Clock_guard
Clock_guard< _Mutex >
Clock_guard<>
Clogic_error
Clogical_and
Clogical_and< void >
Clogical_not
Clogical_not< void >
Clogical_or
Clogical_or< void >
►Clognormal_distribution
Cparam_type
CM128
Cmake_signed
Cmake_unsigned
Cmap
Cmask_array
Cmatch_results
Cmersenne_twister
Cmersenne_twister_engine
Cmessages
Cmessages_base
Cmessages_byname
Cminus
Cminus< void >
Cmodulus
Cmodulus< void >
►Cmoney_base
Cpattern
Cmoney_get
Cmoney_put
Cmoneypunct
Cmoneypunct_byname
Cmove_iterator
Cmultimap
Cmultiplies
Cmultiplies< void >
Cmultiset
Cmutex
Cnegate
Cnegate< void >
Cnegation
►Cnegative_binomial_distribution
Cparam_type
Cnested_exception
►Cnormal_distribution
Cparam_type
Cnot_equal_to
Cnot_equal_to< void >
CNotrefAttribute
Cnum_get
Cnum_put
Cnumeric_limits
Cnumeric_limits< _LONGLONG >
Cnumeric_limits< _ULONGLONG >
Cnumeric_limits< bool >
Cnumeric_limits< char >
Cnumeric_limits< char16_t >
Cnumeric_limits< char32_t >
Cnumeric_limits< const _Ty >
Cnumeric_limits< const volatile _Ty >
Cnumeric_limits< double >
Cnumeric_limits< float >
Cnumeric_limits< int >
Cnumeric_limits< long >
Cnumeric_limits< long double >
Cnumeric_limits< short >
Cnumeric_limits< signed char >
Cnumeric_limits< unsigned char >
Cnumeric_limits< unsigned int >
Cnumeric_limits< unsigned long >
Cnumeric_limits< volatile _Ty >
Cnumeric_limits< wchar_t >
Cnumpunct
Cnumpunct_byname
Conce_flag
Costream_iterator
Costreambuf_iterator
Costrstream
Cout_of_range
Coutput_iterator_tag
Coverflow_error
Cowner_less
Cowner_less< shared_ptr< _Ty > >
Cowner_less< void >
Cowner_less< weak_ptr< _Ty > >
Cpackaged_task
Cpackaged_task< _Ret(_ArgTypes...)>
Cpair
►Cpiecewise_constant_distribution
Cparam_type
Cpiecewise_construct_t
►Cpiecewise_linear_distribution
Cparam_type
Cplus
Cplus< void >
Cpointer_traits
Cpointer_traits< _Ty * >
►Cpoisson_distribution
Cparam_type
CPostAttribute
CPostBoundAttribute
CPostOpAttribute
CPostRangeAttribute
CPreAttribute
CPreBoundAttribute
CPreOpAttribute
CPreRangeAttribute
Cpriority_queue
Cpromise
Cpromise< _Ty & >
Cpromise< void >
Cqueue
Crandom_access_iterator_tag
Crandom_device
Crange_error
Crank
Crank< _Ty[]>
Crank< _Ty[_Ix]>
Cratio
Cratio_equal
Cratio_greater
Cratio_greater_equal
Cratio_less
Cratio_less_equal
Cratio_not_equal
Craw_storage_iterator
Crecursive_mutex
Crecursive_timed_mutex
Creference_wrapper
Cregex_error
Cregex_iterator
Cregex_token_iterator
Cregex_traits
Cregex_traits< char >
Cregex_traits< wchar_t >
Cremove_all_extents
Cremove_all_extents< _Ty[]>
Cremove_all_extents< _Ty[_Ix]>
Cremove_const
Cremove_const< const _Ty >
Cremove_cv
Cremove_extent
Cremove_extent< _Ty[]>
Cremove_extent< _Ty[_Ix]>
Cremove_pointer
Cremove_reference
Cremove_reference< _Ty & >
Cremove_reference< _Ty && >
Cremove_volatile
Cremove_volatile< volatile _Ty >
Cresult_of
Creverse_iterator
Cruntime_error
►Cscoped_allocator_adaptor
Crebind
Cseed_seq
Cset
Cshared_future
Cshared_future< _Ty & >
Cshared_future< void >
Cshared_lock
Cshared_mutex
Cshared_ptr
Cshared_timed_mutex
Cshuffle_order_engine
Cslice
Cslice_array
Csrv_datetime
Csrv_money
Cstack
Cstrstream
Cstrstreambuf
►Cstudent_t_distribution
Cparam_type
Csub_match
Csubtract_with_carry
Csubtract_with_carry_engine
CSuccessAttribute
Csystem_error
►Cthread
Cid
Ctime_base
Ctime_get
Ctime_get_byname
Ctime_put
Ctime_put< wchar_t, _OutIt >
Ctime_put_byname
Ctimed_mutex
Ctry_to_lock_t
Ctuple
Ctuple< _This, _Rest...>
Ctuple<>
Ctuple_element
Ctuple_element< 0, pair< _Ty1, _Ty2 > >
Ctuple_element< 0, tuple< _This, _Rest...> >
Ctuple_element< 1, pair< _Ty1, _Ty2 > >
Ctuple_element< _Idx, array< _Ty, _Size > >
Ctuple_element< _Index, const _Tuple >
Ctuple_element< _Index, const volatile _Tuple >
Ctuple_element< _Index, tuple< _This, _Rest...> >
Ctuple_element< _Index, tuple<> >
Ctuple_element< _Index, volatile _Tuple >
Ctuple_size
Ctuple_size< array< _Ty, _Size > >
Ctuple_size< const _Tuple >
Ctuple_size< const volatile _Tuple >
Ctuple_size< pair< _Ty1, _Ty2 > >
Ctuple_size< tuple< _Types...> >
Ctuple_size< volatile _Tuple >
Ctype_index
Ctype_info
CTypefixAttribute
Cunary_negate
Cunchecked_array_iterator
Cunderflow_error
Cunderlying_type
►Cuniform_int
Cparam_type
►Cuniform_int_distribution
Cparam_type
►Cuniform_real
Cparam_type
►Cuniform_real_distribution
Cparam_type
Cunique_lock
Cunique_ptr
Cunique_ptr< _Ty[], _Dx >
Cunordered_map
Cunordered_multimap
Cunordered_multiset
Cunordered_set
Cvalarray
Cvector
Cvector< bool, _Alloc >
CVsgDbg
Cwbuffer_convert
Cweak_ptr
►Cweibull_distribution
Cparam_type
CWhenAttribute
Cwstring_convert
Cxtime