Table of Contents
Algorithm
Algorithms library
Constrained algorithms
std::accumulate
std::adjacent_difference
std::adjacent_find
std::all_of
std::any_of
std::binary_search
std::bsearch
std::clamp
std::copy
std::copy_backward
std::copy_if
std::copy_n
std::count
std::count_if
std::equal
std::equal_range
std::exclusive_scan
std::execution::par
std::execution::par_unseq
std::execution::parallel_policy
std::execution::parallel_unsequenced_policy
std::execution::seq
std::execution::sequenced_policy
std::execution::unseq
std::execution::unsequenced_policy
std::fill
std::fill_n
std::find
std::find_end
std::find_first_of
std::find_if
std::find_if_not
std::for_each
std::for_each_n
std::generate
std::generate_n
std::includes
std::inclusive_scan
std::inner_product
std::inplace_merge
std::iota
std::is_execution_policy
std::is_heap
std::is_heap_until
std::is_partitioned
std::is_permutation
std::is_sorted
std::is_sorted_until
std::iter_swap
std::lexicographical_compare
std::lexicographical_compare_three_way
std::lower_bound
std::make_heap
std::max
std::max_element
std::merge
std::min
std::min_element
std::minmax
std::minmax_element
std::mismatch
std::move_backward
std::next_permutation
std::none_of
std::nth_element
std::partial_sort
std::partial_sort_copy
std::partial_sum
std::partition
std::partition_copy
std::partition_point
std::pop_heap
std::prev_permutation
std::push_heap
std::qsort
std::random_shuffle
std::ranges::adjacent_find
std::ranges::all_of
std::ranges::any_of
std::ranges::binary_search
std::ranges::binary_transform_result
std::ranges::clamp
std::ranges::copy
std::ranges::copy_backward
std::ranges::copy_backward_result
std::ranges::copy_if
std::ranges::copy_if_result
std::ranges::copy_n
std::ranges::copy_n_result
std::ranges::copy_result
std::ranges::count
std::ranges::count_if
std::ranges::ends_with
std::ranges::equal
std::ranges::equal_range
std::ranges::fill
std::ranges::fill_n
std::ranges::find
std::ranges::find_end
std::ranges::find_first_of
std::ranges::find_if
std::ranges::find_if_not
std::ranges::for_each
std::ranges::for_each_n
std::ranges::for_each_n_result
std::ranges::for_each_result
std::ranges::generate
std::ranges::generate_n
std::ranges::includes
std::ranges::inplace_merge
std::ranges::iota
std::ranges::iota_result
std::ranges::is_heap
std::ranges::is_heap_until
std::ranges::is_partitioned
std::ranges::is_permutation
std::ranges::is_sorted
std::ranges::is_sorted_until
std::ranges::lexicographical_compare
std::ranges::lower_bound
std::ranges::make_heap
std::ranges::max
std::ranges::max_element
std::ranges::merge
std::ranges::merge_result
std::ranges::min
std::ranges::min_element
std::ranges::minmax
std::ranges::minmax_element
std::ranges::minmax_element_result
std::ranges::minmax_result
std::ranges::mismatch
std::ranges::mismatch_result
std::ranges::move
std::ranges::move_backward
std::ranges::move_backward_result
std::ranges::move_result
std::ranges::next_permutation
std::ranges::next_permutation_result
std::ranges::none_of
std::ranges::nth_element
std::ranges::partial_sort
std::ranges::partial_sort_copy
std::ranges::partial_sort_copy_result
std::ranges::partition
std::ranges::partition_copy
std::ranges::partition_copy_result
std::ranges::partition_point
std::ranges::pop_heap
std::ranges::prev_permutation
std::ranges::prev_permutation_result
std::ranges::push_heap
std::ranges::remove
std::ranges::remove_copy
std::ranges::remove_copy_if
std::ranges::remove_copy_if_result
std::ranges::remove_copy_result
std::ranges::remove_if
std::ranges::replace
std::ranges::replace_copy
std::ranges::replace_copy_if
std::ranges::replace_copy_if_result
std::ranges::replace_copy_result
std::ranges::replace_if
std::ranges::reverse
std::ranges::reverse_copy
std::ranges::reverse_copy_result
std::ranges::rotate
std::ranges::rotate_copy
std::ranges::rotate_copy_result
std::ranges::sample
std::ranges::search
std::ranges::search_n
std::ranges::set_difference
std::ranges::set_difference_result
std::ranges::set_intersection
std::ranges::set_intersection_result
std::ranges::set_symmetric_difference
std::ranges::set_symmetric_difference_result
std::ranges::set_union
std::ranges::set_union_result
std::ranges::shift_left
std::ranges::shift_right
std::ranges::shuffle
std::ranges::sort
std::ranges::sort_heap
std::ranges::stable_partition
std::ranges::stable_sort
std::ranges::starts_with
std::ranges::swap_ranges
std::ranges::swap_ranges_result
std::ranges::transform
std::ranges::unary_transform_result
std::ranges::unique
std::ranges::unique_copy
std::ranges::unique_copy_result
std::ranges::upper_bound
std::reduce
std::remove
std::remove_copy
std::remove_copy_if
std::remove_if
std::replace
std::replace_copy
std::replace_copy_if
std::replace_if
std::reverse
std::reverse_copy
std::rotate
std::rotate_copy
std::sample
std::search
std::search_n
std::set_difference
std::set_intersection
std::set_symmetric_difference
std::set_union
std::shift_left
std::shift_right
std::shuffle
std::sort
std::sort_heap
std::stable_partition
std::stable_sort
std::swap
std::swap_ranges
std::transform
std::transform_exclusive_scan
std::transform_inclusive_scan
std::transform_reduce
std::unique
std::unique_copy
std::upper_bound
Atomic operations
Atomic operations library
Compiler support
compiler support
Compiler support for C++11
Compiler support for C++14
Compiler support for C++17
Compiler support for C++20
Compiler support for C++23
Concepts
boolean-testable
Concepts library
std::assignable_from
std::common_reference_with
std::common_with
std::constructible_from
std::convertible_to
std::copy_constructible
std::copyable
std::default_initializable
std::derived_from
std::destructible
std::equality_comparable
std::equality_comparable_with
std::equivalence_relation
std::floating_point
std::integral
std::invocable
std::movable
std::move_constructible
std::predicate
std::regular
std::regular_invocable
std::relation
std::same_as
std::semiregular
std::signed_integral
std::strict_weak_order
std::swappable
std::swappable_with
std::totally_ordered
std::totally_ordered_with
std::unsigned_integral
Concurrency support
ATOMIC_FLAG_INIT
ATOMIC_VAR_INIT
ATOMIC_xxx_LOCK_FREE
Concurrency support library
deduction guides for std::packaged_task
deduction guides for std::stop_callback
operator<<(std::thread::id)
operator==(std::stop_source)
operator==(std::stop_token)
operators (std::thread::id)
std::adopt_lock
std::adopt_lock_t
std::async
std::atomic
std::atomic::atomic
std::atomic::compare_exchange_strong
std::atomic::compare_exchange_weak
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::notify_all
std::atomic::notify_one
std::atomic::operator T
std::atomic::operator=
std::atomic::operators
std::atomic::operators (int)
std::atomic::store
std::atomic::wait
std::atomic_compare_exchange_strong
std::atomic_compare_exchange_strong_explicit
std::atomic_compare_exchange_weak
std::atomic_compare_exchange_weak_explicit
std::atomic_exchange
std::atomic_exchange_explicit
std::atomic_fetch_add
std::atomic_fetch_add_explicit
std::atomic_fetch_and
std::atomic_fetch_and_explicit
std::atomic_fetch_or
std::atomic_fetch_or_explicit
std::atomic_fetch_sub
std::atomic_fetch_sub_explicit
std::atomic_fetch_xor
std::atomic_fetch_xor_explicit
std::atomic_flag
std::atomic_flag::atomic_flag
std::atomic_flag::clear
std::atomic_flag::notify_all
std::atomic_flag::notify_one
std::atomic_flag::operator=
std::atomic_flag::test
std::atomic_flag::test_and_set
std::atomic_flag::wait
std::atomic_flag_clear
std::atomic_flag_clear_explicit
std::atomic_flag_notify_all
std::atomic_flag_notify_one
std::atomic_flag_test
std::atomic_flag_test_and_set
std::atomic_flag_test_and_set_explicit
std::atomic_flag_test_explicit
std::atomic_flag_wait
std::atomic_flag_wait_explicit
std::atomic_init
std::atomic_is_lock_free
std::atomic_load
std::atomic_load_explicit
std::atomic_notify_all
std::atomic_notify_one
std::atomic_ref
std::atomic_ref::atomic_ref
std::atomic_ref::compare_exchange_strong
std::atomic_ref::compare_exchange_weak
std::atomic_ref::exchange
std::atomic_ref::fetch_add
std::atomic_ref::fetch_and
std::atomic_ref::fetch_or
std::atomic_ref::fetch_sub
std::atomic_ref::fetch_xor
std::atomic_ref::is_always_lock_free
std::atomic_ref::is_lock_free
std::atomic_ref::load
std::atomic_ref::notify_all
std::atomic_ref::notify_one
std::atomic_ref::operator T
std::atomic_ref::operator=
std::atomic_ref::operators
std::atomic_ref::operators (int)
std::atomic_ref::required_alignment
std::atomic_ref::store
std::atomic_ref::wait
std::atomic_signal_fence
std::atomic_store
std::atomic_store_explicit
std::atomic_thread_fence
std::atomic_wait
std::atomic_wait_explicit
std::barrier
std::barrier::arrive
std::barrier::arrive_and_drop
std::barrier::arrive_and_wait
std::barrier::barrier
std::barrier::max
std::barrier::wait
std::barrier::~barrier
std::binary_semaphore
std::call_once
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::~condition_variable
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::condition_variable_any::~condition_variable_any
std::counting_semaphore
std::counting_semaphore::acquire
std::counting_semaphore::counting_semaphore
std::counting_semaphore::max
std::counting_semaphore::release
std::counting_semaphore::try_acquire
std::counting_semaphore::try_acquire_for
std::counting_semaphore::try_acquire_until
std::counting_semaphore::~counting_semaphore
std::cv_status
std::defer_lock
std::defer_lock_t
std::future
std::future::future
std::future::get
std::future::operator=
std::future::share
std::future::valid
std::future::wait
std::future::wait_for
std::future::wait_until
std::future::~future
std::future_category
std::future_errc
std::future_error
std::future_error::code
std::future_error::future_error
std::future_error::operator=
std::future_error::what
std::future_status
std::hardware_constructive_interference_size
std::hardware_destructive_interference_size
std::jthread
std::jthread::detach
std::jthread::get_id
std::jthread::get_stop_source
std::jthread::get_stop_token
std::jthread::hardware_concurrency
std::jthread::join
std::jthread::joinable
std::jthread::jthread
std::jthread::native_handle
std::jthread::operator=
std::jthread::request_stop
std::jthread::swap
std::jthread::~jthread
std::kill_dependency
std::latch
std::latch::arrive_and_wait
std::latch::count_down
std::latch::latch
std::latch::max
std::latch::try_wait
std::latch::wait
std::latch::~latch
std::launch
std::lock
std::lock_guard
std::lock_guard::lock_guard
std::lock_guard::~lock_guard
std::make_error_code(std::future_errc)
std::make_error_condition(std::future_errc)
std::memory_order
std::mutex
std::mutex::lock
std::mutex::mutex
std::mutex::native_handle
std::mutex::try_lock
std::mutex::unlock
std::mutex::~mutex
std::nostopstate
std::nostopstate_t
std::notify_all_at_thread_exit
std::once_flag
std::packaged_task
std::packaged_task::get_future
std::packaged_task::make_ready_at_thread_exit
std::packaged_task::operator()
std::packaged_task::operator=
std::packaged_task::packaged_task
std::packaged_task::reset
std::packaged_task::swap
std::packaged_task::valid
std::packaged_task::~packaged_task
std::promise
std::promise::get_future
std::promise::operator=
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::promise::~promise
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_mutex::~recursive_mutex
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::recursive_timed_mutex::~recursive_timed_mutex
std::scoped_lock
std::scoped_lock::scoped_lock
std::scoped_lock::~scoped_lock
std::shared_future
std::shared_future::get
std::shared_future::operator=
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_future::~shared_future
std::shared_lock
std::shared_lock::lock
std::shared_lock::mutex
std::shared_lock::operator bool
std::shared_lock::operator=
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_lock::~shared_lock
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_mutex::~shared_mutex
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::shared_timed_mutex::~shared_timed_mutex
std::stop_callback
std::stop_callback::stop_callback
std::stop_callback::~stop_callback
std::stop_source
std::stop_source::get_token
std::stop_source::operator=
std::stop_source::request_stop
std::stop_source::stop_possible
std::stop_source::stop_requested
std::stop_source::stop_source
std::stop_source::swap
std::stop_source::~stop_source
std::stop_token
std::stop_token::operator=
std::stop_token::stop_possible
std::stop_token::stop_requested
std::stop_token::stop_token
std::stop_token::swap
std::stop_token::~stop_token
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
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::operator=
std::thread::swap
std::thread::thread
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::timed_mutex::~timed_mutex
std::try_lock
std::try_to_lock
std::try_to_lock_t
std::unique_lock
std::unique_lock::lock
std::unique_lock::mutex
std::unique_lock::operator bool
std::unique_lock::operator=
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::unique_lock::~unique_lock
swap(std::jthread)
swap(std::stop_source)
swap(std::stop_token)
Constrained algorithms
std::ranges::in_found_result
std::ranges::in_fun_result
std::ranges::in_in_out_result
std::ranges::in_in_result
std::ranges::in_out_out_result
std::ranges::in_out_result
std::ranges::min_max_result
std::ranges::out_value_result
Containers
cbefore_begin
Containers library
deduction guides for std::array
deduction guides for std::deque
deduction guides for std::forward_list
deduction guides for std::list
deduction guides for std::map
deduction guides for std::multimap
deduction guides for std::multiset
deduction guides for std::priority_queue
deduction guides for std::queue
deduction guides for std::set
deduction guides for std::span
deduction guides for std::stack
deduction guides for std::unordered_map
deduction guides for std::unordered_multimap
deduction guides for std::unordered_multiset
deduction guides for std::unordered_set
deduction guides for std::vector
Node handle
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)
remove_if
remove_if
std::array
std::array::at
std::array::back
std::array::begin
std::array::cbegin
std::array::cend
std::array::crbegin
std::array::crend
std::array::data
std::array::empty
std::array::end
std::array::fill
std::array::front
std::array::max_size
std::array::operator[]
std::array::rbegin
std::array::rend
std::array::size
std::array::swap
std::as_bytes
std::as_writable_bytes
std::deque
std::deque::assign
std::deque::at
std::deque::back
std::deque::begin
std::deque::cbegin
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::end
std::deque::erase
std::deque::front
std::deque::get_allocator
std::deque::insert
std::deque::max_size
std::deque::operator=
std::deque::operator[]
std::deque::pop_back
std::deque::pop_front
std::deque::push_back
std::deque::push_front
std::deque::rbegin
std::deque::rend
std::deque::resize
std::deque::shrink_to_fit
std::deque::size
std::deque::swap
std::deque::~deque
std::dynamic_extent
std::erase
std::erase_if
std::erase_if
std::forward_list
std::forward_list::assign
std::forward_list::before_begin
std::forward_list::begin
std::forward_list::cbegin
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::end
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::operator=
std::forward_list::pop_front
std::forward_list::push_front
std::forward_list::remove
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::forward_list::~forward_list
std::get(std::array)
std::list
std::list::assign
std::list::back
std::list::begin
std::list::cbegin
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::end
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::operator=
std::list::pop_back
std::list::pop_front
std::list::push_back
std::list::push_front
std::list::rbegin
std::list::remove
std::list::rend
std::list::resize
std::list::reverse
std::list::size
std::list::sort
std::list::splice
std::list::swap
std::list::unique
std::list::~list
std::map
std::map::at
std::map::begin
std::map::cbegin
std::map::cend
std::map::clear
std::map::contains
std::map::count
std::map::crbegin
std::map::crend
std::map::emplace
std::map::emplace_hint
std::map::empty
std::map::end
std::map::equal_range
std::map::erase
std::map::extract
std::map::find
std::map::get_allocator
std::map::insert
std::map::insert_or_assign
std::map::key_comp
std::map::lower_bound
std::map::map
std::map::max_size
std::map::merge
std::map::operator=
std::map::operator[]
std::map::rbegin
std::map::rend
std::map::size
std::map::swap
std::map::try_emplace
std::map::upper_bound
std::map::value_comp
std::map::value_compare
std::map::~map
std::multimap
std::multimap::begin
std::multimap::cbegin
std::multimap::cend
std::multimap::clear
std::multimap::contains
std::multimap::count
std::multimap::crbegin
std::multimap::crend
std::multimap::emplace
std::multimap::emplace_hint
std::multimap::empty
std::multimap::end
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::operator=
std::multimap::rbegin
std::multimap::rend
std::multimap::size
std::multimap::swap
std::multimap::upper_bound
std::multimap::value_comp
std::multimap::value_compare
std::multimap::~multimap
std::multiset
std::multiset::begin
std::multiset::cbegin
std::multiset::cend
std::multiset::clear
std::multiset::contains
std::multiset::count
std::multiset::crbegin
std::multiset::crend
std::multiset::emplace
std::multiset::emplace_hint
std::multiset::empty
std::multiset::end
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::operator=
std::multiset::rbegin
std::multiset::rend
std::multiset::size
std::multiset::swap
std::multiset::upper_bound
std::multiset::value_comp
std::multiset::~multiset
std::priority_queue
std::priority_queue::emplace
std::priority_queue::empty
std::priority_queue::operator=
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::priority_queue::~priority_queue
std::queue
std::queue::back
std::queue::emplace
std::queue::empty
std::queue::front
std::queue::operator=
std::queue::pop
std::queue::push
std::queue::queue
std::queue::size
std::queue::swap
std::queue::~queue
std::set
std::set::begin
std::set::cbegin
std::set::cend
std::set::clear
std::set::contains
std::set::count
std::set::crbegin
std::set::crend
std::set::emplace
std::set::emplace_hint
std::set::empty
std::set::end
std::set::equal_range
std::set::erase
std::set::extract
std::set::find
std::set::get_allocator
std::set::insert
std::set::key_comp
std::set::lower_bound
std::set::max_size
std::set::merge
std::set::operator=
std::set::rbegin
std::set::rend
std::set::set
std::set::size
std::set::swap
std::set::upper_bound
std::set::value_comp
std::set::~set
std::span
std::span::back
std::span::begin
std::span::data
std::span::empty
std::span::end
std::span::first
std::span::front
std::span::last
std::span::operator=
std::span::operator[]
std::span::rbegin
std::span::rend
std::span::size
std::span::size_bytes
std::span::span
std::span::subspan
std::stack
std::stack::emplace
std::stack::empty
std::stack::operator=
std::stack::pop
std::stack::push
std::stack::size
std::stack::stack
std::stack::swap
std::stack::top
std::stack::~stack
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::to_array
std::tuple_size(std::array)
std::unordered_map
std::unordered_map::at
std::unordered_map::begin
std::unordered_map::begin(size_type)
std::unordered_map::bucket
std::unordered_map::bucket_count
std::unordered_map::bucket_size
std::unordered_map::cbegin
std::unordered_map::cbegin
std::unordered_map::cend
std::unordered_map::cend
std::unordered_map::clear
std::unordered_map::contains
std::unordered_map::count
std::unordered_map::emplace
std::unordered_map::emplace_hint
std::unordered_map::empty
std::unordered_map::end
std::unordered_map::end(size_type)
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::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_map::~unordered_map
std::unordered_multimap
std::unordered_multimap::begin
std::unordered_multimap::begin(size_type)
std::unordered_multimap::bucket
std::unordered_multimap::bucket_count
std::unordered_multimap::bucket_size
std::unordered_multimap::cbegin
std::unordered_multimap::cbegin
std::unordered_multimap::cend
std::unordered_multimap::cend
std::unordered_multimap::clear
std::unordered_multimap::contains
std::unordered_multimap::count
std::unordered_multimap::emplace
std::unordered_multimap::emplace_hint
std::unordered_multimap::empty
std::unordered_multimap::end
std::unordered_multimap::end(size_type)
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::operator=
std::unordered_multimap::rehash
std::unordered_multimap::reserve
std::unordered_multimap::size
std::unordered_multimap::swap
std::unordered_multimap::unordered_multimap
std::unordered_multimap::~unordered_multimap
std::unordered_multiset
std::unordered_multiset::begin
std::unordered_multiset::begin(size_type)
std::unordered_multiset::bucket
std::unordered_multiset::bucket_count
std::unordered_multiset::bucket_size
std::unordered_multiset::cbegin
std::unordered_multiset::cbegin
std::unordered_multiset::cend
std::unordered_multiset::cend
std::unordered_multiset::clear
std::unordered_multiset::contains
std::unordered_multiset::count
std::unordered_multiset::emplace
std::unordered_multiset::emplace_hint
std::unordered_multiset::empty
std::unordered_multiset::end
std::unordered_multiset::end(size_type)
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::operator=
std::unordered_multiset::rehash
std::unordered_multiset::reserve
std::unordered_multiset::size
std::unordered_multiset::swap
std::unordered_multiset::unordered_multiset
std::unordered_multiset::~unordered_multiset
std::unordered_set
std::unordered_set::begin
std::unordered_set::begin(size_type)
std::unordered_set::bucket
std::unordered_set::bucket_count
std::unordered_set::bucket_size
std::unordered_set::cbegin
std::unordered_set::cbegin
std::unordered_set::cend
std::unordered_set::cend
std::unordered_set::clear
std::unordered_set::contains
std::unordered_set::count
std::unordered_set::emplace
std::unordered_set::emplace_hint
std::unordered_set::empty
std::unordered_set::end
std::unordered_set::end(size_type)
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::operator=
std::unordered_set::rehash
std::unordered_set::reserve
std::unordered_set::size
std::unordered_set::swap
std::unordered_set::unordered_set
std::unordered_set::~unordered_set
std::vector
std::vector::assign
std::vector::at
std::vector::back
std::vector::begin
std::vector::capacity
std::vector::cbegin
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::end
std::vector::erase
std::vector::flip
std::vector::front
std::vector::get_allocator
std::vector::insert
std::vector::max_size
std::vector::operator=
std::vector::operator[]
std::vector::pop_back
std::vector::push_back
std::vector::rbegin
std::vector::reference
std::vector::rend
std::vector::reserve
std::vector::resize
std::vector::shrink_to_fit
std::vector::size
std::vector::swap
std::vector::vector
std::vector::~vector
Diagnostics
assert
errno
Error handling
Error numbers
operators (std::basic_stacktrace)
operators (std::stacktrace_entry)
std::basic_stacktrace
std::basic_stacktrace::at
std::basic_stacktrace::basic_stacktrace
std::basic_stacktrace::begin
std::basic_stacktrace::cbegin
std::basic_stacktrace::cend
std::basic_stacktrace::crbegin
std::basic_stacktrace::crend
std::basic_stacktrace::current
std::basic_stacktrace::empty
std::basic_stacktrace::end
std::basic_stacktrace::get_allocator
std::basic_stacktrace::max_size
std::basic_stacktrace::operator=
std::basic_stacktrace::operator[]
std::basic_stacktrace::rbegin
std::basic_stacktrace::rend
std::basic_stacktrace::size
std::basic_stacktrace::swap
std::basic_stacktrace::~basic_stacktrace
std::current_exception
std::domain_error
std::exception_ptr
std::generic_category
std::get_terminate
std::get_unexpected
std::hash(std::basic_stacktrace)
std::hash(std::stacktrace_entry)
std::invalid_argument
std::length_error
std::logic_error
std::make_exception_ptr
std::nested_exception
std::operator<<(std::basic_stacktrace)
std::operator<<(std::stacktrace_entry)
std::out_of_range
std::overflow_error
std::range_error
std::rethrow_exception
std::rethrow_if_nested
std::runtime_error
std::set_terminate
std::set_unexpected
std::stacktrace_entry
std::stacktrace_entry::description
std::stacktrace_entry::native_handle
std::stacktrace_entry::operator bool
std::stacktrace_entry::operator=
std::stacktrace_entry::source_file
std::stacktrace_entry::source_line
std::stacktrace_entry::stacktrace_entry
std::swap(std::basic_stacktrace)
std::system_category
std::terminate
std::terminate_handler
std::throw_with_nested
std::tx_exception
std::uncaught_exception
std::uncaught_exceptions
std::underflow_error
std::unexpected
std::unexpected_handler
Dynamic memory management
deduction guides for std::scoped_allocator_adaptor
operators (std::allocator)
operators (std::scoped_allocator_adaptor)
std::allocator
std::allocator::address
std::allocator::allocate
std::allocator::allocate_at_least
std::allocator::allocator
std::allocator::construct
std::allocator::deallocate
std::allocator::destroy
std::allocator::max_size
std::allocator::~allocator
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::monotonic_buffer_resource::~monotonic_buffer_resource
std::pmr::operator!=
std::pmr::operators (std::pmr::operator!=)
std::pmr::polymorphic_allocator
std::pmr::polymorphic_allocator:: select_on_container_copy_construction
std::pmr::polymorphic_allocator::allocate
std::pmr::polymorphic_allocator::allocate_bytes
std::pmr::polymorphic_allocator::allocate_object
std::pmr::polymorphic_allocator::construct
std::pmr::polymorphic_allocator::deallocate
std::pmr::polymorphic_allocator::deallocate_bytes
std::pmr::polymorphic_allocator::deallocate_object
std::pmr::polymorphic_allocator::delete_object
std::pmr::polymorphic_allocator::destroy
std::pmr::polymorphic_allocator::new_object
std::pmr::polymorphic_allocator::polymorphic_allocator
std::pmr::polymorphic_allocator::resource
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::synchronized_pool_resource::~synchronized_pool_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::pmr::unsynchronized_pool_resource::~unsynchronized_pool_resource
std::pointer_traits
std::pointer_traits::pointer_to
std::pointer_traits::to_address
std::raw_storage_iterator
std::raw_storage_iterator::base
std::raw_storage_iterator::operator*
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:: scoped_allocator_adaptor
std::scoped_allocator_adaptor:: select_on_container_copy_construction
std::scoped_allocator_adaptor:: ~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::operator=
std::scoped_allocator_adaptor::outer_allocator
Feature testing
Feature testing
Filesystem
Filesystem library
operator<<(std::filesystem::directory_entry)
operator==(std::filesystem::file_status)
operator>(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
std::filesystem::create_directory_symlink
std::filesystem::create_hard_link
std::filesystem::create_symlink
std::filesystem::current_path
std::filesystem::directory_entry
std::filesystem::directory_entry::assign
std::filesystem::directory_entry::directory_entry
std::filesystem::directory_entry::exists
std::filesystem::directory_entry::file_size
std::filesystem::directory_entry::hard_link_count
std::filesystem::directory_entry::is_block_file
std::filesystem::directory_entry::is_character_file
std::filesystem::directory_entry::is_directory
std::filesystem::directory_entry::is_fifo
std::filesystem::directory_entry::is_other
std::filesystem::directory_entry::is_regular_file
std::filesystem::directory_entry::is_socket
std::filesystem::directory_entry::is_symlink
std::filesystem::directory_entry::last_write_time
std::filesystem::directory_entry::operator=
std::filesystem::directory_entry::operators
std::filesystem::directory_entry::path
std::filesystem::directory_entry::refresh
std::filesystem::directory_entry::replace_filename
std::filesystem::directory_entry::status
std::filesystem::directory_entry::symlink_status
std::filesystem::directory_iterator
std::filesystem::directory_iterator::directory_iterator
std::filesystem::directory_iterator::operator->
std::filesystem::directory_iterator::operator=
std::filesystem::directory_iterator::operators
std::filesystem::directory_options
std::filesystem::end
std::filesystem::end
std::filesystem::equivalent
std::filesystem::exists
std::filesystem::file_size
std::filesystem::file_status
std::filesystem::file_status::file_status
std::filesystem::file_status::operator=
std::filesystem::file_status::permissions
std::filesystem::file_status::type
std::filesystem::file_time_type
std::filesystem::file_type
std::filesystem::filesystem_error
std::filesystem::filesystem_error::filesystem_error
std::filesystem::filesystem_error::operator=
std::filesystem::filesystem_error::path1
std::filesystem::filesystem_error::path2
std::filesystem::filesystem_error::what
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::c_str
std::filesystem::path::clear
std::filesystem::path::compare
std::filesystem::path::concat
std::filesystem::path::empty
std::filesystem::path::end
std::filesystem::path::extension
std::filesystem::path::filename
std::filesystem::path::format
std::filesystem::path::generic_string
std::filesystem::path::generic_u16string
std::filesystem::path::generic_u32string
std::filesystem::path::generic_u8string
std::filesystem::path::generic_wstring
std::filesystem::path::has_extension
std::filesystem::path::has_filename
std::filesystem::path::has_parent_path
std::filesystem::path::has_relative_path
std::filesystem::path::has_root_directory
std::filesystem::path::has_root_name
std::filesystem::path::has_root_path
std::filesystem::path::has_stem
std::filesystem::path::is_absolute
std::filesystem::path::lexically_normal
std::filesystem::path::lexically_proximate
std::filesystem::path::lexically_relative
std::filesystem::path::make_preferred
std::filesystem::path::native
std::filesystem::path::operator string_type()
std::filesystem::path::operator+=
std::filesystem::path::operator/=
std::filesystem::path::operator=
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::path::u16string
std::filesystem::path::u32string
std::filesystem::path::u8string
std::filesystem::path::wstring
std::filesystem::path::~path
std::filesystem::perm_options
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::operator->
std::filesystem::recursive_directory_iterator::operator=
std::filesystem::recursive_directory_iterator::operators
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::relative
std::filesystem::remove
std::filesystem::remove_all
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::symlink_status
std::filesystem::temp_directory_path
std::filesystem::u8path
std::filesystem::weakly_canonical
std::hash
Input/output
C-style file input/output
egptr
gptr
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::operator=
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_filebuf::~basic_filebuf
std::basic_fstream
std::basic_fstream::basic_fstream
std::basic_fstream::close
std::basic_fstream::is_open
std::basic_fstream::open
std::basic_fstream::operator=
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::operator=
std::basic_ifstream::rdbuf
std::basic_ifstream::swap
std::basic_ios
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::operator!
std::basic_ios::rdbuf
std::basic_ios::rdstate
std::basic_ios::set_rdbuf
std::basic_ios::setstate
std::basic_ios::swap
std::basic_ios::tie
std::basic_ios::widen
std::basic_ios::~basic_ios
std::basic_iostream
std::basic_iostream::basic_iostream
std::basic_iostream::operator=
std::basic_iostream::swap
std::basic_iostream::~basic_iostream
std::basic_ispanstream
std::basic_ispanstream::basic_ispanstream
std::basic_ispanstream::operator=
std::basic_ispanstream::rdbuf
std::basic_ispanstream::span
std::basic_ispanstream::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::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_istream::~basic_istream
std::basic_istringstream
std::basic_istringstream::basic_istringstream
std::basic_istringstream::operator=
std::basic_istringstream::rdbuf
std::basic_istringstream::str
std::basic_istringstream::swap
std::basic_istringstream::view
std::basic_ofstream
std::basic_ofstream::basic_ofstream
std::basic_ofstream::close
std::basic_ofstream::is_open
std::basic_ofstream::open
std::basic_ofstream::operator=
std::basic_ofstream::rdbuf
std::basic_ofstream::swap
std::basic_ospanstream
std::basic_ospanstream::basic_ospanstream
std::basic_ospanstream::operator=
std::basic_ospanstream::rdbuf
std::basic_ospanstream::span
std::basic_ospanstream::swap
std::basic_ostream
std::basic_ostream::basic_ostream
std::basic_ostream::flush
std::basic_ostream::operator<<
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_ostream::~basic_ostream
std::basic_ostringstream
std::basic_ostringstream::basic_ostringstream
std::basic_ostringstream::operator=
std::basic_ostringstream::rdbuf
std::basic_ostringstream::str
std::basic_ostringstream::swap
std::basic_ostringstream::view
std::basic_osyncstream
std::basic_osyncstream::basic_osyncstream
std::basic_osyncstream::emit
std::basic_osyncstream::get_wrapped
std::basic_osyncstream::operator=
std::basic_osyncstream::rdbuf
std::basic_osyncstream::~basic_osyncstream
std::basic_spanbuf
std::basic_spanbuf::basic_spanbuf
std::basic_spanbuf::operator=
std::basic_spanbuf::seekoff
std::basic_spanbuf::seekpos
std::basic_spanbuf::setbuf
std::basic_spanbuf::span
std::basic_spanbuf::swap
std::basic_spanstream
std::basic_spanstream::basic_spanstream
std::basic_spanstream::operator=
std::basic_spanstream::rdbuf
std::basic_spanstream::span
std::basic_spanstream::swap
std::basic_streambuf
std::basic_streambuf::basic_streambuf
std::basic_streambuf::eback
std::basic_streambuf::epptr
std::basic_streambuf::gbump
std::basic_streambuf::getloc
std::basic_streambuf::imbue
std::basic_streambuf::in_avail
std::basic_streambuf::operator=
std::basic_streambuf::overflow
std::basic_streambuf::pbackfail
std::basic_streambuf::pbase
std::basic_streambuf::pbump
std::basic_streambuf::pptr
std::basic_streambuf::pubimbue
std::basic_streambuf::pubseekoff
std::basic_streambuf::pubseekpos
std::basic_streambuf::pubsetbuf
std::basic_streambuf::pubsync
std::basic_streambuf::sbumpc
std::basic_streambuf::seekoff
std::basic_streambuf::seekpos
std::basic_streambuf::setbuf
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::stossc
std::basic_streambuf::sungetc
std::basic_streambuf::swap
std::basic_streambuf::sync
std::basic_streambuf::uflow
std::basic_streambuf::underflow
std::basic_streambuf::xsgetn
std::basic_streambuf::xsputn
std::basic_streambuf::~basic_streambuf
std::basic_stringbuf
std::basic_stringbuf::basic_stringbuf
std::basic_stringbuf::get_allocator
std::basic_stringbuf::operator=
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_stringbuf::view
std::basic_stringstream
std::basic_stringstream::basic_stringstream
std::basic_stringstream::operator=
std::basic_stringstream::rdbuf
std::basic_stringstream::str
std::basic_stringstream::swap
std::basic_stringstream::view
std::basic_syncbuf
std::basic_syncbuf::basic_syncbuf
std::basic_syncbuf::emit
std::basic_syncbuf::get_allocator
std::basic_syncbuf::get_wrapped
std::basic_syncbuf::operator=
std::basic_syncbuf::set_emit_on_sync
std::basic_syncbuf::swap
std::basic_syncbuf::sync
std::basic_syncbuf::~basic_syncbuf
std::boolalpha
std::cerr
std::cin
std::clearerr
std::clog
std::cout
std::dec
std::defaultfloat
std::emit_on_flush
std::endl
std::ends
std::fclose
std::feof
std::ferror
std::fflush
std::fgetc
std::fgetpos
std::fgets
std::fgetwc
std::fgetws
std::FILE
std::fixed
std::flush
std::flush_emit
std::fopen
std::fpos
std::fpos::state
std::fpos_t
std::fprintf
std::fputc
std::fputs
std::fputwc
std::fputws
std::fread
std::freopen
std::fscanf
std::fseek
std::fsetpos
std::ftell
std::fwide
std::fwprintf
std::fwrite
std::fwscanf
std::get_money
std::get_time
std::getc
std::getchar
std::gets
std::getwchar
std::hex
std::hexfloat
std::internal
std::io_errc
std::ios_base
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::ios_base
std::ios_base::iostate
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::ios_base::~ios_base
std::iostream_category
std::istrstream
std::istrstream::istrstream
std::istrstream::rdbuf
std::istrstream::str
std::istrstream::~istrstream
std::left
std::make_error_code(std::io_errc)
std::make_error_condition(std::io_errc)
std::noboolalpha
std::noemit_on_flush
std::noshowbase
std::noshowpoint
std::noshowpos
std::noskipws
std::nounitbuf
std::nouppercase
std::oct
std::ostrstream
std::ostrstream::freeze
std::ostrstream::ostrstream
std::ostrstream::pcount
std::ostrstream::rdbuf
std::ostrstream::str
std::ostrstream::~ostrstream
std::perror
std::printf
std::put_money
std::put_time
std::putc
std::putchar
std::puts
std::putwchar
std::quoted
std::rename
std::resetiosflags
std::rewind
std::right
std::scanf
std::scientific
std::setbase
std::setbuf
std::setfill
std::setiosflags
std::setprecision
std::setvbuf
std::setw
std::showbase
std::showpoint
std::showpos
std::skipws
std::snprintf
std::sprintf
std::sscanf
std::streamoff
std::streamsize
std::strstream
std::strstream::freeze
std::strstream::pcount
std::strstream::rdbuf
std::strstream::str
std::strstream::strstream
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::strstreambuf::~strstreambuf
std::swap(std::basic_filebuf)
std::swap(std::basic_fstream)
std::swap(std::basic_ifstream)
std::swap(std::basic_ispanstream)
std::swap(std::basic_istringstream)
std::swap(std::basic_ofstream)
std::swap(std::basic_ospanstream)
std::swap(std::basic_ostringstream)
std::swap(std::basic_spanbuf)
std::swap(std::basic_spanstream)
std::swap(std::basic_stringbuf)
std::swap(std::basic_stringstream)
std::swap(std::basic_syncbuf)
std::swprintf
std::swscanf
std::tmpfile
std::tmpnam
std::ungetc
std::ungetwc
std::unitbuf
std::uppercase
std::vfprintf
std::vfscanf
std::vfwprintf
std::vfwscanf
std::vprintf
std::vscanf
std::vsnprintf
std::vsprintf
std::vsscanf
std::vswprintf
std::vswscanf
std::vwprintf
std::vwscanf
std::wcerr
std::wcin
std::wclog
std::wcout
std::wprintf
std::ws
std::wscanf
stderr
stdin
stdout
Iterator
iter_move(std::common_iterator)
iter_move(std::counted_iterator)
iter_move(std::move_iterator)
iter_swap(std::common_iterator)
iter_swap(std::counted_iterator)
iter_swap(std::move_iterator)
Iterator library
operator+(std::counted_iterator)
operator+(std::move_iterator)
operator+(std::reverse_iterator)
operator-(std::common_iterator)
operator-(std::counted_iterator)
operator-(std::move_iterator)
operator-(std::reverse_iterator)
operator==(std::common_iterator)
operators (std::counted_iterator)
operators (std::default_sentinel_t)
operators (std::istream_iterator)
operators (std::istreambuf_iterator)
operators (std::move_iterator)
operators (std::move_sentinel)
operators (std::reverse_iterator)
std::advance
std::back_insert_iterator
std::back_insert_iterator::back_insert_iterator
std::back_insert_iterator::operator*
std::back_insert_iterator::operator++
std::back_insert_iterator::operator=
std::back_inserter
std::begin
std::bidirectional_iterator
std::bidirectional_iterator_tag
std::cbegin
std::cend
std::common_iterator
std::common_iterator::common_iterator
std::common_iterator::operator++
std::common_iterator::operator=
std::common_iterator::operators
std::contiguous_iterator
std::contiguous_iterator_tag
std::counted_iterator
std::counted_iterator::base
std::counted_iterator::count
std::counted_iterator::counted_iterator
std::counted_iterator::operator=
std::counted_iterator::operator[]
std::counted_iterator::operators
std::crbegin
std::crend
std::data
std::default_sentinel
std::default_sentinel_t
std::disable_sized_sentinel_for
std::distance
std::empty
std::end
std::forward_iterator
std::forward_iterator_tag
std::front_insert_iterator
std::front_insert_iterator::front_insert_iterator
std::front_insert_iterator::operator*
std::front_insert_iterator::operator++
std::front_insert_iterator::operator=
std::front_inserter
std::incrementable
std::incrementable_traits
std::indirect_binary_predicate
std::indirect_equivalence_relation
std::indirect_result_t
std::indirect_strict_weak_order
std::indirect_unary_predicate
std::indirectly_comparable
std::indirectly_copyable
std::indirectly_copyable_storable
std::indirectly_movable
std::indirectly_movable_storable
std::indirectly_readable
std::indirectly_readable_traits
std::indirectly_regular_unary_invocable
std::indirectly_swappable
std::indirectly_unary_invocable
std::indirectly_writable
std::input_iterator
std::input_iterator_tag
std::input_or_output_iterator
std::insert_iterator
std::insert_iterator::insert_iterator
std::insert_iterator::operator*
std::insert_iterator::operator++
std::insert_iterator::operator=
std::inserter
std::istream_iterator
std::istream_iterator::istream_iterator
std::istream_iterator::operators (int)
std::istream_iterator::operators (operator->)
std::istream_iterator::~istream_iterator
std::istreambuf_iterator
std::istreambuf_iterator::equal
std::istreambuf_iterator::istreambuf_iterator
std::istreambuf_iterator::operators (int)
std::istreambuf_iterator::operators (operator->)
std::iter_common_reference_t
std::iter_difference_t
std::iter_move(std::reverse_iterator)
std::iter_reference_t
std::iter_rvalue_reference_t
std::iter_swap(std::reverse_iterator)
std::iter_value_t
std::iterator
std::iterator_traits
std::make_move_iterator
std::make_reverse_iterator
std::mergeable
std::move_iterator
std::move_iterator::base
std::move_iterator::move_iterator
std::move_iterator::operator=
std::move_iterator::operator[]
std::move_iterator::operators
std::move_sentinel
std::move_sentinel::base
std::move_sentinel::move_sentinel
std::move_sentinel::operator=
std::next
std::ostream_iterator
std::ostream_iterator::operator*
std::ostream_iterator::operator++
std::ostream_iterator::operator=
std::ostream_iterator::ostream_iterator
std::ostream_iterator::~ostream_iterator
std::ostreambuf_iterator
std::ostreambuf_iterator::failed
std::ostreambuf_iterator::operator*
std::ostreambuf_iterator::operator++
std::ostreambuf_iterator::operator=
std::ostreambuf_iterator::ostreambuf_iterator
std::output_iterator
std::output_iterator_tag
std::permutable
std::prev
std::projected
std::random_access_iterator
std::random_access_iterator_tag
std::ranges::advance
std::ranges::distance
std::ranges::iter_move
std::ranges::iter_swap
std::ranges::next
std::ranges::prev
std::rbegin
std::rend
std::reverse_iterator
std::reverse_iterator::base
std::reverse_iterator::operator=
std::reverse_iterator::operator[]
std::reverse_iterator::operators
std::reverse_iterator::reverse_iterator
std::sentinel_for
std::size
std::sized_sentinel_for
std::sortable
std::ssize
std::unreachable_sentinel
std::unreachable_sentinel_t
std::weakly_incrementable
Keywords
alignas
alignof
and
and_eq
asm
auto
bitand
bitor
bool
break
case
catch
char
char16_t
char32_t
char8_t
class
co_await
co_return
co_yield
compl
concept
const
const_cast
consteval
constexpr
constinit
continue
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
final
float
for
friend
goto
if
import
inline
int
keywords
long
module
mutable
namespace
noexcept
not
not_eq
operator
or
or_eq
override
private
protected
public
reflexpr
register
reinterpret_cast
requires
return
short
signed
sizeof
static
static_assert
static_cast
struct
switch
template
this
thread_local
throw
true
try
typedef
typeid
typename
union
unsigned
using
virtual
void
volatile
wchar_t
while
xor
xor_eq
Language
#define directive
#error directive
#include directive
#line directive
#pragma directive
Abstract class
Access specifiers
Acronyms
Address of an overloaded function
Aggregate initialization
alias template
alignas specifier
alignof operator
Alternative operator representations
Argument-dependent lookup
Arithmetic operators
Array declaration
ASCII Chart
asm declaration
Assignment operators
Attribute specifier sequence(since C++11)
attribute: carries_dependency
attribute: deprecated
attribute: fallthrough
attribute: likely
attribute: maybe_unused
attribute: no_unique_address
attribute: nodiscard
attribute: noreturn
attribute: optimize_for_synchronized
Basic concepts
Bit-field
Boolean literals
break statement
C++ language
Character literal
Character sets and encodings
Class declaration
Class template
Class template argument deduction
Classes
Comments
Comparison operators
Conditional inclusion
const_cast conversion
Constant expressions
Constant initialization
consteval specifier
constexpr specifier
constinit specifier
Constraints and concepts
Constructors and member initializer lists
continue statement
Converting constructor
Copy assignment operator
Copy constructors
Copy elision
Copy initialization
Coroutines
Curiously Recurring Template Pattern
cv type qualifiers
Declarations
decltype specifier
Default arguments
Default comparisons
Default constructors
Default initialization
Definitions and ODR
delete expression
Dependent names
Derived classes
Destructors
Direct initialization
do-while loop
Dynamic exception specification
dynamic_cast conversion
Elaborated type specifier
Empty base optimization
Enumeration declaration
Escape sequences
Exceptions
explicit specifier
Explicit template specialization
Explicit type conversion
Expressions
Extending the namespace std
final specifier
Floating-point literal
fold expression(since C++17)
for loop
Friend declaration
Function declaration
Function template
Function-try-block
Functions
Fundamental types
goto statement
History of C++
Identifiers
if statement
Implicit conversions
Increment/decrement operators
Initialization
Injected-class-name
inline specifier
Integer literal
Lambda expressions
Language linkage
Lifetime
List-initialization
Logical operators
Main function
Member access operators
Member templates
Memory model
Modules
Move assignment operator
Move constructors
Name lookup
Namespace aliases
Namespaces
Nested classes
new expression
No Diagnostic Required
noexcept operator
noexcept specifier
Non-static data members
Non-static member functions
nullptr
Object
operator overloading
Operator Precedence
Order of evaluation
Other operators
Overload resolution
override specifier
Parameter pack(since C++11)
Partial template specialization
Phases of translation
PImpl
Placeholder type specifiers
Pointer declaration
Preprocessor
Punctuation
Qualified name lookup
RAII
Range-based for loop
Reference declaration
Reference initialization
reinterpret_cast conversion
return statement
Scope
SFINAE
sizeof operator
sizeof... operator
Statements
static members
static_assert declaration
static_cast conversion
Storage class specifiers
String literal
Structured binding declaration
switch statement
Template argument deduction
Template Metaprogramming
Template parameters and template arguments
Templates
The as-if rule
the pointer literal
The rule of three/five/zero
The this pointer
throw expression
Transactional memory
Translation-unit-local entities
try-block
Type
Type alias
typedef specifier
typeid operator
Undefined behavior
Union declaration
unlikely
Unqualified name lookup
user-defined conversion function
User-defined literals
Using-declaration
Value categories
Value initialization
Variable template
Variadic arguments
virtual function specifier
while loop
Zero initialization
Zero-overhead principle
Localizations
do_always_noconv
do_curr_symbol
do_decimal_point
do_decimal_point
do_encoding
do_falsename
do_frac_digits
do_get
do_grouping
do_length
do_max_length
do_narrow
do_neg_format
do_negative_sign
do_out
do_pos_format
do_positive_sign
do_put
do_thousands_sep
do_thousands_sep
do_transform
do_truename
do_unshift
do_widen
falsename
LC_ALL
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
Localization library
neg_format
negative_sign
std::codecvt
std::codecvt::always_noconv
std::codecvt::codecvt
std::codecvt::do_in
std::codecvt::encoding
std::codecvt::in
std::codecvt::length
std::codecvt::max_length
std::codecvt::out
std::codecvt::unshift
std::codecvt::~codecvt
std::codecvt_base
std::codecvt_byname
std::codecvt_mode
std::codecvt_utf16
std::codecvt_utf8
std::codecvt_utf8_utf16
std::collate
std::collate::collate
std::collate::compare
std::collate::do_compare
std::collate::do_hash
std::collate::hash
std::collate::transform
std::collate::~collate
std::collate_byname
std::ctype
std::ctype::classic_table
std::ctype::ctype
std::ctype::do_is
std::ctype::do_scan_is
std::ctype::do_tolower
std::ctype::do_toupper
std::ctype::is
std::ctype::narrow
std::ctype::scan_is
std::ctype::scan_not
std::ctype::table
std::ctype::tolower
std::ctype::toupper
std::ctype::widen
std::ctype::~ctype
std::ctype_base
std::ctype_byname
std::has_facet
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::lconv
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::operator()
std::locale::operator=
std::locale::operators (operator!=)
std::locale::~locale
std::localeconv
std::messages
std::messages::close
std::messages::do_close
std::messages::do_get
std::messages::do_open
std::messages::get
std::messages::messages
std::messages::open
std::messages::~messages
std::messages_base
std::messages_byname
std::money_base
std::money_get
std::money_get::get
std::money_get::money_get
std::money_get::~money_get
std::money_put
std::money_put::money_put
std::money_put::put
std::money_put::~money_put
std::moneypunct
std::moneypunct::curr_symbol
std::moneypunct::decimal_point
std::moneypunct::frac_digits
std::moneypunct::grouping
std::moneypunct::moneypunct
std::moneypunct::pos_format
std::moneypunct::positive_sign
std::moneypunct::thousands_sep
std::moneypunct::~moneypunct
std::moneypunct_byname
std::num_get
std::num_get::do_get
std::num_get::get
std::num_get::num_get
std::num_get::~num_get
std::num_put
std::num_put::do_put
std::num_put::num_put
std::num_put::put
std::num_put::~num_put
std::numpunct
std::numpunct::decimal_point
std::numpunct::do_grouping
std::numpunct::grouping
std::numpunct::numpunct
std::numpunct::thousands_sep
std::numpunct::truename
std::numpunct::~numpunct
std::numpunct_byname
std::setlocale
std::time_base
std::time_get
std::time_get::date_order
std::time_get::do_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::get
std::time_get::get_date
std::time_get::get_monthname
std::time_get::get_time
std::time_get::get_weekday
std::time_get::get_year
std::time_get::time_get
std::time_get::~time_get
std::time_get_byname
std::time_put
std::time_put::do_put
std::time_put::put
std::time_put::time_put
std::time_put::~time_put
std::time_put_byname
std::tolower(std::locale)
std::toupper(std::locale)
std::use_facet
std::wbuffer_convert
std::wbuffer_convert::rdbuf
std::wbuffer_convert::state
std::wbuffer_convert::wbuffer_convert
std::wbuffer_convert::~wbuffer_convert
std::wstring_convert
std::wstring_convert:: ~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
Metaprogramming
Compile-time rational arithmetic
Metaprogramming library
std::add_const
std::add_cv
std::add_lvalue_reference
std::add_pointer
std::add_rvalue_reference
std::add_volatile
std::aligned_storage
std::aligned_union
std::alignment_of
std::common_reference
std::common_type
std::conditional
std::conjunction
std::decay
std::disjunction
std::enable_if
std::extent
std::has_unique_object_representations
std::has_virtual_destructor
std::integer_sequence
std::integral_constant
std::invoke_result
std::is_abstract
std::is_aggregate
std::is_arithmetic
std::is_array
std::is_assignable
std::is_base_of
std::is_bounded_array
std::is_class
std::is_compound
std::is_const
std::is_constructible
std::is_convertible
std::is_copy_assignable
std::is_copy_constructible
std::is_corresponding_member
std::is_default_constructible
std::is_destructible
std::is_empty
std::is_enum
std::is_final
std::is_floating_point
std::is_function
std::is_fundamental
std::is_integral
std::is_invocable
std::is_invocable_r
std::is_layout_compatible
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_assignable
std::is_nothrow_constructible
std::is_nothrow_convertible
std::is_nothrow_copy_assignable
std::is_nothrow_copy_constructible
std::is_nothrow_default_constructible
std::is_nothrow_destructible
std::is_nothrow_invocable
std::is_nothrow_invocable_r
std::is_nothrow_move_assignable
std::is_nothrow_move_constructible
std::is_nothrow_swappable
std::is_nothrow_swappable_with
std::is_null_pointer
std::is_object
std::is_pod
std::is_pointer
std::is_pointer_interconvertible_base_of
std::is_pointer_interconvertible_with_class
std::is_polymorphic
std::is_reference
std::is_rvalue_reference
std::is_same
std::is_scalar
std::is_scoped_enum
std::is_signed
std::is_standard_layout
std::is_swappable
std::is_swappable_with
std::is_trivial
std::is_trivially_assignable
std::is_trivially_constructible
std::is_trivially_copy_assignable
std::is_trivially_copy_constructible
std::is_trivially_copyable
std::is_trivially_default_constructible
std::is_trivially_destructible
std::is_trivially_move_assignable
std::is_trivially_move_constructible
std::is_unbounded_array
std::is_union
std::is_unsigned
std::is_void
std::is_volatile
std::make_signed
std::make_unsigned
std::negation
std::rank
std::ratio
std::ratio_add
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::reference_constructs_from_temporary
std::reference_converts_from_temporary
std::remove_all_extents
std::remove_const
std::remove_cv
std::remove_cvref
std::remove_extent
std::remove_pointer
std::remove_reference
std::remove_volatile
std::result_of
std::type_identity
std::underlying_type
std::void_t
Named requirements
Named Requirements
named requirements: Allocator
named requirements: AllocatorAwareContainer
named requirements: AssociativeContainer
named requirements: BasicFormatter
named requirements: BasicLockable
named requirements: BinaryPredicate
named requirements: BinaryTypeTrait
named requirements: BitmaskType
named requirements: Callable
named requirements: CharTraits
named requirements: Clock
named requirements: Compare
named requirements: ConstexprIterator
named requirements: Container
named requirements: ContiguousContainer
named requirements: CopyAssignable
named requirements: CopyConstructible
named requirements: CopyInsertable
named requirements: DefaultConstructible
named requirements: DefaultInsertable
named requirements: Destructible
named requirements: EmplaceConstructible
named requirements: EqualityComparable
named requirements: Erasable
named requirements: FormattedInputFunction
named requirements: FormattedOutputFunction
named requirements: Formatter
named requirements: FunctionObject
named requirements: Hash
named requirements: ImplicitLifetimeType
named requirements: LegacyBidirectionalIterator
named requirements: LegacyContiguousIterator
named requirements: LegacyForwardIterator
named requirements: LegacyInputIterator
named requirements: LegacyIterator
named requirements: LegacyOutputIterator
named requirements: LegacyRandomAccessIterator
named requirements: LessThanComparable
named requirements: LiteralType
named requirements: Lockable
named requirements: MoveAssignable
named requirements: MoveConstructible
named requirements: MoveInsertable
named requirements: Mutex
named requirements: NullablePointer
named requirements: NumericType
named requirements: PODType
named requirements: Predicate
named requirements: RandomNumberDistribution
named requirements: RandomNumberEngine
named requirements: RandomNumberEngineAdaptor
named requirements: RegexTraits
named requirements: ReversibleContainer
named requirements: ScalarType
named requirements: SeedSequence
named requirements: SequenceContainer
named requirements: SharedLockable
named requirements: SharedMutex
named requirements: SharedTimedLockable
named requirements: SharedTimedMutex
named requirements: StandardLayoutType
named requirements: Swappable
named requirements: TimedLockable
named requirements: TimedMutex
named requirements: TransformationTrait
named requirements: TrivialClock
named requirements: TriviallyCopyable
named requirements: TrivialType
named requirements: UnaryTypeTrait
named requirements: UnformattedInputFunction
named requirements: UnformattedOutputFunction
named requirements: UniformRandomBitGenerator
named requirements: UnorderedAssociativeContainer
named requirements: ValueSwappable
Numerics
beta
Common mathematical functions
deduction guides for std::valarray
densities
densities
FE_ALL_EXCEPT
FE_DFL_ENV
FE_DIVBYZERO
FE_DOWNWARD
FE_INEXACT
FE_INVALID
FE_OVERFLOW
FE_TONEAREST
FE_TOWARDZERO
FE_UNDERFLOW
FE_UPWARD
Floating-point environment
FP_INFINITE
FP_NAN
FP_NORMAL
FP_SUBNORMAL
FP_ZERO
HUGE_VAL
HUGE_VALF
HUGE_VALL
INFINITY
MATH_ERREXCEPT
math_errhandling
MATH_ERRNO
Mathematical constants
Mathematical special functions
Numerics library
operator>(std::bernoulli_distribution)
operator>(std::binomial_distribution)
operator>(std::cauchy_distribution)
operator>(std::chi_squared_distribution)
operator>(std::complex)
operator>(std::discard_block_engine)
operator>(std::discrete_distribution)
operator>(std::exponential_distribution)
operator>(std::extreme_value_distribution)
operator>(std::fisher_f_distribution)
operator>(std::gamma_distribution)
operator>(std::geometric_distribution)
operator>(std::independent_bits_engine)
operator>(std::linear_congruential_engine)
operator>(std::lognormal_distribution)
operator>(std::mersenne_twister_engine)
operator>(std::negative_binomial_distribution)
operator>(std::normal_distribution)
operator>(std::piecewise_constant_distribution)
operator>(std::piecewise_linear_distribution)
operator>(std::poisson_distribution)
operator>(std::shuffle_order_engine)
operator>(std::student_t_distribution)
operator>(std::subtract_with_carry_engine)
operator>(std::uniform_int_distribution)
operator>(std::uniform_real_distribution)
operator>(std::weibull_distribution)
operators
operators (std::bernoulli_distribution)
operators (std::binomial_distribution)
operators (std::cauchy_distribution)
operators (std::chi_squared_distribution)
operators (std::complex)
operators (std::discard_block_engine)
operators (std::discrete_distribution)
operators (std::exponential_distribution)
operators (std::extreme_value_distribution)
operators (std::fisher_f_distribution)
operators (std::gamma_distribution)
operators (std::geometric_distribution)
operators (std::independent_bits_engine)
operators (std::linear_congruential_engine)
operators (std::lognormal_distribution)
operators (std::mersenne_twister_engine)
operators (std::negative_binomial_distribution)
operators (std::normal_distribution)
operators (std::piecewise_constant_distribution)
operators (std::piecewise_linear_distribution)
operators (std::poisson_distribution)
operators (std::shuffle_order_engine)
operators (std::student_t_distribution)
operators (std::subtract_with_carry_engine)
operators (std::uniform_int_distribution)
operators (std::uniform_real_distribution)
operators (std::valarray)
operators (std::weibull_distribution)
Pseudo-random number generation
RAND_MAX
std::abs
std::abs(float)
std::abs(std::complex)
std::abs(std::valarray)
std::acos
std::acos(std::complex)
std::acos(std::valarray)
std::acosf
std::acosh
std::acosh(std::complex)
std::acoshf
std::acoshl
std::acosl
std::arg(std::complex)
std::asin
std::asin(std::complex)
std::asin(std::valarray)
std::asinf
std::asinh
std::asinh(std::complex)
std::asinhf
std::asinhl
std::asinl
std::assoc_laguerre
std::assoc_laguerref
std::assoc_laguerrel
std::assoc_legendre
std::assoc_legendref
std::assoc_legendrel
std::atan
std::atan(std::complex)
std::atan(std::valarray)
std::atan2
std::atan2(std::valarray)
std::atan2f
std::atan2l
std::atanf
std::atanh
std::atanh(std::complex)
std::atanhf
std::atanhl
std::atanl
std::begin(std::valarray)
std::bernoulli_distribution
std::bernoulli_distribution::bernoulli_distribution
std::bernoulli_distribution::max
std::bernoulli_distribution::min
std::bernoulli_distribution::operator()
std::bernoulli_distribution::p
std::bernoulli_distribution::param
std::bernoulli_distribution::reset
std::beta
std::betaf
std::betal
std::binomial_distribution
std::binomial_distribution::binomial_distribution
std::binomial_distribution::max
std::binomial_distribution::min
std::binomial_distribution::operator()
std::binomial_distribution::p
std::binomial_distribution::param
std::binomial_distribution::reset
std::bit_cast
std::bit_ceil
std::bit_floor
std::bit_width
std::byteswap
std::cauchy_distribution
std::cauchy_distribution::a
std::cauchy_distribution::cauchy_distribution
std::cauchy_distribution::max
std::cauchy_distribution::min
std::cauchy_distribution::operator()
std::cauchy_distribution::param
std::cauchy_distribution::reset
std::cbrt
std::cbrtf
std::cbrtl
std::ceil
std::ceilf
std::ceill
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::operator()
std::chi_squared_distribution::param
std::chi_squared_distribution::reset
std::comp_ellint_1
std::comp_ellint_1f
std::comp_ellint_1l
std::comp_ellint_2
std::comp_ellint_2f
std::comp_ellint_2l
std::comp_ellint_3
std::comp_ellint_3f
std::comp_ellint_3l
std::complex
std::complex::complex
std::complex::imag
std::complex::operator=
std::complex::operators
std::complex::operators (unary)
std::complex::real
std::conj(std::complex)
std::copysign
std::copysignf
std::copysignl
std::cos
std::cos(std::complex)
std::cos(std::valarray)
std::cosf
std::cosh
std::cosh(std::complex)
std::cosh(std::valarray)
std::coshf
std::coshl
std::cosl
std::countl_one
std::countl_zero
std::countr_one
std::countr_zero
std::cyl_bessel_i
std::cyl_bessel_if
std::cyl_bessel_il
std::cyl_bessel_j
std::cyl_bessel_jf
std::cyl_bessel_jl
std::cyl_bessel_k
std::cyl_bessel_kf
std::cyl_bessel_kl
std::cyl_neumann
std::cyl_neumannf
std::cyl_neumannl
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::operator()
std::discard_block_engine::seed
std::discrete_distribution
std::discrete_distribution::discrete_distribution
std::discrete_distribution::max
std::discrete_distribution::min
std::discrete_distribution::operator()
std::discrete_distribution::param
std::discrete_distribution::probabilities
std::discrete_distribution::reset
std::div
std::ellint_1
std::ellint_1f
std::ellint_1l
std::ellint_2
std::ellint_2f
std::ellint_2l
std::ellint_3
std::ellint_3f
std::ellint_3l
std::end(std::valarray)
std::endian
std::erf
std::erfc
std::erfcf
std::erfcl
std::erff
std::erfl
std::exp
std::exp(std::complex)
std::exp(std::valarray)
std::exp2
std::exp2f
std::exp2l
std::expf
std::expint
std::expintf
std::expintl
std::expl
std::expm1
std::expm1f
std::expm1l
std::exponential_distribution
std::exponential_distribution::exponential_distribution
std::exponential_distribution::lambda
std::exponential_distribution::max
std::exponential_distribution::min
std::exponential_distribution::operator()
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::operator()
std::extreme_value_distribution::param
std::extreme_value_distribution::reset
std::fabs
std::fabsf
std::fabsl
std::fdim
std::fdimf
std::fdiml
std::feclearexcept
std::fegetenv
std::fegetexceptflag
std::fegetround
std::feholdexcept
std::feraiseexcept
std::fesetenv
std::fesetexceptflag
std::fesetround
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::operator()
std::fisher_f_distribution::param
std::fisher_f_distribution::reset
std::floor
std::floorf
std::floorl
std::fma
std::fmaf
std::fmal
std::fmax
std::fmaxf
std::fmaxl
std::fmin
std::fminf
std::fminl
std::fmod
std::fmodf
std::fmodl
std::fpclassify
std::frexp
std::frexpf
std::frexpl
std::gamma_distribution
std::gamma_distribution::alpha
std::gamma_distribution::gamma_distribution
std::gamma_distribution::max
std::gamma_distribution::min
std::gamma_distribution::operator()
std::gamma_distribution::param
std::gamma_distribution::reset
std::gcd
std::generate_canonical
std::geometric_distribution
std::geometric_distribution::geometric_distribution
std::geometric_distribution::max
std::geometric_distribution::min
std::geometric_distribution::operator()
std::geometric_distribution::p
std::geometric_distribution::param
std::geometric_distribution::reset
std::gslice
std::gslice_array
std::gslice_array::gslice_array
std::gslice_array::operator=
std::gslice_array::operators
std::gslice_array::~gslice_array
std::has_single_bit
std::hermite
std::hermitef
std::hermitel
std::hypot
std::hypotf
std::hypotl
std::ilogb
std::ilogbf
std::ilogbl
std::imag(std::complex)
std::imaxabs
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::operator()
std::independent_bits_engine::seed
std::indirect_array
std::indirect_array::indirect_array
std::indirect_array::operator=
std::indirect_array::operators
std::indirect_array::~indirect_array
std::isfinite
std::isgreater
std::isgreaterequal
std::isinf
std::isless
std::islessequal
std::islessgreater
std::isnan
std::isnormal
std::isunordered
std::labs
std::laguerre
std::laguerref
std::laguerrel
std::lcm
std::ldexp
std::ldexpf
std::ldexpl
std::ldiv
std::legendre
std::legendref
std::legendrel
std::lerp
std::lgamma
std::lgammaf
std::lgammal
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::operator()
std::linear_congruential_engine::seed
std::literals::complex_literals::operators
std::llabs
std::lldiv
std::llrint
std::llrintf
std::llround
std::llroundf
std::log
std::log(std::complex)
std::log(std::valarray)
std::log10
std::log10(std::complex)
std::log10(std::valarray)
std::log10f
std::log10l
std::log1p
std::log1pf
std::log1pl
std::log2
std::log2f
std::log2l
std::logb
std::logbf
std::logbl
std::logf
std::logl
std::lognormal_distribution
std::lognormal_distribution::lognormal_distribution
std::lognormal_distribution::m
std::lognormal_distribution::max
std::lognormal_distribution::min
std::lognormal_distribution::operator()
std::lognormal_distribution::param
std::lognormal_distribution::reset
std::lrint
std::lrintf
std::lrintl
std::lround
std::lroundf
std::lroundl
std::mask_array
std::mask_array::mask_array
std::mask_array::operator=
std::mask_array::operators
std::mask_array::~mask_array
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::operator()
std::mersenne_twister_engine::seed
std::midpoint
std::modf
std::modff
std::modfl
std::nan
std::nanf
std::nanl
std::nearbyint
std::nearbyintf
std::nearbyintl
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::operator()
std::negative_binomial_distribution::p
std::negative_binomial_distribution::param
std::negative_binomial_distribution::reset
std::nextafter
std::nextafterf
std::nextafterl
std::nexttoward
std::nexttowardf
std::nexttowardl
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::operator()
std::normal_distribution::param
std::normal_distribution::reset
std::piecewise_constant_distribution
std::piecewise_constant_distribution::intervals
std::piecewise_constant_distribution::max
std::piecewise_constant_distribution::min
std::piecewise_constant_distribution::operator()
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::intervals
std::piecewise_linear_distribution::max
std::piecewise_linear_distribution::min
std::piecewise_linear_distribution::operator()
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::operator()
std::poisson_distribution::param
std::poisson_distribution::poisson_distribution
std::poisson_distribution::reset
std::polar(std::complex)
std::popcount
std::pow
std::pow(std::complex)
std::pow(std::valarray)
std::powf
std::powl
std::proj(std::complex)
std::rand
std::random_device
std::random_device::entropy
std::random_device::max
std::random_device::min
std::random_device::operator()
std::random_device::random_device
std::real(std::complex)
std::remainder
std::remainderf
std::remainderl
std::remquo
std::remquof
std::remquol
std::riemann_zeta
std::riemann_zetaf
std::riemann_zetal
std::rint
std::rintf
std::rintl
std::rotl
std::rotr
std::round
std::roundf
std::roundl
std::scalbln
std::scalblnf
std::scalblnl
std::scalbn
std::scalbnf
std::scalbnl
std::seed_seq
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::operator()
std::shuffle_order_engine::seed
std::shuffle_order_engine::shuffle_order_engine
std::signbit
std::sin
std::sin(std::complex)
std::sin(std::valarray)
std::sinf
std::sinh
std::sinh(std::complex)
std::sinh(std::valarray)
std::sinhf
std::sinhl
std::sinl
std::slice
std::slice_array
std::slice_array::operator=
std::slice_array::operators
std::slice_array::slice_array
std::slice_array::~slice_array
std::sph_bessel
std::sph_besself
std::sph_bessell
std::sph_legendre
std::sph_legendref
std::sph_legendrel
std::sph_neumann
std::sph_neumannf
std::sph_neumannl
std::sqrt
std::sqrt(std::complex)
std::sqrt(std::valarray)
std::sqrtf
std::sqrtl
std::srand
std::student_t_distribution
std::student_t_distribution::max
std::student_t_distribution::min
std::student_t_distribution::n
std::student_t_distribution::operator()
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::operator()
std::subtract_with_carry_engine::seed
std::subtract_with_carry_engine::subtract_with_carry_engine
std::swap(std::valarray)
std::tan
std::tan(std::complex)
std::tan(std::valarray)
std::tanf
std::tanh
std::tanh(std::complex)
std::tanh(std::valarray)
std::tanhf
std::tanhl
std::tanl
std::tgamma
std::tgammaf
std::tgammal
std::trunc
std::truncf
std::truncl
std::uniform_int_distribution
std::uniform_int_distribution::a
std::uniform_int_distribution::max
std::uniform_int_distribution::min
std::uniform_int_distribution::operator()
std::uniform_int_distribution::param
std::uniform_int_distribution::reset
std::uniform_int_distribution::uniform_int_distribution
std::uniform_random_bit_generator
std::uniform_real_distribution
std::uniform_real_distribution::a
std::uniform_real_distribution::max
std::uniform_real_distribution::min
std::uniform_real_distribution::operator()
std::uniform_real_distribution::param
std::uniform_real_distribution::reset
std::uniform_real_distribution::uniform_real_distribution
std::valarray
std::valarray::apply
std::valarray::cshift
std::valarray::max
std::valarray::min
std::valarray::operator=
std::valarray::operator[]
std::valarray::operators
std::valarray::resize
std::valarray::shift
std::valarray::size
std::valarray::sum
std::valarray::swap
std::valarray::valarray
std::valarray::~valarray
std::weibull_distribution
std::weibull_distribution::a
std::weibull_distribution::max
std::weibull_distribution::min
std::weibull_distribution::operator()
std::weibull_distribution::param
std::weibull_distribution::reset
std::weibull_distribution::weibull_distribution
stddev
Ranges
Bound>::iterator
Bound>::sentinel
Copyable wrapper
deduction guides for std::ranges::common_view
deduction guides for std::ranges::drop_view
deduction guides for std::ranges::drop_while_view
deduction guides for std::ranges::join_view
deduction guides for std::ranges::join_with_view
deduction guides for std::ranges::lazy_split_view
deduction guides for std::ranges::split_view
deduction guides for std::ranges::subrange
deduction guides for std::ranges::take_view
deduction guides for std::ranges::take_while_view
deduction guides for std::ranges::transform_view
deduction guides for std::ranges::zip_transform_view
deduction guides for std::ranges::zip_view
iter_move(ranges::join_view::iterator)
iter_move(ranges::join_with_view::iterator)
iter_move(ranges::transform_view::iterator)
iter_swap(ranges::join_view::iterator)
iter_swap(ranges::join_with_view::iterator)
operator-(ranges::elements_view::sentinel)
operator-(ranges::transform_view::sentinel)
operator-(ranges::zip_view::sentinel)
operator==(ranges::elements_view::sentinel)
operator==(ranges::join_with_view::iterator)
operator==(ranges::take_while_view::sentinel)
operator==(ranges::transform_view::sentinel)
operator==(std::ranges::take_view::sentinel)
operators (ranges::elements_view::iterator)
operators (ranges::join_view::iterator)
operators (ranges::join_view::sentinel)
operators (ranges::join_with_view::sentinel)
operators (ranges::transform_view::iterator)
operators (ranges::zip_view::sentinel)
Pattern>::inner_iterator
Pattern>::outer_iterator
Pattern>::outer_iterator::value_type
Ranges library
std::ranges::basic_istream_view
std::ranges::basic_istream_view::iterator
std::ranges::begin
std::ranges::bidirectional_range
std::ranges::borrowed_iterator_t
std::ranges::borrowed_range
std::ranges::borrowed_subrange_t
std::ranges::cbegin
std::ranges::cdata
std::ranges::cend
std::ranges::common_range
std::ranges::common_view
std::ranges::common_view::base
std::ranges::common_view::begin
std::ranges::common_view::common_view
std::ranges::common_view::end
std::ranges::common_view::size
std::ranges::contiguous_range
std::ranges::crbegin
std::ranges::crend
std::ranges::dangling
std::ranges::data
std::ranges::disable_sized_range
std::ranges::drop_view
std::ranges::drop_view::base
std::ranges::drop_view::begin
std::ranges::drop_view::drop_view
std::ranges::drop_view::end
std::ranges::drop_view::size
std::ranges::drop_while_view
std::ranges::drop_while_view::base
std::ranges::drop_while_view::begin
std::ranges::drop_while_view::drop_while_view
std::ranges::drop_while_view::end
std::ranges::drop_while_view::pred
std::ranges::elements_view
std::ranges::elements_view::base
std::ranges::elements_view::begin
std::ranges::elements_view::elements_view
std::ranges::elements_view::end
std::ranges::elements_view::iterator
std::ranges::elements_view::iterator<Const>::base
std::ranges::elements_view::iterator<Const>::iterator
std::ranges::elements_view::iterator<Const>::operator*
std::ranges::elements_view::iterator<Const>::operator[]
std::ranges::elements_view::iterator<Const>::operators
std::ranges::elements_view::sentinel
std::ranges::elements_view::sentinel<Const>::base
std::ranges::elements_view::sentinel<Const>::sentinel
std::ranges::elements_view::size
std::ranges::empty
std::ranges::empty_view
std::ranges::enable_borrowed_range
std::ranges::enable_view
std::ranges::end
std::ranges::filter_view
std::ranges::filter_view::iterator
std::ranges::filter_view::sentinel
std::ranges::forward_range
std::ranges::get(std::ranges::subrange)
std::ranges::input_range
std::ranges::iota_view
std::ranges::iota_view::iterator
std::ranges::iota_view::sentinel
std::ranges::istream_view
std::ranges::iterator_t
std::ranges::join_view
std::ranges::join_view::base
std::ranges::join_view::begin
std::ranges::join_view::end
std::ranges::join_view::iterator
std::ranges::join_view::iterator<Const>::iterator
std::ranges::join_view::iterator<Const>::operators
std::ranges::join_view::iterator<Const>::satisfy
std::ranges::join_view::join_view
std::ranges::join_view::sentinel
std::ranges::join_view::sentinel<Const>::sentinel
std::ranges::join_with_view
std::ranges::join_with_view::base
std::ranges::join_with_view::begin
std::ranges::join_with_view::end
std::ranges::join_with_view::iterator
std::ranges::join_with_view::iterator<Const>::iterator
std::ranges::join_with_view::iterator<Const>::operator*
std::ranges::join_with_view::iterator<Const>::operators
std::ranges::join_with_view::join_with_view
std::ranges::join_with_view::sentinel
std::ranges::join_with_view::sentinel<Const>::sentinel
std::ranges::keys_view
std::ranges::lazy_split_view
std::ranges::lazy_split_view::base
std::ranges::lazy_split_view::begin
std::ranges::lazy_split_view::end
std::ranges::lazy_split_view::inner_iterator
std::ranges::lazy_split_view::lazy_split_view
std::ranges::lazy_split_view::outer_iterator
std::ranges::lazy_split_view::outer_iterator<Const>::value_type
std::ranges::output_range
std::ranges::owning_view
std::ranges::random_access_range
std::ranges::range
std::ranges::range_difference_t
std::ranges::range_reference_t
std::ranges::range_rvalue_reference_t
std::ranges::range_size_t
std::ranges::range_value_t
std::ranges::rbegin
std::ranges::ref_view
std::ranges::rend
std::ranges::reverse_view
std::ranges::sentinel_t
std::ranges::single_view
std::ranges::size
std::ranges::sized_range
std::ranges::split_view
std::ranges::split_view::base
std::ranges::split_view::begin
std::ranges::split_view::end
std::ranges::split_view::find_next
std::ranges::split_view::iterator
std::ranges::split_view::sentinel
std::ranges::split_view::split_view
std::ranges::ssize
std::ranges::subrange
std::ranges::subrange::advance
std::ranges::subrange::begin
std::ranges::subrange::empty
std::ranges::subrange::end
std::ranges::subrange::next
std::ranges::subrange::operator PairLike
std::ranges::subrange::prev
std::ranges::subrange::size
std::ranges::subrange::subrange
std::ranges::subrange_kind
std::ranges::take_view
std::ranges::take_view::base
std::ranges::take_view::begin
std::ranges::take_view::end
std::ranges::take_view::sentinel
std::ranges::take_view::sentinel<Const>::base
std::ranges::take_view::sentinel<Const>::sentinel
std::ranges::take_view::size
std::ranges::take_view::take_view
std::ranges::take_while_view
std::ranges::take_while_view::base
std::ranges::take_while_view::begin
std::ranges::take_while_view::end
std::ranges::take_while_view::pred
std::ranges::take_while_view::sentinel
std::ranges::take_while_view::sentinel<Const>::base
std::ranges::take_while_view::sentinel<Const>::sentinel
std::ranges::take_while_view::take_while_view
std::ranges::transform_view
std::ranges::transform_view::base
std::ranges::transform_view::begin
std::ranges::transform_view::end
std::ranges::transform_view::iterator
std::ranges::transform_view::iterator<Const>::base
std::ranges::transform_view::iterator<Const>::iterator
std::ranges::transform_view::iterator<Const>::operator*
std::ranges::transform_view::iterator<Const>::operator[]
std::ranges::transform_view::iterator<Const>::operators
std::ranges::transform_view::sentinel
std::ranges::transform_view::sentinel<Const>::base
std::ranges::transform_view::sentinel<Const>::sentinel
std::ranges::transform_view::size
std::ranges::transform_view::transform_view
std::ranges::values_view
std::ranges::view
std::ranges::view_base
std::ranges::view_interface
std::ranges::view_interface::back
std::ranges::view_interface::data
std::ranges::view_interface::empty
std::ranges::view_interface::front
std::ranges::view_interface::operator bool
std::ranges::view_interface::operator[]
std::ranges::view_interface::size
std::ranges::viewable_range
std::ranges::views::all
std::ranges::views::all_t
std::ranges::views::common
std::ranges::views::counted
std::ranges::views::drop
std::ranges::views::drop_while
std::ranges::views::elements
std::ranges::views::empty
std::ranges::views::filter
std::ranges::views::iota
std::ranges::views::istream
std::ranges::views::join
std::ranges::views::join_with
std::ranges::views::keys
std::ranges::views::lazy_split
std::ranges::views::reverse
std::ranges::views::single
std::ranges::views::split
std::ranges::views::take
std::ranges::views::take_while
std::ranges::views::transform
std::ranges::views::values
std::ranges::views::zip
std::ranges::views::zip_transform
std::ranges::wistream_view
std::ranges::zip_transform_view
std::ranges::zip_transform_view::begin
std::ranges::zip_transform_view::zip_transform_view
std::ranges::zip_view
std::ranges::zip_view::begin
std::ranges::zip_view::end
std::ranges::zip_view::iterator
std::ranges::zip_view::sentinel
std::ranges::zip_view::sentinel<Const>::sentinel
std::ranges::zip_view::size
std::ranges::zip_view::zip_view
Regular expressions
deduction guides for std::basic_regex
Modified ECMAScript regular expression grammar
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::operator=
std::basic_regex::swap
std::basic_regex::~basic_regex
std::match_results
std::match_results::begin
std::match_results::cbegin
std::match_results::cend
std::match_results::empty
std::match_results::end
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::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::match_results::~match_results
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::operator=
std::regex_error::regex_error
std::regex_iterator
std::regex_iterator::operator=
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::operator=
std::regex_token_iterator::operators (int)
std::regex_token_iterator::operators (operator!=)
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
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)
Standard library headers
algorithm
any
array>
atomic
barrier
bit
bitset
cassert
ccomplex>
cctype
cerrno
cfenv
cfloat
charconv
chrono
cinttypes
ciso646>
climits
clocale
cmath
codecvt
compare
complex
concepts
condition_variable
coroutine
csetjmp
csignal
cstdalign>
cstdarg
cstdbool>
cstddef
cstdint
cstdio
cstdlib
cstring
ctgmath>
ctime
cuchar
cwchar
cwctype
deque
exception
execution
expected
filesystem
format
forward_list
fstream
functional
future
initializer_list
iomanip
ios
iosfwd
iostream
istream
iterator
latch
limits
list
locale
map
memory
memory_resource
mutex
new
numbers
numeric
optional
ostream
queue
random
ranges
ratio
regex
scoped_allocator
semaphore
set
shared_mutex
source_location
span
spanstream
sstream
stack
stacktrace
stdatomic.h
stdexcept
stop_token
streambuf
string
string_view
strstream
syncstream
system_error
thread
tuple
type_traits
typeindex
typeinfo
unordered_map
unordered_set
utility
valarray
variant
vector
version
Strings
deduction guides for std::basic_string
deduction guides for std::basic_string_view
Null-terminated byte strings
Null-terminated multibyte strings
Null-terminated wide strings
operator<<(std::basic_string_view)
operator>(std::basic_string)
operators (std::basic_string)
operators (std::basic_string_view)
std::atof
std::atoi
std::atol
std::atoll
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::c_str
std::basic_string::capacity
std::basic_string::cbegin
std::basic_string::cend
std::basic_string::clear
std::basic_string::compare
std::basic_string::contains
std::basic_string::copy
std::basic_string::crbegin
std::basic_string::crend
std::basic_string::data
std::basic_string::empty
std::basic_string::end
std::basic_string::ends_with
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::operator=
std::basic_string::operator[]
std::basic_string::pop_back
std::basic_string::push_back
std::basic_string::rbegin
std::basic_string::rend
std::basic_string::replace
std::basic_string::reserve
std::basic_string::resize
std::basic_string::resize_and_overwrite
std::basic_string::rfind
std::basic_string::shrink_to_fit
std::basic_string::size
std::basic_string::starts_with
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::cbegin
std::basic_string_view::cend
std::basic_string_view::compare
std::basic_string_view::contains
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::end
std::basic_string_view::ends_with
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::operator[]
std::basic_string_view::rbegin
std::basic_string_view::remove_prefix
std::basic_string_view::remove_suffix
std::basic_string_view::rend
std::basic_string_view::rfind
std::basic_string_view::size
std::basic_string_view::starts_with
std::basic_string_view::substr
std::basic_string_view::swap
std::btowc
std::c16rtomb
std::c32rtomb
std::c8rtomb
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::lt
std::char_traits::move
std::char_traits::not_eof
std::char_traits::to_char_type
std::char_traits::to_int_type
std::getline
std::isalnum
std::isalpha
std::isblank
std::iscntrl
std::isdigit
std::isgraph
std::islower
std::isprint
std::ispunct
std::isspace
std::isupper
std::iswalnum
std::iswalpha
std::iswblank
std::iswcntrl
std::iswctype
std::iswdigit
std::iswgraph
std::iswlower
std::iswprint
std::iswpunct
std::iswspace
std::iswupper
std::iswxdigit
std::isxdigit
std::literals::string_literals::operator""s
std::literals::string_view_literals::operator""sv
std::mblen
std::mbrlen
std::mbrtoc16
std::mbrtoc32
std::mbrtoc8
std::mbrtowc
std::mbsinit
std::mbsrtowcs
std::mbstate_t
std::mbstowcs
std::mbtowc
std::memchr
std::memcmp
std::memcpy
std::memmove
std::memset
std::operator+(std::basic_string)
std::stod
std::stof
std::stoi
std::stol
std::stold
std::stoll
std::stoul
std::stoull
std::strcat
std::strchr
std::strcmp
std::strcoll
std::strcpy
std::strcspn
std::strerror
std::strlen
std::strncat
std::strncmp
std::strncpy
std::strpbrk
std::strrchr
std::strspn
std::strstr
std::strtod
std::strtof
std::strtoimax
std::strtok
std::strtol
std::strtold
std::strtoll
std::strtoul
std::strtoull
std::strtoumax
std::strxfrm
std::swap(std::basic_string)
std::to_string
std::to_wstring
std::tolower
std::toupper
std::towctrans
std::towlower
std::towupper
std::wcrtomb
std::wcscat
std::wcschr
std::wcscmp
std::wcscoll
std::wcscpy
std::wcscspn
std::wcslen
std::wcsncat
std::wcsncmp
std::wcsncpy
std::wcspbrk
std::wcsrchr
std::wcsrtombs
std::wcsspn
std::wcsstr
std::wcstod
std::wcstof
std::wcstoimax
std::wcstok
std::wcstol
std::wcstold
std::wcstoll
std::wcstombs
std::wcstoul
std::wcstoull
std::wcstoumax
std::wcsxfrm
std::wctob
std::wctomb
std::wctrans
std::wctype
std::wmemchr
std::wmemcmp
std::wmemcpy
std::wmemmove
std::wmemset
Strings library
Symbol index
Macro Symbol Index
std Symbol Index
std::chrono Symbol Index
std::execution Symbol Index
std::filesystem Symbol Index
std::literals Symbol Index
std::literals::chrono_literals Symbol Index
std::literals::complex_literals Symbol Index
std::literals::string_literals Symbol Index
std::literals::string_view_literals Symbol Index
std::numbers Symbol Index
std::placeholders Symbol Index
std::pmr Symbol Index
std::ranges Symbol Index
std::ranges::views Symbol Index
std::regex_constants Symbol Index
std::rel_ops Symbol Index
std::this_thread Symbol Index
Symbol Index
Utilities
C Date and time utilities
C memory management library
C numeric limits interface
CLOCKS_PER_SEC
cmp_greater
cmp_greater_equal
cmp_less
cmp_less_equal
cmp_not_equal
Coroutine support
Date and time utilities
Deduction guides for std::chrono::zoned_time
deduction guides for std::function
deduction guides for std::optional
deduction guides for std::pair
deduction guides for std::reference_wrapper
deduction guides for std::shared_ptr
deduction guides for std::tuple
deduction guides for std::weak_ptr
Dynamic memory management
EXIT_FAILURE
EXIT_SUCCESS
Fixed width integer types
FLT_EVAL_METHOD
FLT_ROUNDS
Formatting library
Freestanding and hosted implementations
Function objects
Library feature-test macros
Low level memory management
no-throw-forward-iterator
no-throw-forward-range
no-throw-input-iterator
no-throw-input-range
no-throw-sentinel-for
NULL
offsetof
operator==(std::move_only_function)
operator>(std::bitset)
operators (<=>)
operators (delete[])
operators (new[])
operators (std::bitset)
operators (std::chrono::duration)
operators (std::chrono::time_point)
operators (std::error_condition)
operators (std::function)
operators (std::optional)
operators (std::pair)
operators (std::tuple)
operators (std::unique_ptr)
operators (std::variant)
Program support utilities
setjmp
SIG_DFL
SIG_ERR
SIG_IGN
SIGABRT
SIGFPE
SIGILL
SIGINT
SIGSEGV
SIGTERM
std::_Exit
std::abort
std::addressof
std::align
std::align_val_t
std::aligned_alloc
std::allocate_at_least
std::allocate_shared
std::allocate_shared_for_overwrite
std::allocation_result
std::allocator_arg
std::any
std::any::any
std::any::emplace
std::any::has_value
std::any::operator=
std::any::reset
std::any::swap
std::any::type
std::any::~any
std::any_cast
std::apply
std::as_const
std::asctime
std::assume_aligned
std::at_quick_exit
std::atexit
std::atomic(std::weak_ptr)
std::atomic_...
std::auto_ptr
std::auto_ptr::auto_ptr
std::auto_ptr::get
std::auto_ptr::operator auto_ptr<Y>
std::auto_ptr::operator->
std::auto_ptr::operator=
std::auto_ptr::operators
std::auto_ptr::release
std::auto_ptr::reset
std::auto_ptr::~auto_ptr
std::bad_alloc
std::bad_any_cast
std::bad_array_new_length
std::bad_cast
std::bad_exception
std::bad_exception::bad_exception
std::bad_exception::operator=
std::bad_exception::what
std::bad_function_call
std::bad_optional_access
std::bad_typeid
std::bad_variant_access
std::bad_weak_ptr
std::basic_common_reference
std::basic_format_arg
std::basic_format_args
std::basic_format_context
std::basic_format_parse_context
std::begin(std::initializer_list)
std::binary_function
std::binary_negate
std::bind
std::bind1st
std::bind2nd
std::bind_back
std::bind_front
std::binder1st
std::binder2nd
std::bit_and
std::bit_not
std::bit_or
std::bit_xor
std::bitset
std::bitset::all
std::bitset::any
std::bitset::bitset
std::bitset::count
std::bitset::flip
std::bitset::none
std::bitset::operator!=
std::bitset::operator[]
std::bitset::operators
std::bitset::operators
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::boyer_moore_horspool_searcher
std::boyer_moore_searcher
std::byte
std::calloc
std::chars_format
std::chrono::abs(std::chrono::duration)
std::chrono::ambiguous_local_time
std::chrono::ceil(std::chrono::duration)
std::chrono::ceil(std::chrono::time_point)
std::chrono::choose
std::chrono::clock_cast
std::chrono::clock_time_conversion
std::chrono::current_zone
std::chrono::day
std::chrono::day::day
std::chrono::day::ok
std::chrono::day::operator unsigned
std::chrono::day::operator-=
std::chrono::day::operators
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::operator=
std::chrono::duration::operators
std::chrono::duration::operators (%=)
std::chrono::duration::operators (unary)
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::file_clock
std::chrono::file_clock::from_sys
std::chrono::file_clock::from_utc
std::chrono::file_clock::now
std::chrono::file_clock::to_sys
std::chrono::file_clock::to_utc
std::chrono::floor(std::chrono::duration)
std::chrono::floor(std::chrono::time_point)
std::chrono::from_stream
std::chrono::get_leap_second_info
std::chrono::get_tzdb
std::chrono::get_tzdb_list
std::chrono::gps_clock
std::chrono::gps_clock::from_utc
std::chrono::gps_clock::now
std::chrono::gps_clock::to_utc
std::chrono::hh_mm_ss
std::chrono::hh_mm_ss::hh_mm_ss
std::chrono::hh_mm_ss::hours
std::chrono::hh_mm_ss::is_negative
std::chrono::hh_mm_ss::minutes
std::chrono::hh_mm_ss::operators
std::chrono::hh_mm_ss::seconds
std::chrono::hh_mm_ss::subseconds
std::chrono::hh_mm_ss::to_duration
std::chrono::high_resolution_clock
std::chrono::high_resolution_clock::now
std::chrono::is_am
std::chrono::is_clock
std::chrono::is_pm
std::chrono::last
std::chrono::last_spec
std::chrono::leap_second
std::chrono::leap_second::date
std::chrono::leap_second_info
std::chrono::local_info
std::chrono::local_t
std::chrono::locate_zone
std::chrono::make12
std::chrono::make24
std::chrono::month
std::chrono::month::month
std::chrono::month::ok
std::chrono::month::operator unsigned
std::chrono::month::operator--
std::chrono::month::operators
std::chrono::month_day
std::chrono::month_day::day
std::chrono::month_day::month
std::chrono::month_day::month_day
std::chrono::month_day::ok
std::chrono::month_day_last
std::chrono::month_day_last::month
std::chrono::month_day_last::month_day_last
std::chrono::month_day_last::ok
std::chrono::month_weekday
std::chrono::month_weekday::month
std::chrono::month_weekday::month_weekday
std::chrono::month_weekday::ok
std::chrono::month_weekday::weekday_indexed
std::chrono::month_weekday_last
std::chrono::month_weekday_last::month
std::chrono::month_weekday_last::month_weekday_last
std::chrono::month_weekday_last::ok
std::chrono::month_weekday_last::weekday_last
std::chrono::nonexistent_local_time
std::chrono::operator-
std::chrono::operator/
std::chrono::operator<<
std::chrono::operator<<(std::chrono::day)
std::chrono::operator<<(std::chrono::file_time)
std::chrono::operator<<(std::chrono::gps_time)
std::chrono::operator<<(std::chrono::hh_mm_ss)
std::chrono::operator<<(std::chrono::local_time)
std::chrono::operator<<(std::chrono::month)
std::chrono::operator<<(std::chrono::month_day)
std::chrono::operator<<(std::chrono::month_day_last)
std::chrono::operator<<(std::chrono::month_weekday)
std::chrono::operator<<(std::chrono::month_weekday_last)
std::chrono::operator<<(std::chrono::sys_time)
std::chrono::operator<<(std::chrono::tai_time)
std::chrono::operator<<(std::chrono::utc_time)
std::chrono::operator<<(std::chrono::weekday)
std::chrono::operator<<(std::chrono::weekday_indexed)
std::chrono::operator<<(std::chrono::weekday_last)
std::chrono::operator<<(std::chrono::year)
std::chrono::operator<<(std::chrono::year_month)
std::chrono::operator<<(std::chrono::year_month_day)
std::chrono::operator<<(std::chrono::year_month_day_last)
std::chrono::operator<<(std::chrono::year_month_weekday)
std::chrono::operator<<(std::chrono::year_month_weekday_last)
std::chrono::operator<<(std::chrono::zoned_time)
std::chrono::operator==(std::chrono::month_weekday)
std::chrono::operator==(std::chrono::month_weekday_last)
std::chrono::operator==(std::chrono::weekday)
std::chrono::operator==(std::chrono::weekday_indexed)
std::chrono::operator==(std::chrono::weekday_last)
std::chrono::operator==(std::chrono::year_month_weekday)
std::chrono::operator==(std::chrono::year_month_weekday_last)
std::chrono::operator==(std::chrono::zoned_time)
std::chrono::operators
std::chrono::operators (std::chrono::day)
std::chrono::operators (std::chrono::leap_second)
std::chrono::operators (std::chrono::month)
std::chrono::operators (std::chrono::month_day)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::time_zone)
std::chrono::operators (std::chrono::year)
std::chrono::operators (std::chrono::year_month)
std::chrono::parse
std::chrono::reload_tzdb
std::chrono::remote_version
std::chrono::round(std::chrono::duration)
std::chrono::round(std::chrono::time_point)
std::chrono::steady_clock
std::chrono::steady_clock::now
std::chrono::sys_info
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::tai_clock
std::chrono::tai_clock::from_utc
std::chrono::tai_clock::now
std::chrono::tai_clock::to_utc
std::chrono::time_point
std::chrono::time_point::max
std::chrono::time_point::min
std::chrono::time_point::operator--
std::chrono::time_point::operators
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::time_zone
std::chrono::time_zone::get_info
std::chrono::time_zone::name
std::chrono::time_zone::to_local
std::chrono::time_zone::to_sys
std::chrono::time_zone_link
std::chrono::time_zone_link::name
std::chrono::time_zone_link::target
std::chrono::treat_as_floating_point
std::chrono::tzdb
std::chrono::tzdb::current_zone
std::chrono::tzdb::locate_zone
std::chrono::tzdb_list
std::chrono::tzdb_list::begin
std::chrono::tzdb_list::cend
std::chrono::tzdb_list::end
std::chrono::tzdb_list::erase_after
std::chrono::tzdb_list::front
std::chrono::utc_clock
std::chrono::utc_clock::from_sys
std::chrono::utc_clock::now
std::chrono::utc_clock::to_sys
std::chrono::weekday
std::chrono::weekday::c_encoding
std::chrono::weekday::iso_encoding
std::chrono::weekday::ok
std::chrono::weekday::operator--
std::chrono::weekday::operator[]
std::chrono::weekday::operators
std::chrono::weekday::weekday
std::chrono::weekday_indexed
std::chrono::weekday_indexed::index
std::chrono::weekday_indexed::ok
std::chrono::weekday_indexed::weekday
std::chrono::weekday_indexed::weekday_indexed
std::chrono::weekday_last
std::chrono::weekday_last::ok
std::chrono::weekday_last::weekday
std::chrono::weekday_last::weekday_last
std::chrono::year
std::chrono::year::is_leap
std::chrono::year::max
std::chrono::year::min
std::chrono::year::ok
std::chrono::year::operator int
std::chrono::year::operator-
std::chrono::year::operators
std::chrono::year::year
std::chrono::year_month
std::chrono::year_month::month
std::chrono::year_month::ok
std::chrono::year_month::operator-=
std::chrono::year_month::operators
std::chrono::year_month::year
std::chrono::year_month::year_month
std::chrono::year_month_day
std::chrono::year_month_day::day
std::chrono::year_month_day::month
std::chrono::year_month_day::ok
std::chrono::year_month_day::operator-=
std::chrono::year_month_day::operators
std::chrono::year_month_day::year
std::chrono::year_month_day::year_month_day
std::chrono::year_month_day_last
std::chrono::year_month_day_last::day
std::chrono::year_month_day_last::month
std::chrono::year_month_day_last::month_day_last
std::chrono::year_month_day_last::ok
std::chrono::year_month_day_last::operator local_days
std::chrono::year_month_day_last::operators
std::chrono::year_month_day_last::year
std::chrono::year_month_day_last::year_month_day_last
std::chrono::year_month_weekday
std::chrono::year_month_weekday::index
std::chrono::year_month_weekday::month
std::chrono::year_month_weekday::ok
std::chrono::year_month_weekday::operator-=
std::chrono::year_month_weekday::operators
std::chrono::year_month_weekday::weekday
std::chrono::year_month_weekday::weekday_indexed
std::chrono::year_month_weekday::year
std::chrono::year_month_weekday::year_month_weekday
std::chrono::year_month_weekday_last
std::chrono::year_month_weekday_last::month
std::chrono::year_month_weekday_last::ok
std::chrono::year_month_weekday_last::operator local_days
std::chrono::year_month_weekday_last::operators
std::chrono::year_month_weekday_last::weekday
std::chrono::year_month_weekday_last::weekday_last
std::chrono::year_month_weekday_last::year
std::chrono::year_month_weekday_last::year_month_weekday_last
std::chrono::zoned_time
std::chrono::zoned_time::get_info
std::chrono::zoned_time::get_sys_time
std::chrono::zoned_time::get_time_zone
std::chrono::zoned_time::operator=
std::chrono::zoned_time::operators
std::chrono::zoned_time::zoned_time
std::chrono::zoned_traits
std::clock
std::clock_t
std::cmp_equal
std::common_comparison_category
std::common_type(std::chrono::duration)
std::common_type(std::chrono::time_point)
std::compare_partial_order_fallback
std::compare_strong_order_fallback
std::compare_three_way
std::compare_three_way_result
std::compare_weak_order_fallback
std::const_mem_fun1_ref_t
std::const_mem_fun1_t
std::const_mem_fun_ref_t
std::const_mem_fun_t
std::const_pointer_cast
std::construct_at
std::coroutine_handle
std::coroutine_handle::address
std::coroutine_handle::coroutine_handle
std::coroutine_handle::destroy
std::coroutine_handle::done
std::coroutine_handle::from_address
std::coroutine_handle::from_promise
std::coroutine_handle::operator bool
std::coroutine_handle::operator coroutine_handle<>
std::coroutine_handle::operator=
std::coroutine_handle::operators
std::coroutine_handle::promise
std::coroutine_handle::resume
std::coroutine_traits
std::cref
std::ctime
std::declare_no_pointers
std::declare_reachable
std::declval
std::default_delete
std::default_searcher
std::destroy
std::destroy_at
std::destroy_n
std::destroying_delete
std::destroying_delete_t
std::difftime
std::divides
std::dynamic_pointer_cast
std::enable_shared_from_this
std::enable_shared_from_this::enable_shared_from_this
std::enable_shared_from_this::operator=
std::enable_shared_from_this::shared_from_this
std::enable_shared_from_this::weak_from_this
std::enable_shared_from_this::~enable_shared_from_this
std::end(std::initializer_list)
std::equal_to
std::errc
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_category::~error_category
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::operator=
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::operator=
std::error_condition::value
std::exception
std::exception::exception
std::exception::operator=
std::exception::what
std::exception::~exception
std::exchange
std::exit
std::float_denorm_style
std::float_round_style
std::format
std::format_error
std::format_to
std::format_to_n
std::formatted_size
std::formatter
std::forward
std::forward_as_tuple
std::free
std::from_chars
std::from_chars_result
std::function
std::function::assign
std::function::function
std::function::operator bool
std::function::operator()
std::function::operator=
std::function::swap
std::function::target
std::function::target_type
std::function::~function
std::get
std::get(std::pair)
std::get(std::tuple)
std::get_deleter
std::get_if
std::get_new_handler
std::get_pointer_safety
std::get_temporary_buffer
std::getenv
std::gmtime
std::greater
std::greater_equal
std::hash
std::hash(std::bitset)
std::hash(std::coroutine_handle)
std::hash(std::shared_ptr)
std::hash::hash
std::hash::operator()
std::holds_alternative
std::identity
std::ignore
std::in_place
std::in_place_index
std::in_place_index_t
std::in_place_t
std::in_place_type
std::in_place_type_t
std::in_range
std::initializer_list
std::initializer_list::begin
std::initializer_list::end
std::initializer_list::initializer_list
std::initializer_list::size
std::inout_ptr
std::inout_ptr_t
std::inout_ptr_t::inout_ptr_t
std::inout_ptr_t::operator void**
std::inout_ptr_t::operators (void**)
std::inout_ptr_t::~inout_ptr_t
std::invoke
std::invoke_r
std::is_bind_expression
std::is_constant_evaluated
std::is_eq
std::is_error_code_enum
std::is_error_condition_enum
std::is_gt
std::is_gteq
std::is_lt
std::is_lteq
std::is_neq
std::is_placeholder
std::jmp_buf
std::launder
std::less
std::less_equal
std::literals::chrono_literals::operator""d
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::literals::chrono_literals::operator""y
std::localtime
std::logical_and
std::logical_not
std::logical_or
std::longjmp
std::make_any
std::make_error_code(std::errc)
std::make_error_condition(std::errc)
std::make_format_args
std::make_from_tuple
std::make_obj_using_allocator
std::make_optional
std::make_pair
std::make_shared
std::make_shared_for_overwrite
std::make_tuple
std::make_unique
std::make_unique_for_overwrite
std::make_wformat_args
std::malloc
std::max_align_t
std::mem_fn
std::mem_fun
std::mem_fun1_ref_t
std::mem_fun1_t
std::mem_fun_ref
std::mem_fun_ref_t
std::mem_fun_t
std::minus
std::mktime
std::modulus
std::monostate
std::move
std::move_if_noexcept
std::move_only_function
std::move_only_function::move_only_function
std::move_only_function::operator bool
std::move_only_function::operator()
std::move_only_function::operator=
std::move_only_function::swap
std::move_only_function::~move_only_function
std::multiplies
std::negate
std::nested_exception::nested_exception
std::nested_exception::nested_ptr
std::nested_exception::operator=
std::nested_exception::rethrow_nested
std::nested_exception::~nested_exception
std::new_handler
std::noop_coroutine
std::noop_coroutine_handle
std::noop_coroutine_promise
std::not1
std::not2
std::not_equal_to
std::not_fn
std::nothrow
std::nullopt
std::nullopt_t
std::nullptr_t
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::coroutine_handle)
std::operators (std::error_code)
std::optional
std::optional::and_then
std::optional::emplace
std::optional::operator*
std::optional::operator=
std::optional::operators
std::optional::optional
std::optional::or_else
std::optional::reset
std::optional::swap
std::optional::transform
std::optional::value
std::optional::value_or
std::optional::~optional
std::out_ptr
std::out_ptr_t
std::out_ptr_t::operator void**
std::out_ptr_t::operators (void**)
std::out_ptr_t::out_ptr_t
std::out_ptr_t::~out_ptr_t
std::owner_less
std::pair
std::pair::operator=
std::pair::pair
std::pair::swap
std::partial_order
std::partial_ordering
std::piecewise_construct
std::placeholders::_1
std::placeholders::_2
std::placeholders::_N
std::plus
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::ptr_fun
std::ptrdiff_t
std::quick_exit
std::raise
std::ranges::construct_at
std::ranges::destroy
std::ranges::destroy_at
std::ranges::destroy_n
std::ranges::equal_to
std::ranges::greater
std::ranges::greater_equal
std::ranges::less
std::ranges::less_equal
std::ranges::not_equal_to
std::ranges::swap
std::ranges::uninitialized_copy
std::ranges::uninitialized_copy_n
std::ranges::uninitialized_copy_n_result
std::ranges::uninitialized_copy_result
std::ranges::uninitialized_default_construct
std::ranges::uninitialized_default_construct_n
std::ranges::uninitialized_fill
std::ranges::uninitialized_fill_n
std::ranges::uninitialized_move
std::ranges::uninitialized_move_n
std::ranges::uninitialized_move_n_result
std::ranges::uninitialized_move_result
std::ranges::uninitialized_value_construct
std::ranges::uninitialized_value_construct_n
std::realloc
std::ref
std::reference_wrapper
std::reference_wrapper::get
std::reference_wrapper::operator T&
std::reference_wrapper::operator()
std::reference_wrapper::operator=
std::reference_wrapper::reference_wrapper
std::reinterpret_pointer_cast
std::rel_ops::operators
std::return_temporary_buffer
std::set_new_handler
std::shared_ptr
std::shared_ptr::get
std::shared_ptr::operator bool
std::shared_ptr::operator->
std::shared_ptr::operator<<
std::shared_ptr::operator=
std::shared_ptr::operator[]
std::shared_ptr::operators
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::shared_ptr::~shared_ptr
std::sig_atomic_t
std::signal
std::size_t
std::source_location
std::source_location::column
std::source_location::current
std::source_location::file_name
std::source_location::function_name
std::source_location::line
std::source_location::source_location
std::static_pointer_cast
std::strftime
std::strong_order
std::strong_ordering
std::suspend_always
std::suspend_never
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
std::system_error
std::system_error::code
std::system_error::operator=
std::system_error::system_error
std::system_error::what
std::three_way_comparable
std::three_way_comparable_with
std::tie
std::time
std::time_t
std::timespec
std::timespec_get
std::tm
std::to_address
std::to_chars
std::to_chars_result
std::to_underlying
std::tuple
std::tuple::operator=
std::tuple::swap
std::tuple::tuple
std::tuple_cat
std::tuple_element
std::tuple_size
std::type_index
std::type_index::hash_code
std::type_index::name
std::type_index::operators
std::type_index::type_index
std::type_info
std::type_info::before
std::type_info::hash_code
std::type_info::name
std::type_info::operator!=
std::type_info::operators
std::type_info::~type_info
std::unary_function
std::unary_negate
std::undeclare_no_pointers
std::undeclare_reachable
std::uninitialized_construct_using_allocator
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::operator=
std::unique_ptr::operator[]
std::unique_ptr::operators
std::unique_ptr::release
std::unique_ptr::reset
std::unique_ptr::swap
std::unique_ptr::unique_ptr
std::unique_ptr::~unique_ptr
std::unreachable
std::unwrap_ref_decay
std::unwrap_reference
std::uses_allocator
std::uses_allocator_construction_args
std::va_list
std::variant
std::variant::emplace
std::variant::index
std::variant::operator=
std::variant::swap
std::variant::valueless_by_exception
std::variant::variant
std::variant::~variant
std::variant_alternative
std::variant_alternative_t
std::variant_npos
std::variant_size
std::variant_size_v
std::vformat
std::vformat_to
std::visit
std::visit_format_arg
std::wcsftime
std::weak_order
std::weak_ordering
std::weak_ptr
std::weak_ptr::expired
std::weak_ptr::lock
std::weak_ptr::operator=
std::weak_ptr::owner_before
std::weak_ptr::reset
std::weak_ptr::swap
std::weak_ptr::use_count
std::weak_ptr::weak_ptr
std::weak_ptr::~weak_ptr
swap(std::move_only_function)
Type support
Utility library
va_arg
va_copy
va_end
va_start
Variadic functions
Versions
C++11
C++14
C++17
C++20
C++23
Current Status
中文
English
A
A
Serif
Sans
White
Sepia
Night
首页
API Docs
工具
首页
API Docs
工具
cpp
/
latest
/
ranges
/
join_view
/
iterator
/
Files
File Name
iter_move.html
iter_swap.html
iterator.html
operator_.html
operator_cmp.html
satisfy.html
Name
C++
Version
latest
Badge
Last Updated
2022-06-02T22:02:33Z