A platform combines multiple tutorials, projects, documentations, questions and answers for developers
  • Home (current)
  • Documentations
  • About
  • Login
  1. Home
  2. Documentations
  3. C++
  4. or

C++ keywords: or

Usage

  • alternative operators: as an alternative for ||

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/keyword/or

Language
#define directive
#error directive
#include directive
#line directive
#pragma directive
ASCII Chart
Acronyms
Address of an overloaded function
Alternative operator representations
Argument-dependent lookup
Arithmetic operators
Array declaration
Assignment operators
Basic concepts
Bit field
Boolean literals
C++ language
Class declaration
Class template
Class template argument deduction(since C++17)
Classes
Comments
Comparison operators
Conditional inclusion
Constant expressions
Constraints and concepts
Constructors and member initializer lists
Converting constructor
Copy assignment operator
Copy constructors
Copy elision
Coroutines
Declarations
Default arguments
Default comparisons(since C++20)
Default constructors
Definitions and ODR
Dependent names
Derived classes
Destructors
Dynamic exception specification
Elaborated type specifier
Empty base optimization
Enumeration declaration
Escape sequences
Exceptions
Explicit type conversion
Expressions
Function declaration
Function template
Function-try-block
Functions
Fundamental types
Identifiers
Implicit conversions
Increment/decrement operators
Initialization
Lambda expressions
Language linkage
Lifetime
Logical operators
Main function
Member access operators
Member templates
Memory model
Modules
Move assignment operator
Move constructors
Name lookup
Namespace aliases
Namespaces
Non-static data members
Non-static member functions
Object
Operator Precedence
Order of evaluation
Other operators
Overload resolution
PImpl
Parameter pack(since C++11)
Phases of translation
Pointer declaration
Preprocessor
Qualified name lookup
RAII
Range-based for loop
Reference declaration
Reference initialization
SFINAE
Scope
Statements
Static Assertion
Storage class specifiers
Structured binding declaration
Template argument deduction
Template parameters and template arguments
Templates
The as-if rule
The rule of three/five/zero
Transactional memory
Type
Type
Type alias
Undefined behavior
Union declaration
Unqualified name lookup
User-defined literals
Using-declaration
Value categories
Variable template(since C++14)
Variadic arguments
abstract class
access specifiers
aggregate initialization
Standard library headers
algorithm
alias template
alignas specifier
alignof operator
any
array
asm declaration
assert
atomic
attribute specifier sequence(since C++11)
attribute: carries_dependency
attribute: deprecated
attribute: expects
attribute: fallthrough
attribute: likely
attribute: maybe_unused
attribute: no_unique_address
attribute: nodiscard
attribute: noreturn
attribute: optimize_for_synchronized
bit
bitset
break statement
cassert
ccomplex
cctype
cerrno
cfenv
cfloat
character literal
charconv
chrono
cinttypes
ciso646
climits
clocale
cmath
codecvt
compare
complex
concepts
condition_variable
const_cast conversion
constant initialization
consteval specifier
constexpr specifier
continue statement
contract
copy initialization
csetjmp
csignal
cstdalign
cstdarg
cstdbool
cstddef
cstdint
cstdio
cstdlib
cstring
ctgmath
ctime
cuchar
cv type qualifiers
cwchar
cwctype
decltype specifier
default initialization
delete expression
deque
direct initialization
do-while loop
dynamic_cast conversion
ensures
exception
execution
explicit specifier
explicit template specialization
filesystem
final specifier
floating point literal
fold expression(since C++17)
for loop
forward_list
friend declaration
fstream
functional
future
goto statement
if statement
initializer_list
injected-class-name
inline specifier
integer literal
iomanip
ios
iosfwd
iostream
istream
iterator
limits
list
list initialization
locale
map
memory
memory_resource
mutex
nested classes
new
new expression
noexcept operator
noexcept specifier
nullptr
numeric
operator overloading
optional
ostream
override specifier
partial template specialization
placeholder type specifiers
queue
random
ranges
ratio
regex
reinterpret_cast conversion
return statement
scoped_allocator
set
shared_mutex
sizeof operator
sizeof... operator
span
sstream
stack
static members
static_cast conversion
stdexcept
streambuf
string
string literal
string_view
strstream
switch statement
syncstream
system_error
the pointer literal
this pointer
thread
throw expression
try-block
tuple
type_traits
typedef specifier
typeid operator
typeindex
typeinfo
unlikely
unordered_map
unordered_set
user-defined conversion
utility
valarray
value initialization(since C++03)
variant
vector
version
virtual function specifier
while loop
zero initialization
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::compare_3way
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_3way
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
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::all_of
std::ranges::any_of
std::ranges::none_of
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
Keywords
alignas
alignof
and
and_eq
asm
audit
auto
axiom
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
continue
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
final
float
for
friend
goto
if
inline
int
keywords
long
mutable
namespace
new
noexcept
not
not_eq
nullptr
operator
or
or_eq
override
private
protected
public
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
Utilities
C Date and time utilities
C memory management library
C numeric limits interface
CLOCKS_PER_SEC
Date and time utilities
Deduction guides for std::chrono::zoned_time
Dynamic memory management
EXIT_FAILURE
EXIT_SUCCESS
Error handling
Error numbers
FLT_EVAL_METHOD
FLT_ROUNDS
Fixed width integer types
Freestanding and hosted implementations
Function objects
Library feature-test macros
Low level memory management
NULL
Program support utilities
SIGABRT
SIGFPE
SIGILL
SIGINT
SIGSEGV
SIGTERM
SIG_DFL
SIG_ERR
SIG_IGN
Type support
Utility library
Variadic functions
assert
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
errno
offsetof
operator>(std::bitset)
operators (delete[])
operators (new[])
operators (std::bitset)
operators (std::bitset)
operators (std::chrono::duration)
operators (std::chrono::duration)
operators (std::error_condition)
operators (std::function)
operators (std::optional)
operators (std::pair)
operators (std::time_point)
operators (std::time_point)
operators (std::tuple)
operators (std::unique_ptr)
operators (std::variant)
setjmp
std::_Exit
std::abort
std::add_const
std::add_cv
std::add_lvalue_reference
std::add_pointer
std::add_rvalue_reference
std::add_volatile
std::addressof
std::align
std::align_val_t
std::aligned_alloc
std::aligned_storage
std::aligned_union
std::alignment_of
std::allocate_shared
std::allocate_shared_default_init
std::allocator_arg
std::allocator_arg_t
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::shared_ptr)
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
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_array_new_length::bad_array_new_length
std::bad_cast
std::bad_cast::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_typeid::bad_typeid
std::bad_variant_access
std::bad_weak_ptr
std::begin(std::initializer_list)
std::binary_function
std::binary_negate
std::bind
std::bind1st
std::bind2nd
std::bind_front
std::binder1st
std::binder2nd
std::bit_and
std::bit_and
std::bit_not
std::bit_not
std::bit_or
std::bit_or
std::bit_xor
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::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::operator-=
std::chrono::day::operators
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::format
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
std::chrono::from_stream
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::high_resolution_clock
std::chrono::high_resolution_clock::now
std::chrono::is_clock
std::chrono::last_spec
std::chrono::leap
std::chrono::leap::date
std::chrono::link
std::chrono::link::name
std::chrono::link::target
std::chrono::local_info
std::chrono::local_t
std::chrono::locate_zone
std::chrono::month
std::chrono::month::month
std::chrono::month::ok
std::chrono::month::operator unsigned
std::chrono::month::operator--
std::chrono::month::operator-=
std::chrono::month::operators
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::operator-
std::chrono::operator-
std::chrono::operator-
std::chrono::operator-
std::chrono::operator-
std::chrono::operator/
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operator<<
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
std::chrono::operators (std::chrono::operator-)
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_of_day
std::chrono::time_of_day::hours
std::chrono::time_of_day::make12
std::chrono::time_of_day::make24
std::chrono::time_of_day::minutes
std::chrono::time_of_day::operators
std::chrono::time_of_day::seconds
std::chrono::time_of_day::subseconds
std::chrono::time_of_day::time_of_day
std::chrono::time_of_day::to_duration
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::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
std::chrono::to_stream
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::ok
std::chrono::weekday::operator unsigned
std::chrono::weekday::operator--
std::chrono::weekday::operator-=
std::chrono::weekday::operator[]
std::chrono::weekday::operators
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::operator--
std::chrono::year::operator-=
std::chrono::year::operators
std::chrono::year::operators
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 local_days
std::chrono::year_month_day::operator-=
std::chrono::year_month_day::operators
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::operator-=
std::chrono::year_month_day_last::operators
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 local_days
std::chrono::year_month_weekday::operator-=
std::chrono::year_month_weekday::operators
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::operator-=
std::chrono::year_month_weekday_last::operators
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_local_time
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::operators
std::chrono::zoned_time::zoned_time
std::chrono::zoned_traits
std::clock
std::clock_t
std::common_comparison_category
std::common_reference
std::common_type
std::common_type(std::chrono::duration)
std::common_type(std::chrono::time_point)
std::conditional
std::conjunction
std::const_mem_fun1_ref_t
std::const_mem_fun1_t
std::const_mem_fun_ref_t
std::const_mem_fun_t
std::const_pointer_cast
std::contract_violation
std::cref
std::ctime
std::current_exception
std::decay
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::disjunction
std::divides
std::divides
std::domain_error
std::dynamic_pointer_cast
std::enable_if
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::endian
std::equal_to
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::exception_ptr
std::exchange
std::exit
std::extent
std::float_denorm_style
std::float_round_style
std::forward
std::forward_as_tuple
std::free
std::from_chars
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::generic_category
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::get_terminate
std::get_unexpected
std::getenv
std::gmtime
std::greater
std::greater
std::greater_equal
std::greater_equal
std::has_unique_object_representations
std::has_virtual_destructor
std::hash
std::hash
std::hash
std::hash
std::hash
std::hash
std::hash
std::hash
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::initializer_list
std::initializer_list::begin
std::initializer_list::end
std::initializer_list::initializer_list
std::initializer_list::size
std::integer_sequence
std::integral_constant
std::invalid_argument
std::invoke
std::invoke_result
std::is_abstract
std::is_aggregate
std::is_arithmetic
std::is_array
std::is_assignable
std::is_base_of
std::is_bind_expression
std::is_bounded_array
std::is_class
std::is_compound
std::is_const
std::is_constant_evaluated
std::is_constructible
std::is_convertible
std::is_copy_assignable
std::is_copy_constructible
std::is_default_constructible
std::is_destructible
std::is_empty
std::is_enum
std::is_eq
std::is_error_code_enum
std::is_error_code_enum
std::is_error_condition_enum
std::is_error_condition_enum
std::is_final
std::is_floating_point
std::is_function
std::is_fundamental
std::is_gt
std::is_gteq
std::is_integral
std::is_invocable
std::is_invocable_r
std::is_literal_type
std::is_lt
std::is_lteq
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_neq
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_placeholder
std::is_pod
std::is_pointer
std::is_polymorphic
std::is_reference
std::is_rvalue_reference
std::is_same
std::is_scalar
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::jmp_buf
std::launder
std::length_error
std::less
std::less
std::less_equal
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::logic_error
std::logical_and
std::logical_and
std::logical_not
std::logical_not
std::logical_or
std::logical_or
std::longjmp
std::make_any
std::make_error_code(std::errc)
std::make_error_condition(std::errc)
std::make_exception_ptr
std::make_from_tuple
std::make_obj_using_allocator
std::make_optional
std::make_pair
std::make_shared
std::make_shared_default_init
std::make_signed
std::make_tuple
std::make_unique
std::make_unique_default_init
std::make_unsigned
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::minus
std::mktime
std::modulus
std::modulus
std::monostate
std::move
std::move_if_noexcept
std::multiplies
std::multiplies
std::negate
std::negate
std::negation
std::nested_exception
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::not1
std::not2
std::not_equal_to
std::not_equal_to
std::not_fn
std::nothrow
std::nothrow_t
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::error_code)
std::optional
std::optional::emplace
std::optional::has_value
std::optional::operator*
std::optional::operator=
std::optional::operators
std::optional::operators
std::optional::optional
std::optional::reset
std::optional::swap
std::optional::value
std::optional::value_or
std::optional::~optional
std::out_of_range
std::overflow_error
std::owner_less
std::owner_less
std::pair
std::pair::operator=
std::pair::pair
std::pair::swap
std::partial_order
std::partial_ordering
std::piecewise_construct
std::piecewise_construct_t
std::placeholders::_1
std::placeholders::_2
std::placeholders::_N
std::plus
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::pointer_traits
std::ptr_fun
std::ptrdiff_t
std::quick_exit
std::raise
std::range_error
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::rank
std::rbegin(std::initializer_list)
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::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::rend(std::initializer_list)
std::result_of
std::rethrow_exception
std::rethrow_if_nested
std::return_temporary_buffer
std::runtime_error
std::set_new_handler
std::set_terminate
std::set_unexpected
std::shared_ptr
std::shared_ptr::get
std::shared_ptr::operator bool
std::shared_ptr::operator->
std::shared_ptr::operator<<
std::shared_ptr::operator=
std::shared_ptr::operator[]
std::shared_ptr::operators
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::static_pointer_cast
std::strftime
std::strong_equal
std::strong_equality
std::strong_order
std::strong_ordering
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_category
std::system_error
std::system_error::code
std::system_error::system_error
std::system_error::what
std::terminate
std::terminate_handler
std::throw_with_nested
std::tie
std::time
std::time_t
std::timespec
std::timespec_get
std::tm
std::to_address
std::to_chars
std::tuple
std::tuple::operator=
std::tuple::swap
std::tuple::tuple
std::tuple_cat
std::tuple_element
std::tuple_element
std::tuple_size
std::tuple_size
std::tx_exception
std::type_identity
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::uncaught_exception
std::uncaught_exceptions
std::undeclare_no_pointers
std::undeclare_reachable
std::underflow_error
std::underlying_type
std::unexpected
std::unexpected_handler
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::release
std::unique_ptr::reset
std::unique_ptr::swap
std::unique_ptr::unique_ptr
std::unique_ptr::~unique_ptr
std::unwrap_ref_decay
std::unwrap_reference
std::uses_allocator
std::uses_allocator
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::visit
std::void_t
std::wcsftime
std::weak_equal
std::weak_equality
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
va_arg
va_copy
va_end
va_start
Atomic operations
ATOMIC_FLAG_INIT
ATOMIC_VAR_INIT
ATOMIC_xxx_LOCK_FREE
Atomic operations library
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::operator T
std::atomic::operator=
std::atomic::operators
std::atomic::operators (int)
std::atomic::store
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::operator=
std::atomic_flag::test_and_set
std::atomic_flag_clear
std::atomic_flag_clear_explicit
std::atomic_flag_test_and_set
std::atomic_flag_test_and_set_explicit
std::atomic_init
std::atomic_is_lock_free
std::atomic_load
std::atomic_load_explicit
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::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_signal_fence
std::atomic_store
std::atomic_store_explicit
std::atomic_thread_fence
std::kill_dependency
std::memory_order
Strings
Null-terminated byte strings
Null-terminated multibyte strings
Null-terminated wide strings
Strings library
begin
deduction guides for std::basic_string
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::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::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::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::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::erase
std::erase_if
std::getline
std::hash
std::hash
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::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
Containers
Containers library
Node handle
begin
cbefore_begin
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
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
std::erase
std::erase
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
std::erase_if
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::get(std::span)
std::hash
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::cbegin
std::span::cend
std::span::crbegin
std::span::crend
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::tuple_element
std::tuple_element
std::tuple_size(std::array)
std::tuple_size(std::span)
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::uses_allocator
std::uses_allocator
std::uses_allocator
std::vector
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::swap
std::vector::vector
std::vector::~vector
Numerics
Common mathematical functions
Compile-time rational arithmetic
FE_ALL_EXCEPT
FE_DFL_ENV
FE_DIVBYZERO
FE_DOWNWARD
FE_INEXACT
FE_INVALID
FE_OVERFLOW
FE_TONEAREST
FE_TOWARDZERO
FE_UNDERFLOW
FE_UPWARD
FP_INFINITE
FP_NAN
FP_NORMAL
FP_SUBNORMAL
FP_ZERO
Floating-point environment
HUGE_VAL
HUGE_VALF
HUGE_VALL
INFINITY
MATH_ERREXCEPT
MATH_ERRNO
Mathematical special functions
NAN
Numerics library
Pseudo-random number generation
RAND_MAX
beta
deduction guides for std::valarray
densities
densities
math_errhandling
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
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)
std::UniformRandomBitGenerator
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::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::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::ceil2
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::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::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::floor2
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::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::ispow2
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::log2p1
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::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::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::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::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_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::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
Input/output
C-style file input/output
Input/output library
Input/output manipulators
egptr
gptr
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_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_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_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_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_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::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::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_stringstream
std::basic_stringstream::basic_stringstream
std::basic_stringstream::operator=
std::basic_stringstream::rdbuf
std::basic_stringstream::str
std::basic_stringstream::swap
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::fixed
std::flush
std::flush_emit
std::fopen
std::fpos
std::fpos::state
std::fprintf
std::fprintf
std::fputc
std::fputs
std::fputwc
std::fputws
std::fread
std::freopen
std::fscanf
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::Init
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::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::is_error_code_enum
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::no_emit_on_flush
std::noboolalpha
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::printf
std::put_money
std::put_time
std::putc
std::putchar
std::puts
std::putwchar
std::quoted
std::remove
std::rename
std::resetiosflags
std::rewind
std::right
std::scanf
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::snprintf
std::sprintf
std::sprintf
std::sscanf
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_istringstream)
std::swap(std::basic_ofstream)
std::swap(std::basic_ostringstream)
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
Concepts
Concepts library
std::Assignable
std::Boolean
std::Common
std::CommonReference
std::Constructible
std::ConvertibleTo
std::CopyConstructible
std::Copyable
std::DefaultConstructible
std::DerivedFrom
std::Destructible
std::EqualityComparable
std::EqualityComparableWith
std::Integral
std::Invocable
std::Movable
std::MoveConstructible
std::Predicate
std::Regular
std::RegularInvocable
std::Relation
std::Same
std::Semiregular
std::SignedIntegral
std::StrictTotallyOrdered
std::StrictTotallyOrderedWith
std::StrictWeakOrder
std::Swappable
std::SwappableWith
std::UnsignedIntegral
Regular expressions
Regular expressions library
deduction guides for std::basic_regex
operator<<(std::sub_match)
operators (std::match_results)
operators (std::sub_match)
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::regex_error
std::regex_iterator
std::regex_iterator::operator=
std::regex_iterator::operators
std::regex_iterator::operators
std::regex_iterator::operators (int)
std::regex_iterator::regex_iterator
std::regex_match
std::regex_replace
std::regex_search
std::regex_token_iterator
std::regex_token_iterator::operator=
std::regex_token_iterator::operators (int)
std::regex_token_iterator::operators (operator->)
std::regex_token_iterator::regex_token_iterator
std::regex_traits
std::regex_traits::getloc
std::regex_traits::imbue
std::regex_traits::isctype
std::regex_traits::length
std::regex_traits::lookup_classname
std::regex_traits::lookup_collatename
std::regex_traits::regex_traits
std::regex_traits::transform
std::regex_traits::transform_primary
std::regex_traits::translate
std::regex_traits::translate_nocase
std::regex_traits::value
std::sub_match
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)
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::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::operator!=
std::pmr::operators (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::deallocate_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::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::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
std::scoped_allocator_adaptor::scoped_allocator_adaptor
std::scoped_allocator_adaptor::select_on_container_copy_construction
std::scoped_allocator_adaptor::~scoped_allocator_adaptor
Localizations
LC_ALL
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
Localization library
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
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
std::ctype::classic_table
std::ctype::ctype
std::ctype::ctype
std::ctype::do_is
std::ctype::do_scan_is
std::ctype::do_scan_not
std::ctype::do_tolower
std::ctype::do_toupper
std::ctype::is
std::ctype::is
std::ctype::narrow
std::ctype::scan_is
std::ctype::scan_is
std::ctype::scan_not
std::ctype::scan_not
std::ctype::table
std::ctype::tolower
std::ctype::toupper
std::ctype::widen
std::ctype::~ctype
std::ctype::~ctype
std::ctype_base
std::ctype_byname
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
Feature testing
Feature testing
Filesystem
Filesystem library
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::increment
std::filesystem::directory_iterator::operator->
std::filesystem::directory_iterator::operator=
std::filesystem::directory_iterator::operators
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::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::increment
std::filesystem::recursive_directory_iterator::operator->
std::filesystem::recursive_directory_iterator::operator=
std::filesystem::recursive_directory_iterator::operators
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
Iterator
Iterator library
operator-(std::move_iterator)
operator-(std::reverse_iterator)
operators (std::istream_iterator)
operators (std::istreambuf_iterator)
operators (std::move_iterator)
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_inserter
std::begin
std::bidirectional_iterator_tag
std::cbegin
std::cend
std::contiguous_iterator_tag
std::crbegin
std::crend
std::data
std::distance
std::empty
std::end
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_inserter
std::incrementable_traits
std::input_iterator_tag
std::insert_iterator
std::insert_iterator::insert_iterator
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_reference_t
std::iter_rvalue_reference_t
std::iter_value_t
std::iterator
std::iterator_traits
std::make_move_iterator
std::make_reverse_iterator
std::move_iterator
std::move_iterator::base
std::move_iterator::move_iterator
std::move_iterator::operator=
std::move_iterator::operator[]
std::move_iterator::operators
std::move_iterator::operators
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_tag
std::prev
std::random_access_iterator_tag
std::rbegin
std::readable_traits
std::rend
std::reverse_iterator
std::reverse_iterator::base
std::reverse_iterator::operator=
std::reverse_iterator::operator[]
std::reverse_iterator::operators
std::reverse_iterator::operators
std::reverse_iterator::reverse_iterator
std::size
std::ssize
Named requirements
Named requirements
named requirements: Allocator
named requirements: AllocatorAwareContainer
named requirements: AssociativeContainer
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: FunctionObject
named requirements: Hash
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: SeedSequence
named requirements: SequenceContainer
named requirements: SharedMutex
named requirements: SharedTimedMutex
named requirements: StandardLayoutType
named requirements: Swappable
named requirements: TimedLockable
named requirements: TimedMutex
named requirements: TransformationTrait
named requirements: TrivialClock
named requirements: TrivialType
named requirements: TriviallyCopyable
named requirements: UnaryTypeTrait
named requirements: UnformattedInputFunction
named requirements: UnformattedOutputFunction
named requirements: UniformRandomBitGenerator
named requirements: UnorderedAssociativeContainer
named requirements: ValueSwappable
Thread support
Thread support library
operator<<(std::thread::id)
operators (std::thread::id)
std::adopt_lock
std::adopt_lock_t
std::async
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::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::what
std::future_status
std::hardware_constructive_interference_size
std::hardware_destructive_interference_size
std::hash
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::mutex
std::mutex::lock
std::mutex::mutex
std::mutex::native_handle
std::mutex::try_lock
std::mutex::unlock
std::mutex::~mutex
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::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
std::uses_allocator
std::uses_allocator
Ranges
Ranges library
Semiregular wrapper
std::ranges::BidirectionalRange
std::ranges::CommonRange
std::ranges::ContiguousRange
std::ranges::ForwardRange
std::ranges::InputRange
std::ranges::OutputRange
std::ranges::RandomAccessRange
std::ranges::Range
std::ranges::SizedRange
std::ranges::View
std::ranges::ViewableRange
std::ranges::all_view
std::ranges::begin
std::ranges::cbegin
std::ranges::dangling
std::ranges::disable_sized_range
std::ranges::empty_view
std::ranges::enable_view
std::ranges::filter_view
std::ranges::iota_view
std::ranges::iterator_t
std::ranges::ref_view
std::ranges::reverse_view
std::ranges::safe_iterator_t
std::ranges::safe_subrange_t
std::ranges::sentinel_t
std::ranges::view::all
std::ranges::view::counted
std::ranges::view::empty
std::ranges::view::filter
std::ranges::view::iota
std::ranges::view::reverse
std::ranges::view_base
Copyright ©2025 TypeError Powered By AnyPost, page cost 103ms.
Privacy Policy