CPP 官方文档

Language

#define directive

#error directive

#include directive

#line directive

#pragma directive

access specifiers

Address of an overloaded function

aggregate initialization

alignas specifier

alignof operator

Alternative operator representations

Argument-dependent lookup

Arithmetic operators

Array declaration

asm declaration

Assignment operators

attribute specifier sequence(since C++11)

Boolean literals

break statement

character literal

Class declaration

Class template deduction(since C++17)

Comparison operators

Conditional inclusion

Constant expressions

constant initialization

constexpr specifier

Constraints and concepts

Constructors and member initializer lists

const_cast conversion

continue statement

Converting constructor

Copy assignment operator

Copy constructors

copy initialization

cv type qualifiers

Declaring functions

decltype specifier

Default arguments

Default constructors

default initialization

Definitions and ODR

delete expression

Dependent names

Derived classes

direct initialization

dynamic exception specification

dynamic_cast conversion

Elaborated type specifier

Empty base optimization

enumeration declaration

Escape sequences

explicit specifier

explicit template specialization

Explicit type conversion

final specifier

floating point literal

fold expression

friend declaration

Function template

Function-try-block

Fundamental types

Implicit conversions

Increment/decrement operators

inline specifier

integer literal

Lambda expressions

Language linkage

list initialization

Logical operators

Member access operators

Member templates

Move assignment operator

Move constructors

Namespace aliases

noexcept operator

noexcept specifier

Non-static data members

Non-static member functions

operator overloading

Operator Precedence

Order of evaluation

Other operators

Overload resolution

override specifier

partial template specialization

Phases of translation

Pointer declaration

Qualified name lookup

Range-based for loop

Reference declaration

reference initialization

reinterpret_cast conversion

return statement

sizeof operator

sizeof... operator

Static Assertion

static_cast conversion

Storage class specifiers

switch statement

Template argument deduction

Template parameters and template arguments

The rule of three/five/zero

throw expression

Transactional memory

typedef specifier

typeid operator

Undefined behavior

Union declaration

Unqualified name lookup

user-defined conversion

User-defined literals

Using-declaration

Value categories

value initialization

Variable template

Variadic arguments

virtual function specifier

zero initialization

Standard library header files

Algorithms library

std::accumulate

std::adjacent_difference

std::adjacent_find

std::binary_search

std::copy_backward

std::equal_range

std::exclusive_scan

std::execution::par

std::execution::parallel_policy

std::find_first_of

std::for_each_n

std::generate_n

std::inclusive_scan

std::inner_product

std::inplace_merge

std::is_execution_policy

std::is_heap_until

std::is_partitioned

std::is_permutation

std::is_sorted_until

std::lexicographical_compare

std::lower_bound

std::max_element

std::minmax_element

std::min_element

std::move_backward

std::next_permutation

std::nth_element

std::partial_sort

std::partial_sort_copy

std::partial_sum

std::partition_copy

std::partition_point

std::prev_permutation

std::random_shuffle

std::remove_copy

std::replace_copy

std::reverse_copy

std::rotate_copy

std::set_difference

std::set_intersection

std::set_symmetric_difference

std::stable_partition

std::stable_sort

std::swap_ranges

std::transform_exclusive_scan

std::transform_inclusive_scan

std::transform_reduce

std::unique_copy

std::upper_bound

condition_variable

Filesystem library

operators (std::filesystem::path)

operators (std::filesystem::path)

std::filesystem::absolute

std::filesystem::begin(directory_iterator)

std::filesystem::begin(recursive_directory_iterator)

std::filesystem::canonical

std::filesystem::copy

std::filesystem::copy_file

std::filesystem::copy_options

std::filesystem::copy_symlink

std::filesystem::create_directories

std::filesystem::create_directory_symlink

std::filesystem::create_hard_link

std::filesystem::current_path

std::filesystem::directory_entry

std::filesystem::directory_entry::assign

std::filesystem::directory_entry::directory_entry

std::filesystem::directory_entry::operators

std::filesystem::directory_entry::path

std::filesystem::directory_entry::replace_filename

std::filesystem::directory_entry::status

std::filesystem::directory_iterator

std::filesystem::directory_iterator::directory_iterator

std::filesystem::directory_iterator::operator->

std::filesystem::directory_iterator::operator=

std::filesystem::directory_options

std::filesystem::equivalent

std::filesystem::exists

std::filesystem::filesystem_error

std::filesystem::filesystem_error::filesystem_error

std::filesystem::filesystem_error::path1

std::filesystem::filesystem_error::what

std::filesystem::file_size

std::filesystem::file_status

std::filesystem::file_status::file_status

std::filesystem::file_status::permissions

std::filesystem::file_status::type

std::filesystem::file_time_type

std::filesystem::file_type

std::filesystem::hard_link_count

std::filesystem::hash_value

std::filesystem::is_block_file

std::filesystem::is_character_file

std::filesystem::is_directory

std::filesystem::is_empty

std::filesystem::is_fifo

std::filesystem::is_other

std::filesystem::is_regular_file

std::filesystem::is_socket

std::filesystem::is_symlink

std::filesystem::last_write_time

std::filesystem::operator/(std::filesystem::path)

std::filesystem::path

std::filesystem::path::append

std::filesystem::path::assign

std::filesystem::path::begin

std::filesystem::path::clear

std::filesystem::path::compare

std::filesystem::path::concat

std::filesystem::path::c_str

std::filesystem::path::empty

std::filesystem::path::extension

std::filesystem::path::filename

std::filesystem::path::generic_string

std::filesystem::path::has_root_directory

std::filesystem::path::lexically_normal

std::filesystem::path::make_preferred

std::filesystem::path::parent_path

std::filesystem::path::path

std::filesystem::path::relative_path

std::filesystem::path::remove_filename

std::filesystem::path::replace_extension

std::filesystem::path::replace_filename

std::filesystem::path::root_directory

std::filesystem::path::root_name

std::filesystem::path::root_path

std::filesystem::path::stem

std::filesystem::path::string

std::filesystem::path::swap

std::filesystem::permissions

std::filesystem::perms

std::filesystem::proximate

std::filesystem::read_symlink

std::filesystem::recursive_directory_iterator

std::filesystem::recursive_directory_iterator::depth

std::filesystem::recursive_directory_iterator::disable_recursion_pending

std::filesystem::recursive_directory_iterator::increment

std::filesystem::recursive_directory_iterator::operator->

std::filesystem::recursive_directory_iterator::options

std::filesystem::recursive_directory_iterator::pop

std::filesystem::recursive_directory_iterator::recursion_pending

std::filesystem::recursive_directory_iterator::recursive_directory_iterator

std::filesystem::remove

std::filesystem::rename

std::filesystem::resize_file

std::filesystem::space

std::filesystem::space_info

std::filesystem::status

std::filesystem::status_known

std::filesystem::swap(std::filesystem::path)

std::filesystem::temp_directory_path

std::filesystem::u8path

initializer_list

memory_resource

scoped_allocator

Keywords

reinterpret_cast

Concepts

AllocatorAwareContainer

AssociativeContainer

BidirectionalIterator

BinaryPredicate

CopyConstructible

DefaultConstructible

DefaultInsertable

EmplaceConstructible

EqualityComparable

FormattedInputFunction

FormattedOutputFunction

ForwardIterator

Iterator library

operator-(move_iterator)

operator-(reverse_iterator)

operators (std::istreambuf_iterator)

operators (std::istream_iterator)

operators (std::move_iterator)

operators (std::reverse_iterator)

std::back_inserter

std::back_insert_iterator

std::back_insert_iterator::back_insert_iterator

std::back_insert_iterator::operator*

std::bidirectional_iterator_tag

std::front_inserter

std::front_insert_iterator

std::front_insert_iterator::front_insert_iterator

std::front_insert_iterator::operator*

std::insert_iterator

std::insert_iterator::insert_iterator

std::insert_iterator::operator*

std::istreambuf_iterator

std::istreambuf_iterator::equal

std::istreambuf_iterator::istreambuf_iterator

std::istreambuf_iterator::operators (int)

std::istreambuf_iterator::operators (operator->)

std::istream_iterator

std::istream_iterator::istream_iterator

std::istream_iterator::operators (int)

std::istream_iterator::operators (operator->)

std::iterator_traits

std::make_move_iterator

std::make_reverse_iterator

std::move_iterator

std::move_iterator::base

std::move_iterator::move_iterator

std::move_iterator::operators

std::move_iterator::operators

std::move_iterator::operator[]

std::ostreambuf_iterator

std::ostreambuf_iterator::failed

std::ostreambuf_iterator::operator*

std::ostreambuf_iterator::operator++

std::ostreambuf_iterator::ostreambuf_iterator

std::ostream_iterator

std::ostream_iterator::operator*

std::ostream_iterator::operator++

std::ostream_iterator::ostream_iterator

std::reverse_iterator

std::reverse_iterator::base

std::reverse_iterator::operators

std::reverse_iterator::operators

std::reverse_iterator::operator[]

std::reverse_iterator::reverse_iterator

LessThanComparable

Library Concepts

MoveConstructible

NullablePointer

RandomAccessIterator

RandomNumberDistribution

ReversibleContainer

SequenceContainer

SharedTimedMutex

StandardLayoutType

TriviallyCopyable

UnformattedInputFunction

UnformattedOutputFunction

UniformRandomBitGenerator

UnorderedAssociativeContainer

Utilities

C Date and time utilities

C memory management library

C numeric limits interface

Date and time utilities

Dynamic memory management

operators (std::allocator)

operators (std::scoped_allocator_adaptor)

std::allocator::address

std::allocator::allocate

std::allocator::allocator

std::allocator::construct

std::allocator::deallocate

std::allocator::destroy

std::allocator::max_size

std::allocator_traits

std::allocator_traits::allocate

std::allocator_traits::construct

std::allocator_traits::deallocate

std::allocator_traits::destroy

std::allocator_traits::max_size

std::allocator_traits::select_on_container_copy_construction

std::pmr::memory_resource

std::pmr::memory_resource::allocate

std::pmr::memory_resource::deallocate

std::pmr::memory_resource::do_allocate

std::pmr::memory_resource::do_deallocate

std::pmr::memory_resource::do_is_equal

std::pmr::memory_resource::is_equal

std::pmr::memory_resource::memory_resource

std::pmr::monotonic_buffer_resource

std::pmr::monotonic_buffer_resource::do_allocate

std::pmr::monotonic_buffer_resource::do_deallocate

std::pmr::monotonic_buffer_resource::do_is_equal

std::pmr::monotonic_buffer_resource::monotonic_buffer_resource

std::pmr::monotonic_buffer_resource::release

std::pmr::monotonic_buffer_resource::upstream_resource

std::pmr::operator!=

std::pmr::operator!=

std::pmr::polymorphic_allocator

std::pmr::polymorphic_allocator::allocate

std::pmr::polymorphic_allocator::construct

std::pmr::polymorphic_allocator::deallocate

std::pmr::polymorphic_allocator::destroy

std::pmr::polymorphic_allocator::polymorphic_allocator

std::pmr::polymorphic_allocator::resource

std::pmr::polymorphic_allocator::select_on_container_copy_construction

std::pmr::synchronized_pool_resource

std::pmr::synchronized_pool_resource::do_allocate

std::pmr::synchronized_pool_resource::do_deallocate

std::pmr::synchronized_pool_resource::do_is_equal

std::pmr::synchronized_pool_resource::options

std::pmr::synchronized_pool_resource::release

std::pmr::synchronized_pool_resource::synchronized_pool_resource

std::pmr::synchronized_pool_resource::upstream_resource

std::pmr::unsynchronized_pool_resource

std::pmr::unsynchronized_pool_resource::do_allocate

std::pmr::unsynchronized_pool_resource::do_deallocate

std::pmr::unsynchronized_pool_resource::do_is_equal

std::pmr::unsynchronized_pool_resource::options

std::pmr::unsynchronized_pool_resource::release

std::pmr::unsynchronized_pool_resource::unsynchronized_pool_resource

std::pmr::unsynchronized_pool_resource::upstream_resource

std::pointer_traits::pointer_to

std::raw_storage_iterator

std::raw_storage_iterator::base

std::raw_storage_iterator::operator*

std::raw_storage_iterator::operators (int)

std::raw_storage_iterator::raw_storage_iterator

std::scoped_allocator_adaptor

std::scoped_allocator_adaptor::allocate

std::scoped_allocator_adaptor::construct

std::scoped_allocator_adaptor::deallocate

std::scoped_allocator_adaptor::destroy

std::scoped_allocator_adaptor::inner_allocator

std::scoped_allocator_adaptor::max_size

std::scoped_allocator_adaptor::outer_allocator

std::scoped_allocator_adaptor::scoped_allocator_adaptor

std::scoped_allocator_adaptor::select_on_container_copy_construction

Fixed width integer types

FLT_EVAL_METHOD

Function objects

Low level memory management

operators (delete[])

operators (new[])

operators (std::bitset)

operators (std::bitset)

operators (std::bitset)

operators (std::chrono::duration)

operators (std::chrono::duration)

operators (std::error_condition)

operators (std::function)

operators (std::optional)

operators (std::pair)

operators (std::time_point)

operators (std::time_point)

operators (std::tuple)

operators (std::unique_ptr)

operators (std::variant)

Program support utilities

std::add_lvalue_reference

std::add_pointer

std::aligned_alloc

std::aligned_storage

std::aligned_union

std::alignment_of

std::align_val_t

std::allocate_shared

std::allocator_arg

std::allocator_arg_t

std::any::emplace

std::any::has_value

std::any::reset

std::atomic_...<std::shared_ptr>

std::at_quick_exit

std::auto_ptr::auto_ptr

std::auto_ptr::get

std::auto_ptr::operator auto_ptr<Y>

std::auto_ptr::operator->

std::auto_ptr::release

std::auto_ptr::reset

std::bad_any_cast

std::bad_array_new_length

std::bad_array_new_length::bad_array_new_length

std::bad_cast::bad_cast

std::bad_exception

std::bad_exception::bad_exception

std::bad_exception::what

std::bad_function_call

std::bad_optional_access

std::bad_typeid

std::bad_typeid::bad_typeid

std::bad_variant_access

std::bad_weak_ptr

std::bad_weak_ptr::bad_weak_ptr

std::begin(std::initializer_list)

std::binary_function

std::binary_negate

std::bitset::all

std::bitset::bitset

std::bitset::count

std::bitset::flip

std::bitset::operators

std::bitset::operators

std::bitset::operator[]

std::bitset::reference

std::bitset::reset

std::bitset::set

std::bitset::size

std::bitset::test

std::bitset::to_string

std::bitset::to_ullong

std::bitset::to_ulong

std::bit_and<void>

std::bit_not<void>

std::bit_or<void>

std::bit_xor<void>

std::boyer_moore_horspool_searcher

std::boyer_moore_searcher

std::chars_format

std::chrono::abs(std::chrono::duration)

std::chrono::ceil(std::chrono::duration)

std::chrono::ceil(std::chrono::time_point)

std::chrono::duration

std::chrono::duration::count

std::chrono::duration::duration

std::chrono::duration::max

std::chrono::duration::min

std::chrono::duration::operator-

std::chrono::duration::operator--

std::chrono::duration::operators (%=)

std::chrono::duration::zero

std::chrono::duration_cast

std::chrono::duration_values

std::chrono::duration_values::max

std::chrono::duration_values::min

std::chrono::duration_values::zero

std::chrono::floor(std::chrono::duration)

std::chrono::floor(std::chrono::time_point)

std::chrono::high_resolution_clock

std::chrono::high_resolution_clock::now

std::chrono::round(std::chrono::duration)

std::chrono::round(std::chrono::time_point)

std::chrono::steady_clock

std::chrono::steady_clock::now

std::chrono::system_clock

std::chrono::system_clock::from_time_t

std::chrono::system_clock::now

std::chrono::system_clock::to_time_t

std::chrono::time_point

std::chrono::time_point::max

std::chrono::time_point::min

std::chrono::time_point::operators (operator-)

std::chrono::time_point::time_point

std::chrono::time_point::time_since_epoch

std::chrono::time_point_cast

std::chrono::treat_as_floating_point

std::common_type

std::common_type(std::chrono::duration)

std::common_type(std::chrono::time_point)

std::conditional

std::conjunction

std::const_mem_fun1_ref_t

std::const_mem_fun1_t

std::const_pointer_cast

std::current_exception

std::declare_no_pointers

std::declare_reachable

std::default_delete

std::default_searcher

std::destroy_at

std::disjunction

std::divides<void>

std::domain_error

std::enable_shared_from_this

std::enable_shared_from_this::enable_shared_from_this

std::enable_shared_from_this::shared_from_this

std::enable_shared_from_this::weak_from_this

std::end(std::initializer_list)

std::equal_to<void>

std::error_category

std::error_category::default_error_condition

std::error_category::equivalent

std::error_category::error_category

std::error_category::message

std::error_category::name

std::error_category::operators

std::error_code

std::error_code::assign

std::error_code::category

std::error_code::clear

std::error_code::default_error_condition

std::error_code::error_code

std::error_code::message

std::error_code::operator bool

std::error_code::value

std::error_condition

std::error_condition::assign

std::error_condition::category

std::error_condition::clear

std::error_condition::error_condition

std::error_condition::message

std::error_condition::operator bool

std::error_condition::value

std::exception::exception

std::exception::what

std::exception_ptr

std::float_denorm_style

std::float_round_style

std::forward_as_tuple

std::from_chars

std::function::assign

std::function::function

std::function::operator bool

std::function::swap

std::function::target

std::function::target_type

std::generic_category

std::get(std::pair)

std::get(std::tuple)

std::get_deleter

std::get_new_handler

std::get_pointer_safety

std::get_temporary_buffer

std::get_terminate

std::get_unexpected

std::greater<void>

std::greater_equal

std::greater_equal<void>

std::hash <std::optional>

std::hash <std::unique_ptr>

std::hash <std::variant>

std::hash(std::shared_ptr)

std::hash::hash

std::hash<std::error_code>

std::hash<std::error_condition>

std::hash<std::type_index>

std::has_unique_object_representations

std::has_virtual_destructor

std::holds_alternative

std::initializer_list

std::initializer_list::begin

std::initializer_list::end

std::initializer_list::initializer_list

std::initializer_list::size

std::integer_sequence

std::integral_constant

std::invalid_argument

std::invoke_result

std::in_place_t

std::is_abstract

std::is_aggregate

std::is_arithmetic

std::is_assignable

std::is_base_of

std::is_bind_expression

std::is_compound

std::is_constructible

std::is_convertible

std::is_copy_assignable

std::is_copy_constructible

std::is_default_constructible

std::is_destructible

std::is_error_code_enum

std::is_error_code_enum<std::future_errc>

std::is_error_condition_enum

std::is_error_condition_enum<std::errc>

std::is_floating_point

std::is_function

std::is_fundamental

std::is_integral

std::is_invocable

std::is_literal_type

std::is_lvalue_reference

std::is_member_function_pointer

std::is_member_object_pointer

std::is_member_pointer

std::is_move_assignable

std::is_move_constructible

std::is_nothrow_swappable

std::is_null_pointer

std::is_placeholder

std::is_pointer

std::is_polymorphic

std::is_reference

std::is_rvalue_reference

std::is_standard_layout

std::is_trivial

std::is_trivially_copyable

std::is_unsigned

std::is_volatile

std::length_error

std::less<void>

std::less_equal

std::less_equal<void>

std::literals::chrono_literals::operator""h

std::literals::chrono_literals::operator""min

std::literals::chrono_literals::operator""ms

std::literals::chrono_literals::operator""ns

std::literals::chrono_literals::operator""s

std::literals::chrono_literals::operator""us

std::logical_and

std::logical_and<void>

std::logical_not

std::logical_not<void>

std::logical_or

std::logical_or<void>

std::logic_error

std::make_error_code(std::errc)

std::make_error_condition(std::errc)

std::make_exception_ptr

std::make_from_tuple

std::make_optional

std::make_shared

std::make_signed

std::make_tuple

std::make_unique

std::make_unsigned

std::max_align_t

std::mem_fun_ref

std::minus<void>

std::modulus<void>

std::move_if_noexcept

std::multiplies

std::multiplies<void>

std::negate<void>

std::nested_exception

std::nested_exception::nested_exception

std::nested_exception::nested_ptr

std::nested_exception::rethrow_nested

std::new_handler

std::not_equal_to

std::not_equal_to<void>

std::numeric_limits

std::numeric_limits::denorm_min

std::numeric_limits::digits

std::numeric_limits::digits10

std::numeric_limits::epsilon

std::numeric_limits::has_denorm

std::numeric_limits::has_denorm_loss

std::numeric_limits::has_infinity

std::numeric_limits::has_quiet_NaN

std::numeric_limits::has_signaling_NaN

std::numeric_limits::infinity

std::numeric_limits::is_bounded

std::numeric_limits::is_exact

std::numeric_limits::is_iec559

std::numeric_limits::is_integer

std::numeric_limits::is_modulo

std::numeric_limits::is_signed

std::numeric_limits::is_specialized

std::numeric_limits::lowest

std::numeric_limits::max

std::numeric_limits::max_digits10

std::numeric_limits::max_exponent

std::numeric_limits::max_exponent10

std::numeric_limits::min

std::numeric_limits::min_exponent

std::numeric_limits::min_exponent10

std::numeric_limits::quiet_NaN

std::numeric_limits::radix

std::numeric_limits::round_error

std::numeric_limits::round_style

std::numeric_limits::signaling_NaN

std::numeric_limits::tinyness_before

std::numeric_limits::traps

std::operator<<(std::error_code)

std::operators (std::error_code)

std::optional::emplace

std::optional::has_value

std::optional::operator*

std::optional::optional

std::optional::reset

std::optional::swap

std::optional::value

std::optional::value_or

std::out_of_range

std::overflow_error

std::owner_less

std::owner_less

std::pair::pair

std::pair::swap

std::piecewise_construct

std::piecewise_construct_t

std::placeholders::_1

std::plus<void>

std::pmr::get_default_resource

std::pmr::new_delete_resource

std::pmr::null_memory_resource

std::pmr::pool_options

std::pmr::set_default_resource

std::pointer_safety

std::pointer_to_binary_function

std::pointer_to_unary_function

std::pointer_traits

std::quick_exit

std::range_error

std::rbegin(std::initializer_list)

std::reference_wrapper

std::reference_wrapper::get

std::reference_wrapper::reference_wrapper

std::rel_ops::operators

std::remove_all_extents

std::remove_const

std::remove_extent

std::remove_pointer

std::remove_reference

std::rend(std::initializer_list)

std::rethrow_exception

std::rethrow_if_nested

std::return_temporary_buffer

std::runtime_error

std::set_new_handler

std::set_terminate

std::set_unexpected

std::shared_ptr

std::shared_ptr::get

std::shared_ptr::operator bool

std::shared_ptr::operator->

std::shared_ptr::operator<<

std::shared_ptr::operators (>=)

std::shared_ptr::operator[]

std::shared_ptr::owner_before

std::shared_ptr::reset

std::shared_ptr::shared_ptr

std::shared_ptr::swap

std::shared_ptr::unique

std::shared_ptr::use_count

std::sig_atomic_t

std::swap(std::any)

std::swap(std::function)

std::swap(std::optional)

std::swap(std::pair)

std::swap(std::shared_ptr)

std::swap(std::tuple)

std::swap(std::unique_ptr)

std::swap(std::variant)

std::swap(std::weak_ptr)

std::system_category

std::system_error

std::system_error::code

std::system_error::system_error

std::system_error::what

std::terminate_handler

std::throw_with_nested

std::timespec_get

std::tuple::swap

std::tuple::tuple

std::tuple_element<std::pair>

std::tuple_element<std::tuple>

std::tuple_size<std::pair>

std::tuple_size<std::tuple>

std::tx_exception

std::type_index

std::type_index::hash_code

std::type_index::name

std::type_index::operators

std::type_index::type_index

std::type_info::before

std::type_info::hash_code

std::type_info::name

std::type_info::operator!=

std::unary_function

std::unary_negate

std::uncaught_exception

std::undeclare_no_pointers

std::undeclare_reachable

std::underflow_error

std::underlying_type

std::unexpected

std::unexpected_handler

std::uninitialized_copy

std::uninitialized_copy_n

std::uninitialized_default_construct

std::uninitialized_default_construct_n

std::uninitialized_fill

std::uninitialized_fill_n

std::uninitialized_move

std::uninitialized_move_n

std::uninitialized_value_construct

std::uninitialized_value_construct_n

std::unique_ptr

std::unique_ptr::get

std::unique_ptr::get_deleter

std::unique_ptr::operator bool

std::unique_ptr::operator*

std::unique_ptr::operator[]

std::unique_ptr::release

std::unique_ptr::reset

std::unique_ptr::swap

std::unique_ptr::unique_ptr

std::uses_allocator

std::uses_allocator<std::function>

std::uses_allocator<std::tuple>

std::uses_allocator<std::variant>

std::variant::emplace

std::variant::index

std::variant::swap

std::variant::valueless_by_exception

std::variant::variant

std::variant_alternative

std::variant_npos

std::variant_size

std::weak_ptr::expired

std::weak_ptr::lock

std::weak_ptr::owner_before

std::weak_ptr::reset

std::weak_ptr::swap

std::weak_ptr::use_count

std::weak_ptr::weak_ptr

Utility library

Variadic functions

Atomic operations

Atomic operations library

ATOMIC_FLAG_INIT

ATOMIC_VAR_INIT

ATOMIC_xxx_LOCK_FREE

std::atomic::atomic

std::atomic::compare_exchange_strong

std::atomic::exchange

std::atomic::fetch_add

std::atomic::fetch_and

std::atomic::fetch_or

std::atomic::fetch_sub

std::atomic::fetch_xor

std::atomic::is_always_lock_free

std::atomic::is_lock_free

std::atomic::load

std::atomic::operator T()

std::atomic::operators

std::atomic::operators (int)

std::atomic::store

std::atomic_compare_exchange_strong

std::atomic_exchange

std::atomic_fetch_add

std::atomic_fetch_and

std::atomic_fetch_or

std::atomic_fetch_sub

std::atomic_fetch_xor

std::atomic_flag

std::atomic_flag::atomic_flag

std::atomic_flag::clear

std::atomic_flag::test_and_set

std::atomic_flag_clear

std::atomic_flag_test_and_set

std::atomic_init

std::atomic_load

std::atomic_signal_fence

std::atomic_store

std::atomic_thread_fence

std::kill_dependency

std::memory_order

Numerics

Common mathematical functions

Compile-time rational arithmetic

Floating-point environment

Mathematical special functions

Numerics library

operators (std::bernoulli_distribution)

operators (std::bernoulli_distribution)

operators (std::binomial_distribution)

operators (std::binomial_distribution)

operators (std::cauchy_distribution)

operators (std::cauchy_distribution)

operators (std::chi_squared_distribution)

operators (std::chi_squared_distribution)

operators (std::complex)

operators (std::complex)

operators (std::discard_block_engine)

operators (std::discard_block_engine)

operators (std::discrete_distribution)

operators (std::discrete_distribution)

operators (std::exponential_distribution)

operators (std::exponential_distribution)

operators (std::extreme_value_distribution)

operators (std::extreme_value_distribution)

operators (std::fisher_f_distribution)

operators (std::fisher_f_distribution)

operators (std::gamma_distribution)

operators (std::gamma_distribution)

operators (std::geometric_distribution)

operators (std::geometric_distribution)

operators (std::independent_bits_engine)

operators (std::independent_bits_engine)

operators (std::linear_congruential_engine)

operators (std::linear_congruential_engine)

operators (std::lognormal_distribution)

operators (std::lognormal_distribution)

operators (std::mersenne_twister_engine)

operators (std::mersenne_twister_engine)

operators (std::negative_binomial_distribution)

operators (std::negative_binomial_distribution)

operators (std::normal_distribution)

operators (std::normal_distribution)

operators (std::piecewise_constant_distribution)

operators (std::piecewise_constant_distribution)

operators (std::piecewise_linear_distribution)

operators (std::piecewise_linear_distribution)

operators (std::poisson_distribution)

operators (std::poisson_distribution)

operators (std::shuffle_order_engine)

operators (std::shuffle_order_engine)

operators (std::student_t_distribution)

operators (std::student_t_distribution)

operators (std::subtract_with_carry_engine)

operators (std::subtract_with_carry_engine)

operators (std::uniform_int_distribution)

operators (std::uniform_int_distribution)

operators (std::uniform_real_distribution)

operators (std::uniform_real_distribution)

operators (std::valarray)

operators (std::weibull_distribution)

operators (std::weibull_distribution)

Pseudo-random number generation

std::abs(float)

std::abs(std::complex)

std::abs(std::valarray)

std::acos(std::complex)

std::acos(std::valarray)

std::acosh(std::complex)

std::arg(std::complex)

std::asin(std::complex)

std::asin(std::valarray)

std::asinh(std::complex)

std::assoc_laguerre

std::assoc_legendre

std::atan(std::complex)

std::atan(std::valarray)

std::atan2(std::valarray)

std::atanh(std::complex)

std::begin(std::valarray)

std::bernoulli_distribution

std::bernoulli_distribution::bernoulli_distribution

std::bernoulli_distribution::max

std::bernoulli_distribution::min

std::bernoulli_distribution::p

std::bernoulli_distribution::param

std::bernoulli_distribution::reset

std::binomial_distribution

std::binomial_distribution::binomial_distribution

std::binomial_distribution::max

std::binomial_distribution::min

std::binomial_distribution::p

std::binomial_distribution::param

std::binomial_distribution::reset

std::cauchy_distribution

std::cauchy_distribution::a

std::cauchy_distribution::cauchy_distribution

std::cauchy_distribution::max

std::cauchy_distribution::min

std::cauchy_distribution::param

std::cauchy_distribution::reset

std::chi_squared_distribution

std::chi_squared_distribution::chi_squared_distribution

std::chi_squared_distribution::max

std::chi_squared_distribution::min

std::chi_squared_distribution::n

std::chi_squared_distribution::param

std::chi_squared_distribution::reset

std::complex::complex

std::complex::imag

std::complex::operators

std::complex::operators (unary)

std::complex::real

std::comp_ellint_1

std::comp_ellint_2

std::comp_ellint_3

std::conj(std::complex)

std::cos(std::complex)

std::cos(std::valarray)

std::cosh(std::complex)

std::cosh(std::valarray)

std::cyl_bessel_i

std::cyl_bessel_j

std::cyl_bessel_k

std::cyl_neumann

std::discard_block_engine

std::discard_block_engine::base

std::discard_block_engine::discard

std::discard_block_engine::discard_block_engine

std::discard_block_engine::max

std::discard_block_engine::min

std::discard_block_engine::seed

std::discrete_distribution

std::discrete_distribution::discrete_distribution

std::discrete_distribution::max

std::discrete_distribution::min

std::discrete_distribution::param

std::discrete_distribution::probabilities

std::discrete_distribution::reset

std::end(std::valarray)

std::exp(std::complex)

std::exp(std::valarray)

std::exponential_distribution

std::exponential_distribution::exponential_distribution

std::exponential_distribution::lambda

std::exponential_distribution::max

std::exponential_distribution::min

std::exponential_distribution::param

std::exponential_distribution::reset

std::extreme_value_distribution

std::extreme_value_distribution::a

std::extreme_value_distribution::extreme_value_distribution

std::extreme_value_distribution::max

std::extreme_value_distribution::min

std::extreme_value_distribution::param

std::extreme_value_distribution::reset

std::feclearexcept

std::fegetexceptflag

std::fegetround

std::feholdexcept

std::feraiseexcept

std::fetestexcept

std::feupdateenv

std::fisher_f_distribution

std::fisher_f_distribution::fisher_f_distribution

std::fisher_f_distribution::m

std::fisher_f_distribution::max

std::fisher_f_distribution::min

std::fisher_f_distribution::param

std::fisher_f_distribution::reset

std::fpclassify

std::gamma_distribution

std::gamma_distribution::gamma_distribution

std::gamma_distribution::max

std::gamma_distribution::min

std::gamma_distribution::param

std::gamma_distribution::reset

std::generate_canonical

std::geometric_distribution

std::geometric_distribution::geometric_distribution

std::geometric_distribution::max

std::geometric_distribution::min

std::geometric_distribution::p

std::geometric_distribution::param

std::geometric_distribution::reset

std::gslice_array

std::gslice_array::gslice_array

std::gslice_array::operators

std::imag(std::complex)

std::independent_bits_engine

std::independent_bits_engine::base

std::independent_bits_engine::discard

std::independent_bits_engine::independent_bits_engine

std::independent_bits_engine::max

std::independent_bits_engine::min

std::independent_bits_engine::seed

std::indirect_array

std::indirect_array::indirect_array

std::indirect_array::operators

std::isgreaterequal

std::islessequal

std::islessgreater

std::isunordered

std::linear_congruential_engine

std::linear_congruential_engine::discard

std::linear_congruential_engine::linear_congruential_engine

std::linear_congruential_engine::max

std::linear_congruential_engine::min

std::linear_congruential_engine::seed

std::literals::complex_literals::operators

std::log(std::complex)

std::log(std::valarray)

std::log10(std::complex)

std::log10(std::valarray)

std::lognormal_distribution

std::lognormal_distribution::lognormal_distribution

std::lognormal_distribution::m

std::lognormal_distribution::max

std::lognormal_distribution::min

std::lognormal_distribution::param

std::lognormal_distribution::reset

std::mask_array

std::mask_array::mask_array

std::mask_array::operators

std::mersenne_twister_engine

std::mersenne_twister_engine::discard

std::mersenne_twister_engine::max

std::mersenne_twister_engine::mersenne_twister_engine

std::mersenne_twister_engine::min

std::mersenne_twister_engine::seed

std::negative_binomial_distribution

std::negative_binomial_distribution::max

std::negative_binomial_distribution::min

std::negative_binomial_distribution::negative_binomial_distribution

std::negative_binomial_distribution::p

std::negative_binomial_distribution::param

std::negative_binomial_distribution::reset

std::norm(std::complex)

std::normal_distribution

std::normal_distribution::max

std::normal_distribution::mean

std::normal_distribution::min

std::normal_distribution::normal_distribution

std::normal_distribution::param

std::normal_distribution::reset

std::piecewise_constant_distribution

std::piecewise_constant_distribution::max

std::piecewise_constant_distribution::min

std::piecewise_constant_distribution::param

std::piecewise_constant_distribution::piecewise_constant_distribution

std::piecewise_constant_distribution::reset

std::piecewise_linear_distribution

std::piecewise_linear_distribution::max

std::piecewise_linear_distribution::min

std::piecewise_linear_distribution::param

std::piecewise_linear_distribution::piecewise_linear_distribution

std::piecewise_linear_distribution::reset

std::poisson_distribution

std::poisson_distribution::max

std::poisson_distribution::mean

std::poisson_distribution::min

std::poisson_distribution::param

std::poisson_distribution::poisson_distribution

std::poisson_distribution::reset

std::polar(std::complex)

std::pow(std::complex)

std::pow(std::valarray)

std::proj(std::complex)

std::random_device

std::random_device::entropy

std::random_device::max

std::random_device::min

std::random_device::random_device

std::ratio_divide

std::ratio_equal

std::ratio_greater

std::ratio_greater_equal

std::ratio_less

std::ratio_less_equal

std::ratio_multiply

std::ratio_not_equal

std::ratio_subtract

std::real(std::complex)

std::riemann_zeta

std::seed_seq::generate

std::seed_seq::param

std::seed_seq::seed_seq

std::seed_seq::size

std::shuffle_order_engine

std::shuffle_order_engine::base

std::shuffle_order_engine::discard

std::shuffle_order_engine::max

std::shuffle_order_engine::min

std::shuffle_order_engine::seed

std::shuffle_order_engine::shuffle_order_engine

std::sin(std::complex)

std::sin(std::valarray)

std::sinh(std::complex)

std::sinh(std::valarray)

std::slice_array

std::slice_array::operators

std::slice_array::slice_array

std::sph_bessel

std::sph_legendre

std::sph_neumann

std::sqrt(std::complex)

std::sqrt(std::valarray)

std::student_t_distribution

std::student_t_distribution::max

std::student_t_distribution::min

std::student_t_distribution::n

std::student_t_distribution::param

std::student_t_distribution::reset

std::student_t_distribution::student_t_distribution

std::subtract_with_carry_engine

std::subtract_with_carry_engine::discard

std::subtract_with_carry_engine::max

std::subtract_with_carry_engine::min

std::subtract_with_carry_engine::seed

std::subtract_with_carry_engine::subtract_with_carry_engine

std::swap(std::valarray)

std::tan(std::complex)

std::tan(std::valarray)

std::tanh(std::complex)

std::tanh(std::valarray)

std::uniform_int_distribution

std::uniform_int_distribution::a

std::uniform_int_distribution::max

std::uniform_int_distribution::min

std::uniform_int_distribution::param

std::uniform_int_distribution::reset

std::uniform_int_distribution::uniform_int_distribution

std::uniform_real_distribution

std::uniform_real_distribution::a

std::uniform_real_distribution::max

std::uniform_real_distribution::min

std::uniform_real_distribution::param

std::uniform_real_distribution::reset

std::uniform_real_distribution::uniform_real_distribution

std::valarray::apply

std::valarray::cshift

std::valarray::max

std::valarray::min

std::valarray::operators

std::valarray::operators

std::valarray::operator[]

std::valarray::resize

std::valarray::shift

std::valarray::size

std::valarray::sum

std::valarray::swap

std::valarray::valarray

std::weibull_distribution

std::weibull_distribution::a

std::weibull_distribution::max

std::weibull_distribution::min

std::weibull_distribution::param

std::weibull_distribution::reset

std::weibull_distribution::weibull_distribution

Input/output

C-style file input/output

Input/output library

Input/output manipulators

operator<<(std::basic_ostream)

operator>>(std::basic_istream)

std::basic_filebuf

std::basic_filebuf::basic_filebuf

std::basic_filebuf::close

std::basic_filebuf::imbue

std::basic_filebuf::is_open

std::basic_filebuf::open

std::basic_filebuf::overflow

std::basic_filebuf::pbackfail

std::basic_filebuf::seekoff

std::basic_filebuf::seekpos

std::basic_filebuf::setbuf

std::basic_filebuf::showmanyc

std::basic_filebuf::swap

std::basic_filebuf::sync

std::basic_filebuf::uflow

std::basic_filebuf::underflow

std::basic_fstream

std::basic_fstream::basic_fstream

std::basic_fstream::close

std::basic_fstream::is_open

std::basic_fstream::open

std::basic_fstream::rdbuf

std::basic_fstream::swap

std::basic_ifstream

std::basic_ifstream::basic_ifstream

std::basic_ifstream::close

std::basic_ifstream::is_open

std::basic_ifstream::open

std::basic_ifstream::rdbuf

std::basic_ifstream::swap

std::basic_ios::bad

std::basic_ios::basic_ios

std::basic_ios::clear

std::basic_ios::copyfmt

std::basic_ios::eof

std::basic_ios::exceptions

std::basic_ios::fail

std::basic_ios::fill

std::basic_ios::good

std::basic_ios::imbue

std::basic_ios::init

std::basic_ios::move

std::basic_ios::narrow

std::basic_ios::operator bool

std::basic_ios::rdbuf

std::basic_ios::rdstate

std::basic_ios::setstate

std::basic_ios::set_rdbuf

std::basic_ios::swap

std::basic_ios::tie

std::basic_ios::widen

std::basic_iostream

std::basic_iostream::basic_iostream

std::basic_iostream::swap

std::basic_istream

std::basic_istream::basic_istream

std::basic_istream::gcount

std::basic_istream::get

std::basic_istream::getline

std::basic_istream::ignore

std::basic_istream::operator>>

std::basic_istream::peek

std::basic_istream::putback

std::basic_istream::read

std::basic_istream::readsome

std::basic_istream::seekg

std::basic_istream::sentry

std::basic_istream::swap

std::basic_istream::sync

std::basic_istream::tellg

std::basic_istream::unget

std::basic_istringstream

std::basic_istringstream::basic_istringstream

std::basic_istringstream::rdbuf

std::basic_istringstream::str

std::basic_istringstream::swap

std::basic_ofstream

std::basic_ofstream::basic_ofstream

std::basic_ofstream::close

std::basic_ofstream::is_open

std::basic_ofstream::open

std::basic_ofstream::rdbuf

std::basic_ofstream::swap

std::basic_ostream

std::basic_ostream::basic_ostream

std::basic_ostream::flush

std::basic_ostream::operator<<

std::basic_ostream::put

std::basic_ostream::seekp

std::basic_ostream::sentry

std::basic_ostream::swap

std::basic_ostream::tellp

std::basic_ostream::write

std::basic_ostringstream

std::basic_ostringstream::basic_ostringstream

std::basic_ostringstream::rdbuf

std::basic_ostringstream::str

std::basic_ostringstream::swap

std::basic_streambuf

std::basic_streambuf::basic_streambuf

std::basic_streambuf::epptr

std::basic_streambuf::gbump

std::basic_streambuf::getloc

std::basic_streambuf::imbue

std::basic_streambuf::in_avail

std::basic_streambuf::overflow

std::basic_streambuf::pbackfail

std::basic_streambuf::pbump

std::basic_streambuf::pubseekoff

std::basic_streambuf::pubseekpos

std::basic_streambuf::pubsetbuf

std::basic_streambuf::pubsync

std::basic_streambuf::sbumpc

std::basic_streambuf::setg

std::basic_streambuf::setp

std::basic_streambuf::sgetc

std::basic_streambuf::sgetn

std::basic_streambuf::showmanyc

std::basic_streambuf::snextc

std::basic_streambuf::sputbackc

std::basic_streambuf::sputc

std::basic_streambuf::sputn

std::basic_streambuf::sungetc

std::basic_streambuf::swap

std::basic_streambuf::uflow

std::basic_streambuf::underflow

std::basic_stringbuf

std::basic_stringbuf::basic_stringbuf

std::basic_stringbuf::overflow

std::basic_stringbuf::pbackfail

std::basic_stringbuf::seekoff

std::basic_stringbuf::seekpos

std::basic_stringbuf::setbuf

std::basic_stringbuf::str

std::basic_stringbuf::swap

std::basic_stringbuf::underflow

std::basic_stringstream

std::basic_stringstream::basic_stringstream

std::basic_stringstream::rdbuf

std::basic_stringstream::str

std::basic_stringstream::swap

std::defaultfloat

std::fpos::state

std::iostream_category

std::ios_base::event

std::ios_base::event_callback

std::ios_base::failure

std::ios_base::flags

std::ios_base::fmtflags

std::ios_base::getloc

std::ios_base::imbue

std::ios_base::Init

std::ios_base::iostate

std::ios_base::ios_base

std::ios_base::iword

std::ios_base::openmode

std::ios_base::precision

std::ios_base::pword

std::ios_base::register_callback

std::ios_base::seekdir

std::ios_base::setf

std::ios_base::sync_with_stdio

std::ios_base::unsetf

std::ios_base::width

std::ios_base::xalloc

std::istrstream

std::istrstream::istrstream

std::istrstream::rdbuf

std::istrstream::str

std::is_error_code_enum<std::io_errc>

std::make_error_code(std::io_errc)

std::make_error_condition(std::io_errc)

std::noshowbase

std::noshowpoint

std::nouppercase

std::ostrstream

std::ostrstream::freeze

std::ostrstream::ostrstream

std::ostrstream::pcount

std::ostrstream::rdbuf

std::ostrstream::str

std::resetiosflags

std::setiosflags

std::setprecision

std::streamsize

std::strstream::freeze

std::strstream::pcount

std::strstream::rdbuf

std::strstream::str

std::strstream::strstream

std::strstreambuf

std::strstreambuf::freeze

std::strstreambuf::overflow

std::strstreambuf::pbackfail

std::strstreambuf::pcount

std::strstreambuf::seekoff

std::strstreambuf::seekpos

std::strstreambuf::setbuf

std::strstreambuf::str

std::strstreambuf::strstreambuf

std::strstreambuf::underflow

std::swap(std::basic_filebuf)

std::swap(std::basic_fstream)

std::swap(std::basic_ifstream)

std::swap(std::basic_istringstream)

std::swap(std::basic_ofstream)

std::swap(std::basic_ostringstream)

std::swap(std::basic_stringbuf)

std::swap(std::basic_stringstream)

Containers

Containers library

operators (std::array)

operators (std::deque)

operators (std::forward_list)

operators (std::list)

operators (std::map)

operators (std::multimap)

operators (std::multiset)

operators (std::queue)

operators (std::set)

operators (std::stack)

operators (std::unordered_map)

operators (std::unordered_multimap)

operators (std::unordered_multiset)

operators (std::unordered_set)

operators (std::vector)

std::array::back

std::array::begin

std::array::cend

std::array::crbegin

std::array::crend

std::array::data

std::array::empty

std::array::fill

std::array::front

std::array::max_size

std::array::operator[]

std::array::size

std::array::swap

std::deque::assign

std::deque::back

std::deque::begin

std::deque::cend

std::deque::clear

std::deque::crbegin

std::deque::crend

std::deque::deque

std::deque::emplace

std::deque::emplace_back

std::deque::emplace_front

std::deque::empty

std::deque::erase

std::deque::front

std::deque::get_allocator

std::deque::insert

std::deque::max_size

std::deque::operator[]

std::deque::pop_back

std::deque::pop_front

std::deque::push_back

std::deque::push_front

std::deque::resize

std::deque::shrink_to_fit

std::deque::size

std::deque::swap

std::forward_list

std::forward_list::assign

std::forward_list::begin

std::forward_list::cend

std::forward_list::clear

std::forward_list::emplace_after

std::forward_list::emplace_front

std::forward_list::empty

std::forward_list::erase_after

std::forward_list::forward_list

std::forward_list::front

std::forward_list::get_allocator

std::forward_list::insert_after

std::forward_list::max_size

std::forward_list::merge

std::forward_list::pop_front

std::forward_list::push_front

std::forward_list::resize

std::forward_list::reverse

std::forward_list::sort

std::forward_list::splice_after

std::forward_list::swap

std::forward_list::unique

std::get(std::array)

std::list::assign

std::list::back

std::list::begin

std::list::cend

std::list::clear

std::list::crbegin

std::list::crend

std::list::emplace

std::list::emplace_back

std::list::emplace_front

std::list::empty

std::list::erase

std::list::front

std::list::get_allocator

std::list::insert

std::list::list

std::list::max_size

std::list::merge

std::list::pop_back

std::list::pop_front

std::list::push_back

std::list::push_front

std::list::resize

std::list::reverse

std::list::size

std::list::sort

std::list::splice

std::list::swap

std::list::unique

std::map::begin

std::map::clear

std::map::count

std::map::crbegin

std::map::crend

std::map::emplace

std::map::emplace_hint

std::map::empty

std::map::equal_range

std::map::erase

std::map::extract

std::map::get_allocator

std::map::insert

std::map::insert_or_assign

std::map::key_comp

std::map::lower_bound

std::map::max_size

std::map::merge

std::map::operator[]

std::map::try_emplace

std::map::upper_bound

std::map::value_comp

std::map::value_compare

std::multimap::begin

std::multimap::cend

std::multimap::clear

std::multimap::count

std::multimap::crbegin

std::multimap::crend

std::multimap::emplace

std::multimap::emplace_hint

std::multimap::empty

std::multimap::equal_range

std::multimap::erase

std::multimap::extract

std::multimap::find

std::multimap::get_allocator

std::multimap::insert

std::multimap::key_comp

std::multimap::lower_bound

std::multimap::max_size

std::multimap::merge

std::multimap::multimap

std::multimap::size

std::multimap::swap

std::multimap::upper_bound

std::multimap::value_comp

std::multimap::value_compare

std::multiset::begin

std::multiset::cend

std::multiset::clear

std::multiset::count

std::multiset::crbegin

std::multiset::crend

std::multiset::emplace

std::multiset::emplace_hint

std::multiset::empty

std::multiset::equal_range

std::multiset::erase

std::multiset::extract

std::multiset::find

std::multiset::get_allocator

std::multiset::insert

std::multiset::key_comp

std::multiset::lower_bound

std::multiset::max_size

std::multiset::merge

std::multiset::multiset

std::multiset::size

std::multiset::swap

std::multiset::upper_bound

std::multiset::value_comp

std::priority_queue

std::priority_queue::emplace

std::priority_queue::empty

std::priority_queue::pop

std::priority_queue::priority_queue

std::priority_queue::push

std::priority_queue::size

std::priority_queue::swap

std::priority_queue::top

std::queue::back

std::queue::emplace

std::queue::empty

std::queue::front

std::queue::pop

std::queue::push

std::queue::queue

std::queue::size

std::queue::swap

std::set::begin

std::set::clear

std::set::count

std::set::crbegin

std::set::crend

std::set::emplace

std::set::emplace_hint

std::set::empty

std::set::equal_range

std::set::erase

std::set::extract

std::set::get_allocator

std::set::insert

std::set::key_comp

std::set::lower_bound

std::set::max_size

std::set::merge

std::set::upper_bound

std::set::value_comp

std::stack::emplace

std::stack::empty

std::stack::pop

std::stack::push

std::stack::size

std::stack::stack

std::stack::swap

std::stack::top

std::swap(std::array)

std::swap(std::deque)

std::swap(std::forward_list)

std::swap(std::list)

std::swap(std::map)

std::swap(std::multimap)

std::swap(std::multiset)

std::swap(std::priority_queue)

std::swap(std::queue)

std::swap(std::set)

std::swap(std::stack)

std::swap(std::unordered_map)

std::swap(std::unordered_multimap)

std::swap(std::unordered_multiset)

std::swap(std::unordered_set)

std::swap(std::vector)

std::tuple_element<std::array>

std::tuple_size(std::array)

std::unordered_map

std::unordered_map::at

std::unordered_map::begin

std::unordered_map::begin(int)

std::unordered_map::bucket

std::unordered_map::bucket_count

std::unordered_map::bucket_size

std::unordered_map::cend

std::unordered_map::cend

std::unordered_map::clear

std::unordered_map::count

std::unordered_map::emplace

std::unordered_map::emplace_hint

std::unordered_map::empty

std::unordered_map::equal_range

std::unordered_map::erase

std::unordered_map::extract

std::unordered_map::find

std::unordered_map::get_allocator

std::unordered_map::hash_function

std::unordered_map::insert

std::unordered_map::insert_or_assign

std::unordered_map::key_eq

std::unordered_map::load_factor

std::unordered_map::max_bucket_count

std::unordered_map::max_load_factor

std::unordered_map::max_size

std::unordered_map::merge

std::unordered_map::operator[]

std::unordered_map::rehash

std::unordered_map::reserve

std::unordered_map::size

std::unordered_map::swap

std::unordered_map::try_emplace

std::unordered_map::unordered_map

std::unordered_multimap

std::unordered_multimap::begin

std::unordered_multimap::begin(int)

std::unordered_multimap::bucket

std::unordered_multimap::bucket_count

std::unordered_multimap::bucket_size

std::unordered_multimap::cend

std::unordered_multimap::cend

std::unordered_multimap::clear

std::unordered_multimap::count

std::unordered_multimap::emplace

std::unordered_multimap::emplace_hint

std::unordered_multimap::empty

std::unordered_multimap::equal_range

std::unordered_multimap::erase

std::unordered_multimap::extract

std::unordered_multimap::find

std::unordered_multimap::get_allocator

std::unordered_multimap::hash_function

std::unordered_multimap::insert

std::unordered_multimap::key_eq

std::unordered_multimap::load_factor

std::unordered_multimap::max_bucket_count

std::unordered_multimap::max_load_factor

std::unordered_multimap::max_size

std::unordered_multimap::merge

std::unordered_multimap::rehash

std::unordered_multimap::reserve

std::unordered_multimap::size

std::unordered_multimap::swap

std::unordered_multimap::unordered_multimap

std::unordered_multiset

std::unordered_multiset::begin

std::unordered_multiset::begin(int)

std::unordered_multiset::bucket

std::unordered_multiset::bucket_count

std::unordered_multiset::bucket_size

std::unordered_multiset::cend

std::unordered_multiset::cend

std::unordered_multiset::clear

std::unordered_multiset::count

std::unordered_multiset::emplace

std::unordered_multiset::emplace_hint

std::unordered_multiset::empty

std::unordered_multiset::equal_range

std::unordered_multiset::erase

std::unordered_multiset::extract

std::unordered_multiset::find

std::unordered_multiset::get_allocator

std::unordered_multiset::hash_function

std::unordered_multiset::insert

std::unordered_multiset::key_eq

std::unordered_multiset::load_factor

std::unordered_multiset::max_bucket_count

std::unordered_multiset::max_load_factor

std::unordered_multiset::max_size

std::unordered_multiset::merge

std::unordered_multiset::rehash

std::unordered_multiset::reserve

std::unordered_multiset::size

std::unordered_multiset::swap

std::unordered_multiset::unordered_multiset

std::unordered_set

std::unordered_set::begin

std::unordered_set::begin(int)

std::unordered_set::bucket

std::unordered_set::bucket_count

std::unordered_set::bucket_size

std::unordered_set::cend

std::unordered_set::cend

std::unordered_set::clear

std::unordered_set::count

std::unordered_set::emplace

std::unordered_set::emplace_hint

std::unordered_set::empty

std::unordered_set::equal_range

std::unordered_set::erase

std::unordered_set::extract

std::unordered_set::find

std::unordered_set::get_allocator

std::unordered_set::hash_function

std::unordered_set::insert

std::unordered_set::key_eq

std::unordered_set::load_factor

std::unordered_set::max_bucket_count

std::unordered_set::max_load_factor

std::unordered_set::max_size

std::unordered_set::merge

std::unordered_set::rehash

std::unordered_set::reserve

std::unordered_set::size

std::unordered_set::swap

std::unordered_set::unordered_set

std::uses_allocator<std::priority_queue>

std::uses_allocator<std::queue>

std::uses_allocator<std::stack>

std::vector::assign

std::vector::at

std::vector::back

std::vector::begin

std::vector::capacity

std::vector::cend

std::vector::clear

std::vector::crbegin

std::vector::crend

std::vector::data

std::vector::emplace

std::vector::emplace_back

std::vector::empty

std::vector::erase

std::vector::front

std::vector::get_allocator

std::vector::insert

std::vector::max_size

std::vector::operator[]

std::vector::pop_back

std::vector::push_back

std::vector::reserve

std::vector::resize

std::vector::shrink_to_fit

std::vector::size

std::vector::swap

std::vector::vector

std::vector<bool>

std::vector<bool>::flip

std::vector<bool>::reference

std::vector<bool>::swap

Localizations

do_always_noconv

do_decimal_point

do_decimal_point

do_negative_sign

do_thousands_sep

do_thousands_sep

Localization library

std::codecvt::codecvt

std::codecvt::do_in

std::codecvt_base

std::codecvt_byname

std::codecvt_mode

std::codecvt_utf16

std::codecvt_utf8

std::codecvt_utf8_utf16

std::collate::collate

std::collate::compare

std::collate_byname

std::ctype::ctype

std::ctype::do_is

std::ctype::do_scan_is

std::ctype::do_scan_not

std::ctype::do_tolower

std::ctype::do_toupper

std::ctype<char>

std::ctype<char>::classic_table

std::ctype<char>::ctype

std::ctype<char>::is

std::ctype<char>::scan_is

std::ctype<char>::scan_is

std::ctype<char>::table

std::ctype_base

std::ctype_byname

std::isalnum(std::locale)

std::isalpha(std::locale)

std::isblank(std::locale)

std::iscntrl(std::locale)

std::isdigit(std::locale)

std::isgraph(std::locale)

std::islower(std::locale)

std::isprint(std::locale)

std::ispunct(std::locale)

std::isspace(std::locale)

std::isupper(std::locale)

std::isxdigit(std::locale)

std::locale::classic

std::locale::combine

std::locale::facet

std::locale::facet::facet

std::locale::global

std::locale::id

std::locale::id::id

std::locale::locale

std::locale::name

std::locale::operators (operator!=)

std::localeconv

std::messages::close

std::messages::do_open

std::messages::messages

std::messages_base

std::messages_byname

std::moneypunct

std::moneypunct::moneypunct

std::moneypunct_byname

std::money_base

std::money_get::money_get

std::money_put::money_put

std::numpunct::numpunct

std::numpunct_byname

std::num_get::do_get

std::num_get::num_get

std::num_put::do_put

std::num_put::num_put

std::time_get::date_order

std::time_get::do_get

std::time_get::do_get_date

std::time_get::do_get_monthname

std::time_get::do_get_time

std::time_get::do_get_weekday

std::time_get::do_get_year

std::time_get::time_get

std::time_get_byname

std::time_put::do_put

std::time_put::time_put

std::time_put_byname

std::tolower(std::locale)

std::toupper(std::locale)

std::wbuffer_convert

std::wbuffer_convert::rdbuf

std::wbuffer_convert::state

std::wbuffer_convert::wbuffer_convert

std::wstring_convert

std::wstring_convert::converted

std::wstring_convert::from_bytes

std::wstring_convert::state

std::wstring_convert::to_bytes

std::wstring_convert::wstring_convert

Strings

Null-terminated byte strings

Null-terminated multibyte strings

Null-terminated wide strings

operator<<(std::basic_string_view)

operators (std::basic_string)

operators (std::basic_string)

operators (std::basic_string_view)

std::basic_string

std::basic_string::append

std::basic_string::assign

std::basic_string::at

std::basic_string::back

std::basic_string::basic_string

std::basic_string::begin

std::basic_string::capacity

std::basic_string::cend

std::basic_string::clear

std::basic_string::compare

std::basic_string::copy

std::basic_string::crbegin

std::basic_string::crend

std::basic_string::c_str

std::basic_string::data

std::basic_string::empty

std::basic_string::erase

std::basic_string::find

std::basic_string::find_first_not_of

std::basic_string::find_first_of

std::basic_string::find_last_not_of

std::basic_string::find_last_of

std::basic_string::front

std::basic_string::get_allocator

std::basic_string::insert

std::basic_string::length

std::basic_string::max_size

std::basic_string::npos

std::basic_string::operator basic_string_view

std::basic_string::operator[]

std::basic_string::pop_back

std::basic_string::push_back

std::basic_string::replace

std::basic_string::reserve

std::basic_string::resize

std::basic_string::rfind

std::basic_string::shrink_to_fit

std::basic_string::substr

std::basic_string::swap

std::basic_string_view

std::basic_string_view::at

std::basic_string_view::back

std::basic_string_view::basic_string_view

std::basic_string_view::begin

std::basic_string_view::cend

std::basic_string_view::compare

std::basic_string_view::copy

std::basic_string_view::crbegin

std::basic_string_view::crend

std::basic_string_view::data

std::basic_string_view::empty

std::basic_string_view::find

std::basic_string_view::find_first_not_of

std::basic_string_view::find_first_of

std::basic_string_view::find_last_not_of

std::basic_string_view::find_last_of

std::basic_string_view::front

std::basic_string_view::length

std::basic_string_view::max_size

std::basic_string_view::npos

std::basic_string_view::operator[]

std::basic_string_view::remove_prefix

std::basic_string_view::remove_suffix

std::basic_string_view::rfind

std::basic_string_view::substr

std::basic_string_view::swap

std::char_traits

std::char_traits::assign

std::char_traits::compare

std::char_traits::copy

std::char_traits::eof

std::char_traits::eq

std::char_traits::eq_int_type

std::char_traits::find

std::char_traits::length

std::char_traits::move

std::char_traits::not_eof

std::char_traits::to_char_type

std::char_traits::to_int_type

std::literals::string_literals::operator""s

std::literals::string_view_literals::operator""sv

std::swap(std::basic_string)

std::to_wstring

Strings library

Regular expressions

operator<<(std::sub_match)

operators (std::match_results)

operators (std::sub_match)

Regular expressions library

std::basic_regex

std::basic_regex constants

std::basic_regex::assign

std::basic_regex::basic_regex

std::basic_regex::flags

std::basic_regex::getloc

std::basic_regex::imbue

std::basic_regex::mark_count

std::basic_regex::swap

std::match_results

std::match_results::begin

std::match_results::cend

std::match_results::empty

std::match_results::format

std::match_results::get_allocator

std::match_results::length

std::match_results::match_results

std::match_results::max_size

std::match_results::operator[]

std::match_results::position

std::match_results::prefix

std::match_results::ready

std::match_results::size

std::match_results::str

std::match_results::suffix

std::match_results::swap

std::regex_constants::error_type

std::regex_constants::match_flag_type

std::regex_constants::syntax_option_type

std::regex_error

std::regex_error::code

std::regex_error::regex_error

std::regex_iterator

std::regex_iterator::operators

std::regex_iterator::operators

std::regex_iterator::operators (int)

std::regex_iterator::regex_iterator

std::regex_match

std::regex_replace

std::regex_search

std::regex_token_iterator

std::regex_token_iterator::operators (int)

std::regex_token_iterator::operators (operator->)

std::regex_token_iterator::regex_token_iterator

std::regex_traits

std::regex_traits::getloc

std::regex_traits::imbue

std::regex_traits::isctype

std::regex_traits::length

std::regex_traits::lookup_classname

std::regex_traits::lookup_collatename

std::regex_traits::regex_traits

std::regex_traits::transform

std::regex_traits::transform_primary

std::regex_traits::translate

std::regex_traits::translate_nocase

std::regex_traits::value

std::sub_match::compare

std::sub_match::length

std::sub_match::operators (std::sub_match::str)

std::sub_match::sub_match

std::swap(std::basic_regex)

std::swap(std::match_results)

Thread support

operator<<(std::thread::id)

operators (std::thread::id)

std::adopt_lock

std::adopt_lock_t

std::condition_variable

std::condition_variable::condition_variable

std::condition_variable::native_handle

std::condition_variable::notify_all

std::condition_variable::notify_one

std::condition_variable::wait

std::condition_variable::wait_for

std::condition_variable::wait_until

std::condition_variable_any

std::condition_variable_any::condition_variable_any

std::condition_variable_any::notify_all

std::condition_variable_any::notify_one

std::condition_variable_any::wait

std::condition_variable_any::wait_for

std::condition_variable_any::wait_until

std::future::future

std::future::get

std::future::share

std::future::valid

std::future::wait

std::future::wait_for

std::future::wait_until

std::future_category

std::future_category

std::future_errc

std::future_error

std::future_error::code

std::future_error::future_error

std::future_error::what

std::future_status

std::hardware_constructive_interference_size

std::hash<std::thread::id>

std::lock_guard

std::lock_guard::lock_guard

std::make_error_code(std::future_errc)

std::make_error_condition(std::future_errc)

std::mutex::lock

std::mutex::mutex

std::mutex::native_handle

std::mutex::try_lock

std::mutex::unlock

std::notify_all_at_thread_exit

std::packaged_task

std::packaged_task::get_future

std::packaged_task::make_ready_at_thread_exit

std::packaged_task::packaged_task

std::packaged_task::reset

std::packaged_task::swap

std::packaged_task::valid

std::promise::get_future

std::promise::promise

std::promise::set_exception

std::promise::set_exception_at_thread_exit

std::promise::set_value

std::promise::set_value_at_thread_exit

std::promise::swap

std::recursive_mutex

std::recursive_mutex::lock

std::recursive_mutex::native_handle

std::recursive_mutex::recursive_mutex

std::recursive_mutex::try_lock

std::recursive_mutex::unlock

std::recursive_timed_mutex

std::recursive_timed_mutex::lock

std::recursive_timed_mutex::native_handle

std::recursive_timed_mutex::recursive_timed_mutex

std::recursive_timed_mutex::try_lock

std::recursive_timed_mutex::try_lock_for

std::recursive_timed_mutex::try_lock_until

std::recursive_timed_mutex::unlock

std::scoped_lock

std::scoped_lock::scoped_lock

std::shared_future

std::shared_future::get

std::shared_future::shared_future

std::shared_future::valid

std::shared_future::wait

std::shared_future::wait_for

std::shared_future::wait_until

std::shared_lock

std::shared_lock::lock

std::shared_lock::mutex

std::shared_lock::operator bool

std::shared_lock::owns_lock

std::shared_lock::release

std::shared_lock::shared_lock

std::shared_lock::swap

std::shared_lock::try_lock

std::shared_lock::try_lock_for

std::shared_lock::try_lock_until

std::shared_lock::unlock

std::shared_mutex

std::shared_mutex::lock

std::shared_mutex::lock_shared

std::shared_mutex::native_handle

std::shared_mutex::shared_mutex

std::shared_mutex::try_lock

std::shared_mutex::try_lock_shared

std::shared_mutex::unlock

std::shared_mutex::unlock_shared

std::shared_timed_mutex

std::shared_timed_mutex::lock

std::shared_timed_mutex::lock_shared

std::shared_timed_mutex::shared_timed_mutex

std::shared_timed_mutex::try_lock

std::shared_timed_mutex::try_lock_for

std::shared_timed_mutex::try_lock_shared

std::shared_timed_mutex::try_lock_shared_for

std::shared_timed_mutex::try_lock_shared_until

std::shared_timed_mutex::try_lock_until

std::shared_timed_mutex::unlock

std::shared_timed_mutex::unlock_shared

std::swap(std::packaged_task)

std::swap(std::promise)

std::swap(std::shared_lock)

std::swap(std::thread)

std::swap(std::unique_lock)

std::this_thread::get_id

std::this_thread::sleep_for

std::this_thread::sleep_until

std::this_thread::yield

std::thread::detach

std::thread::get_id

std::thread::hardware_concurrency

std::thread::id

std::thread::id::id

std::thread::join

std::thread::joinable

std::thread::native_handle

std::thread::swap

std::thread::thread

std::timed_mutex

std::timed_mutex::lock

std::timed_mutex::native_handle

std::timed_mutex::timed_mutex

std::timed_mutex::try_lock

std::timed_mutex::try_lock_for

std::timed_mutex::try_lock_until

std::timed_mutex::unlock

std::unique_lock

std::unique_lock::lock

std::unique_lock::mutex

std::unique_lock::operator bool

std::unique_lock::owns_lock

std::unique_lock::release

std::unique_lock::swap

std::unique_lock::try_lock

std::unique_lock::try_lock_for

std::unique_lock::try_lock_until

std::unique_lock::unique_lock

std::unique_lock::unlock

std::uses_allocator<std::packaged_task>

std::uses_allocator<std::promise>

Thread support library

Index