Index
Symbols
Numbers
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
Symbols
!
,
see
operator, logical negation
!=
,
see
operator, inequality
#
operator,
[cpp.replace]
,
[cpp.stringize]
#
#
operator,
[cpp.concat]
#define
,
[cpp.replace]
#elif
,
[cpp.cond]
#else
,
[cpp.cond]
#endif
,
[cpp.cond]
#error
,
see
preprocessing directives, error
#if
,
[cpp.cond]
,
[res.on.macro.definitions]
#ifdef
,
[cpp.cond]
#ifndef
,
[cpp.cond]
#include
,
[cpp.include]
,
[using.headers]
#line
,
see
preprocessing directives, line control
#pragma
,
see
preprocessing directives, pragma
#undef
,
[cpp.scope]
,
[macro.names]
%
,
see
operator, remainder
&
,
see
operator, address-of
,
see
operator, bitwise AND
,
see
declarator, reference
&&
,
see
operator, logical AND
()
,
see
operator, function call
,
see
declarator, function
*
,
see
operator, indirection
,
see
operator, multiplication
,
see
declarator, pointer
+
,
see
operator, unary plus
,
see
operator, addition
++
,
see
operator, increment
,
,
see
operator, comma
-
,
see
operator, unary minus
,
see
operator, subtraction
--
,
see
operator, decrement
->
,
see
operator, class member access
->*
,
see
operator, pointer to member
.
,
see
operator, class member access
.*
,
see
operator, pointer to member
...
,
see
ellipsis
/
,
see
operator, division
:
bit-field declaration,
[class.bit]
label specifier,
[stmt.label]
::
,
see
operator, scope resolution
::*
,
see
declarator, pointer-to-member
<
,
see
operator, less than
template and,
[temp.param]
,
[temp.names]
<<
,
see
operator, left shift
<=
,
see
operator, less than or equal to
<=>
,
see
operator, three-way comparison
=
,
see
assignment operator
==
,
see
operator, equality
>
,
see
operator, greater than
>=
,
see
operator, greater than or equal to
>>
,
see
operator, right shift
?:
,
see
operator, conditional expression
[]
,
see
operator, subscripting
,
see
declarator, array
\
,
see
backslash character
^
,
see
operator, bitwise exclusive OR
_
,
see
character, underscore
__cplusplus
,
[cpp.predefined]
__cpp_aggregate_bases
,
[cpp.predefined]
__cpp_aggregate_nsdmi
,
[cpp.predefined]
__cpp_aggregate_paren_init
,
[cpp.predefined]
__cpp_alias_templates
,
[cpp.predefined]
__cpp_aligned_new
,
[cpp.predefined]
__cpp_attributes
,
[cpp.predefined]
__cpp_binary_literals
,
[cpp.predefined]
__cpp_capture_star_this
,
[cpp.predefined]
__cpp_char8_t
,
[cpp.predefined]
__cpp_concepts
,
[cpp.predefined]
__cpp_conditional_explicit
,
[cpp.predefined]
__cpp_consteval
,
[cpp.predefined]
__cpp_constexpr
,
[cpp.predefined]
__cpp_constexpr_dynamic_alloc
,
[cpp.predefined]
__cpp_constexpr_in_decltype
,
[cpp.predefined]
__cpp_constinit
,
[cpp.predefined]
__cpp_decltype
,
[cpp.predefined]
__cpp_decltype_auto
,
[cpp.predefined]
__cpp_deduction_guides
,
[cpp.predefined]
__cpp_delegating_constructors
,
[cpp.predefined]
__cpp_designated_initializers
,
[cpp.predefined]
__cpp_enumerator_attributes
,
[cpp.predefined]
__cpp_fold_expressions
,
[cpp.predefined]
__cpp_generic_lambdas
,
[cpp.predefined]
__cpp_guaranteed_copy_elision
,
[cpp.predefined]
__cpp_hex_float
,
[cpp.predefined]
__cpp_if_constexpr
,
[cpp.predefined]
__cpp_impl_coroutine
,
[cpp.predefined]
__cpp_impl_destroying_delete
,
[cpp.predefined]
__cpp_impl_three_way_comparison
,
[cpp.predefined]
__cpp_inheriting_constructors
,
[cpp.predefined]
__cpp_init_captures
,
[cpp.predefined]
__cpp_initializer_lists
,
[cpp.predefined]
__cpp_inline_variables
,
[cpp.predefined]
__cpp_lambdas
,
[cpp.predefined]
__cpp_modules
,
[cpp.predefined]
__cpp_namespace_attributes
,
[cpp.predefined]
__cpp_noexcept_function_type
,
[cpp.predefined]
__cpp_nontype_template_args
,
[cpp.predefined]
__cpp_nontype_template_parameter_auto
,
[cpp.predefined]
__cpp_nsdmi
,
[cpp.predefined]
__cpp_range_based_for
,
[cpp.predefined]
__cpp_raw_strings
,
[cpp.predefined]
__cpp_ref_qualifiers
,
[cpp.predefined]
__cpp_return_type_deduction
,
[cpp.predefined]
__cpp_rvalue_references
,
[cpp.predefined]
__cpp_sized_deallocation
,
[cpp.predefined]
__cpp_static_assert
,
[cpp.predefined]
__cpp_structured_bindings
,
[cpp.predefined]
__cpp_template_template_args
,
[cpp.predefined]
__cpp_threadsafe_static_init
,
[cpp.predefined]
__cpp_unicode_characters
,
[cpp.predefined]
__cpp_unicode_literals
,
[cpp.predefined]
__cpp_user_defined_literals
,
[cpp.predefined]
__cpp_using_enum
,
[cpp.predefined]
__cpp_variable_templates
,
[cpp.predefined]
__cpp_variadic_templates
,
[cpp.predefined]
__cpp_variadic_using
,
[cpp.predefined]
__DATE__
,
[cpp.predefined]
__FILE__
,
[cpp.predefined]
__has_cpp_attribute
,
[cpp.cond]
__has_include
,
[cpp.cond]
__LINE__
,
[cpp.predefined]
__STDC__
,
[cpp.predefined]
__STDC_HOSTED__
,
[cpp.predefined]
__STDC_ISO_10646__
,
[cpp.predefined]
__STDC_MB_MIGHT_NEQ_WC__
,
[cpp.predefined]
__STDC_VERSION__
,
[cpp.predefined]
__STDCPP_DEFAULT_NEW_ALIGNMENT__
,
[cpp.predefined]
__STDCPP_STRICT_POINTER_SAFETY__
,
[cpp.predefined]
__STDCPP_THREADS__
,
[cpp.predefined]
__TIME__
,
[cpp.predefined]
__VA_ARGS__
,
[cpp.replace]
,
[cpp.subst]
__VA_OPT__
,
[cpp.replace]
,
[cpp.subst]
{}
block statement,
[stmt.block]
class declaration,
[class.pre]
class definition,
[class.pre]
enum
declaration,
[dcl.enum]
initializer list,
[dcl.init.aggr]
|
,
see
operator, bitwise inclusive OR
||
,
see
operator, logical OR
~
,
see
operator, ones' complement
,
see
destructor
Numbers
0
,
see also
zero, null
null character,
see
character, null
string terminator,
[lex.string]
A
abbreviated
template function,
see
template, function, abbreviated
abort
,
[basic.start.term]
,
[stmt.jump]
absolute path,
see
path, absolute
abstract class,
see
class, abstract
access,
[defns.access]
access control,
[class.access]
anonymous
union
,
[class.union.anon]
base class,
[class.access.base]
base class member,
[class.derived]
class member,
[expr.ref]
default,
[class.access]
default argument,
[class.access]
friend function,
[class.friend]
member function and,
[special]
member name,
[class.access]
multiple access,
[class.paths]
nested class,
[class.access.nest]
overload resolution and,
[class.member.lookup]
overloading and,
[over.dcl]
private
,
[class.access]
protected
,
[class.access]
,
[class.protected]
public
,
[class.access]
using-declaration and,
[namespace.udecl]
virtual function,
[class.access.virt]
access specifier,
[class.access.spec]
,
[class.access.base]
accessible,
[class.access.base]
active
union member,
[class.union]
active macro directive,
see
macro, active
addition operator,
see
operator, addition
address,
[basic.compound]
,
[expr.eq]
addressable function,
see
function, addressable
aggregate,
[dcl.init.aggr]
,
[dcl.init.aggr]
elements,
[dcl.init.aggr]
aggregate deduction candidate,
see
candidate, aggregate deduction
aggregate initialization,
[dcl.init.aggr]
<algorithm>
,
[version.syn]
,
[algorithm.syn]
,
[diff.cpp03.library]
algorithm
stable,
[defns.stable]
,
[algorithm.stable]
alias
namespace,
[namespace.alias]
alias template,
see
template, alias
alignas
,
[lex.key]
,
[dcl.attr.grammar]
,
[dcl.align]
,
[gram.dcl]
alignment,
[basic.align]
extended,
[basic.align]
fundamental,
[basic.align]
new-extended,
[basic.align]
stricter,
[basic.align]
stronger,
[basic.align]
weaker,
[basic.align]
alignment requirement
implementation-defined,
[basic.align]
alignof
,
[lex.key]
,
[expr.unary]
,
[expr.alignof]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
allocated type,
see
type, allocated
allocation
alignment storage,
[expr.new]
implementation-defined bit-field,
[class.bit]
unspecified,
[class.mem]
allocation functions,
[basic.stc.dynamic]
alternate form
format string,
[format.string.std]
alternative token,
see
token, alternative
ambiguity
base class member,
[class.member.lookup]
class conversion,
[class.member.lookup]
declaration type,
[dcl.spec]
declaration versus cast,
[dcl.ambig.res]
declaration versus expression,
[stmt.ambig]
function declaration,
[dcl.init]
member access,
[class.member.lookup]
overloaded function,
[over.match]
parentheses and,
[expr.new]
ambiguous conversion sequence,
see
conversion sequence, ambiguous
Amendment 1,
[extern.names]
and
,
[lex.key]
and_eq
,
[lex.key]
anonymous union,
[class.union.anon]
anonymous union object,
[class.union.anon]
<any>
,
[version.syn]
,
[any.synop]
,
[diff.cpp14.library]
appearance-ordered,
[basic.start.dynamic]
appertain,
[dcl.attr.grammar]
argc
,
[basic.start.main]
argument,
[defns.argument]
,
[defns.argument.macro]
,
[defns.argument.throw]
,
[defns.argument.templ]
,
[res.on.arguments]
,
[res.on.macro.definitions]
,
[out.of.range]
access checking and default,
[class.access]
binding of default,
[dcl.fct.default]
evaluation of default,
[dcl.fct.default]
example of default,
[dcl.fct.default]
function call expression,
[defns.argument]
function-like macro,
[defns.argument.macro]
overloaded operator and default,
[over.oper]
reference,
[expr.call]
scope of default,
[dcl.fct.default]
template,
[temp.arg]
template instantiation,
[defns.argument.templ]
throw expression,
[defns.argument.throw]
type checking of default,
[dcl.fct.default]
argument and name hiding
default,
[dcl.fct.default]
argument and virtual function
default,
[dcl.fct.default]
argument forwarding call wrapper,
[func.require]
argument list
empty,
[dcl.fct]
variable,
[dcl.fct]
argument passing,
[expr.call]
reference and,
[dcl.init.ref]
argument substitution,
see
macro, argument substitution
argument type
unknown,
[dcl.fct]
argv
,
[basic.start.main]
arithmetic
pointer,
[expr.add]
unsigned
,
[basic.fundamental]
<array>
,
[version.syn]
,
[tuple.helper]
,
[sequences.general]
,
[array.syn]
,
[array.overview]
,
[iterator.range]
,
[diff.cpp03.library]
,
[depr.tuple]
array
as aggregate,
[array.overview]
bound,
[dcl.array]
const
,
[basic.type.qualifier]
contiguous storage,
[array.overview]
creation,
[array.creation]
delete
,
[expr.delete]
element,
[dcl.array]
handler of type,
[except.handle]
initialization,
[array.overview]
,
[array.cons]
new
,
[expr.new]
overloading and pointer versus,
[over.load]
parameter of type,
[dcl.fct]
sizeof
,
[expr.sizeof]
template parameter of type,
[temp.param]
tuple interface to,
[array.tuple]
zero sized,
[array.zero]
array size
default,
[dcl.array]
array type,
[dcl.array]
arrow operator,
see
operator, class member access
as-if rule,
[intro.abstract]
asm
,
[lex.key]
,
[dcl.asm]
,
[gram.dcl]
implementation-defined,
[dcl.asm]
assembler,
[dcl.asm]
<assert.h>
,
[using.headers]
,
[cassert.syn]
,
[diff.header.assert.h]
,
[depr.c.headers]
assignment
and lvalue,
[expr.ass]
conversion by,
[expr.ass]
copy,
see
assignment operator, copy
move,
see
assignment operator, move
,
[defns.move.assign]
reference,
[dcl.init.ref]
assignment operator
copy,
[special]
,
[class.copy.assign]
hidden,
[class.copy.assign]
implicitly declared,
[class.copy.assign]
implicitly defined,
[class.copy.assign]
non-trivial,
[class.copy.assign]
trivial,
[class.copy.assign]
virtual bases and,
[class.copy.assign]
move,
[special]
,
[class.copy.assign]
hidden,
[class.copy.assign]
implicitly declared,
[class.copy.assign]
implicitly defined,
[class.copy.assign]
non-trivial,
[class.copy.assign]
trivial,
[class.copy.assign]
overloaded,
[over.ass]
associated,
[thread.stoptoken.intro]
associated constraints,
[temp.constr.decl]
associative containers
exception safety,
[associative.reqmts.except]
requirements,
[associative.reqmts.except]
unordered,
see
unordered associative containers
asynchronous provider,
[futures.state]
asynchronous return object,
[futures.state]
at least as constrained,
[temp.constr.order]
at least as specialized as,
see
more specialized
atexit
,
[basic.start.term]
<atomic>
,
[compliance]
,
[version.syn]
,
[atomics.syn]
,
[diff.cpp03.library]
,
[depr.atomics]
atomic
notifying operation,
[atomics.wait]
operation,
[intro.multithread]
smart pointers,
[util.smartptr.atomic]
waiting operation,
[atomics.wait]
eligible to be unblocked,
[atomics.wait]
atomic constraint,
see
constraint, atomic
identical,
[temp.constr.atomic]
attached
declaration,
[module.unit]
entity,
[basic.link]
attribute,
[dcl.attr]
alignment,
[dcl.align]
carries dependency,
[dcl.attr.depend]
deprecated,
[dcl.attr.deprecated]
fallthrough,
[dcl.attr.fallthrough]
likely,
[dcl.attr.likelihood]
maybe unused,
[dcl.attr.unused]
no unique address,
[dcl.attr.nouniqueaddr]
nodiscard,
[dcl.attr.nodiscard]
noreturn,
[dcl.attr.noreturn]
syntax and semantics,
[dcl.attr.grammar]
unlikely,
[dcl.attr.likelihood]
auto
,
[lex.key]
,
[stmt.ranged]
,
[dcl.spec.auto]
,
[gram.dcl]
automatic storage duration,
see
storage duration, automatic
awk
,
[re.synopt]
B
backslash character,
[lex.ccon]
bad_alloc
,
[expr.new]
bad_cast
,
[expr.dynamic.cast]
bad_typeid
,
[expr.typeid]
<barrier>
,
[version.syn]
,
[barrier.syn]
,
[diff.cpp17.library]
barrier
phase synchronization point,
[thread.barrier.class]
barrier phase,
[thread.barrier.class]
base characteristic,
[meta.rqmts]
base class,
[class.derived]
,
[class.mi]
dependent,
[temp.dep.type]
direct,
[class.derived]
indirect,
[class.derived]
non-virtual,
[class.mi]
overloading and,
[over.dcl]
private
,
[class.access.base]
protected
,
[class.access.base]
public
,
[class.access.base]
virtual,
[class.mi]
,
[class.mi]
base class subobject,
[intro.object]
base prefix,
[format.string.std]
base-2 representation,
[basic.fundamental]
behavior
conditionally-supported,
[defns.cond.supp]
,
[intro.compliance]
default,
[defns.default.behavior.impl]
,
[defns.default.behavior.func]
,
[structure.specifications]
implementation-defined,
[defns.impl.defined]
,
[intro.abstract]
locale-specific,
[defns.locale.specific]
observable,
[intro.abstract]
,
[intro.abstract]
on receipt of signal,
[intro.execution]
required,
[defns.required.behavior]
,
[structure.specifications]
undefined,
[defns.undefined]
,
[intro.compliance]
,
[intro.abstract]
,
[istreambuf.iterator]
unspecified,
[defns.unspecified]
,
[intro.abstract]
Ben,
[over.dcl]
Bernoulli distributions,
[rand.dist.bern]
bernoulli_distribution
discrete probability function,
[rand.dist.bern.bernoulli]
Bessel functions
I
ν
,
[sf.cmath.cyl.bessel.i]
j
n
,
[sf.cmath.sph.bessel]
J
ν
,
[sf.cmath.cyl.bessel.j]
K
ν
,
[sf.cmath.cyl.bessel.k]
n
n
,
[sf.cmath.sph.neumann]
N
ν
,
[sf.cmath.cyl.neumann]
beta functions
B
,
[sf.cmath.beta]
better conversion,
see
conversion, better
better conversion sequence,
see
conversion sequence, better
binary fold,
[expr.prim.fold]
binary left fold,
[expr.prim.fold]
binary operator
interpretation of,
[over.binary]
overloaded,
[over.binary]
binary operator function,
see
operator function, binary
binary right fold,
[expr.prim.fold]
bind directly,
[dcl.init.ref]
binding
reference,
[dcl.init.ref]
binomial_distribution
discrete probability function,
[rand.dist.bern.bin]
<bit>
,
[version.syn]
,
[bit.general]
,
[diff.cpp17.library]
bit-field,
[class.bit]
address of,
[class.bit]
alignment of,
[class.bit]
implementation-defined alignment of,
[class.bit]
implementation-defined sign of,
[diff.class]
type of,
[class.bit]
unnamed,
[class.bit]
zero width of,
[class.bit]
bitand
,
[lex.key]
bitmask
element,
[bitmask.types]
empty,
[bitmask.types]
value
clear,
[bitmask.types]
is set,
[bitmask.types]
set,
[bitmask.types]
bitor
,
[lex.key]
<bitset>
,
[bitset.syn]
block (execution),
[defns.block]
,
[thread.req.lockable.basic]
,
[thread.thread.member]
,
[thread.jthread.mem]
,
[thread.thread.this]
,
[thread.mutex.requirements.mutex]
,
[thread.mutex.class]
,
[thread.mutex.recursive]
,
[thread.timedmutex.class]
,
[thread.timedmutex.recursive]
,
[thread.sharedmutex.requirements]
,
[thread.condition.condvar]
,
[thread.condvarany.wait]
,
[thread.sema.cnt]
,
[thread.latch.class]
,
[thread.barrier.class]
,
[futures.unique.future]
,
[futures.shared.future]
with forward progress guarantee delegation,
[intro.progress]
block (statement),
[defns.block.stmt]
,
see
statement, compound
initialization in,
[stmt.dcl]
scope,
[basic.scope.block]
structure,
[stmt.dcl]
body
function,
[dcl.fct.def.general]
Bond
James Bond,
[expr.prim.lambda.capture]
bool
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
Boolean literal,
[lex.bool]
boolean literal,
see
literal, boolean
Boolean type,
[basic.fundamental]
bound argument entity,
[func.def]
bound arguments,
[func.bind.bind]
bound, of array,
[dcl.array]
brains
names that want to eat your,
[zombie.names]
break
,
[lex.key]
,
[stmt.jump]
,
[gram.stmt]
buckets,
[unord.req]
built-in candidate,
[over.match.oper]
built-in operators,
see
operators, built-in
byte,
[intro.memory]
,
[expr.sizeof]
C
C
linkage to,
[dcl.link]
standard,
[intro.scope]
standard library,
[intro.refs]
C++ library headers
importable,
[headers]
call
nodiscard,
[dcl.attr.nodiscard]
operator function,
[over.oper]
call pattern,
[func.require]
call signature,
[func.def]
call wrapper,
[func.require]
,
[func.def]
forwarding,
[func.require]
perfect forwarding,
[func.require]
simple,
[func.require]
type,
[func.def]
callable object,
see
object, callable
callable type,
see
type, callable
,
[func.wrap.func]
candidate,
[over.match]
aggregate deduction,
[over.match.class.deduct]
usable,
[over.match]
capture
implicit,
[expr.prim.lambda.capture]
captured,
[expr.prim.lambda.capture]
by copy,
[expr.prim.lambda.capture]
by reference,
[expr.prim.lambda.capture]
carries a dependency,
[intro.races]
carry
subtract_with_carry_engine
,
[rand.eng.sub]
case
,
[lex.key]
,
[stmt.label]
,
[stmt.switch]
,
[gram.stmt]
<cassert>
,
[using.headers]
,
[assertions]
,
[diff.header.assert.h]
cast
base class,
[expr.static.cast]
const,
[expr.const.cast]
,
[expr.cast]
derived class,
[expr.static.cast]
dynamic,
[expr.dynamic.cast]
,
[bad.cast]
construction and,
[class.cdtor]
destruction and,
[class.cdtor]
integer to pointer,
[expr.reinterpret.cast]
lvalue,
[expr.static.cast]
,
[expr.reinterpret.cast]
pointer to integer,
[expr.reinterpret.cast]
pointer-to-function,
[expr.reinterpret.cast]
pointer-to-member,
[expr.static.cast]
,
[expr.reinterpret.cast]
reference,
[expr.static.cast]
,
[expr.reinterpret.cast]
reinterpret,
[expr.reinterpret.cast]
,
[expr.cast]
integer to pointer,
[expr.reinterpret.cast]
lvalue,
[expr.reinterpret.cast]
pointer to integer,
[expr.reinterpret.cast]
pointer-to-function,
[expr.reinterpret.cast]
pointer-to-member,
[expr.reinterpret.cast]
reference,
[expr.reinterpret.cast]
static,
[expr.static.cast]
,
[expr.cast]
lvalue,
[expr.static.cast]
reference,
[expr.static.cast]
undefined pointer-to-function,
[expr.reinterpret.cast]
casting,
[expr.type.conv]
casting away constness,
[expr.const.cast]
catch
,
[lex.key]
,
[except.pre]
category tag,
[std.iterator.tags]
cats
interfering with canines,
[hardware.interference]
cauchy_distribution
probability density function,
[rand.dist.norm.cauchy]
<ccomplex>
absence thereof,
[zombie.names]
,
[diff.cpp17.library]
<cctype>
,
[cctype.syn]
,
[locale.ctype]
<cerrno>
,
[extern.names]
,
[errno]
,
[system.error.syn]
<cfenv>
,
[cfenv.syn]
,
[diff.cpp03.library]
<cfloat>
,
[support.limits.general]
,
[cfloat.syn]
char
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
implementation-defined sign of,
[basic.fundamental]
char-like object,
[strings.general]
char-like type,
[strings.general]
char_class_type
regular expression traits,
[re.req]
char16_t
,
[lex.key]
,
see
type,
char16_t
,
[dcl.type.simple]
,
[gram.dcl]
char32_t
,
[lex.key]
,
see
type,
char32_t
,
[dcl.type.simple]
,
[gram.dcl]
char8_t
,
[lex.key]
,
see
type,
char8_t
,
[dcl.type.simple]
,
[gram.dcl]
character,
[defns.character]
decimal-point,
[character.seq]
multibyte,
[defns.multibyte]
null,
[lex.charset]
signed
,
[basic.fundamental]
source file,
[lex.phases]
terminating null,
[byte.strings]
underscore,
[lex.name]
in identifier,
[lex.name]
character literal,
see
literal, character
character sequence,
[character.seq]
character set,
[lex.charset]
basic execution,
[lex.charset]
,
[intro.memory]
basic source,
[lex.phases]
,
[lex.charset]
execution,
[lex.charset]
character string,
[lex.string]
character string literal,
[cpp.stringize]
<charconv>
,
[version.syn]
,
[charconv.syn]
,
[diff.cpp17.library]
,
[diff.cpp14.library]
checking
point of error,
[temp.res]
syntax,
[temp.res]
chi_squared_distribution
probability density function,
[rand.dist.norm.chisq]
<chrono>
,
[version.syn]
,
[time.syn]
,
[diff.cpp03.library]
chunks,
[mem.res.pool.overview]
<cinttypes>
,
[cinttypes.syn]
,
[diff.cpp03.library]
<ciso646>
absence thereof,
[zombie.names]
,
[diff.cpp17.library]
class
,
[lex.key]
,
[basic.compound]
,
[dcl.enum]
,
[class]
,
[class.pre]
,
[temp.param]
,
[gram.dcl]
,
[gram.class]
,
[gram.temp]
abstract,
[class.abstract]
base,
[derived.classes]
,
[derivation]
cast to incomplete,
[expr.cast]
constructor and abstract,
[class.abstract]
definition,
[basic.def.odr]
derived,
[derivation]
implicit-lifetime,
[class.prop]
linkage of,
[basic.link]
linkage specification,
[dcl.link]
local,
see
local class
,
[class.local]
member function,
see
member function, class
nested,
see
nested class
,
[class.nest]
polymorphic,
[class.virtual]
scope of enumerator,
[dcl.enum]
standard-layout,
[basic.types]
,
[class.prop]
trivial,
[basic.types]
,
[class.prop]
trivially copyable,
[basic.types]
,
[class.prop]
union-like,
[class.union.anon]
unnamed,
[dcl.typedef]
variant member of,
[class.union.anon]
class member access operator function,
see
operator function, class member access
class name
elaborated,
[dcl.type.elab]
,
[class.name]
point of declaration,
[class.name]
scope of,
[class.name]
typedef
,
[dcl.typedef]
,
[class.name]
class object
member,
[class.mem]
sizeof
,
[expr.sizeof]
class object copy,
see
constructor, copy
class object initialization,
see
constructor
<climits>
,
[intro.memory]
,
[support.limits.general]
,
[climits.syn]
,
[depr.strstreambuf.cons]
<clocale>
,
[character.seq]
,
[clocale.syn]
,
[diff.null]
closure object,
[expr.prim.lambda]
closure type,
[expr.prim.lambda.closure]
<cmath>
,
[version.syn]
,
[cmath.syn]
,
[c.math.abs]
,
[diff.cpp17.library]
,
[depr.tgmath.h.syn]
co_await
,
[lex.key]
,
[expr.await]
co_return
,
[lex.key]
,
[stmt.return.coroutine]
co_yield
,
[lex.key]
,
[expr.yield]
<codecvt>
,
[diff.cpp03.library]
,
[depr.locale.stdcvt]
coherence
read-read,
[intro.races]
read-write,
[intro.races]
write-read,
[intro.races]
write-write,
[intro.races]
coherence-ordered before,
[atomics.order]
collating element,
[re.def]
comma operator,
see
operator, comma
comment,
[lex.pptoken]
,
[lex.comment]
/*
*/
,
[lex.comment]
//
,
[lex.comment]
common comparison type,
[class.spaceship]
common initial sequence,
[class.mem]
<compare>
,
[expr.spaceship]
,
[version.syn]
,
[compare.syn]
,
[diff.cpp17.library]
comparison
pointer,
[expr.eq]
pointer to function,
[expr.eq]
undefined pointer,
[expr.add]
comparison category types,
[cmp.categories.pre]
comparison operator function,
see
operator function, comparison
compatible with
shared_ptr
,
[util.smartptr.shared]
compilation
separate,
[lex.separate]
compiler control line,
see
preprocessing directive
compl
,
[lex.key]
complete object,
[intro.object]
complete object of,
[intro.object]
complete-class context,
[class.mem]
completely defined,
[class.mem]
<complex>
,
[version.syn]
,
[complex.numbers]
,
[complex.syn]
,
[diff.cpp17.library]
,
[depr.complex.h.syn]
,
[depr.tgmath.h.syn]
<complex.h>
,
[diff.mods.to.headers]
,
[depr.c.headers]
,
[depr.complex.h.syn]
,
[depr.c.headers.other]
component,
[defns.component]
composite pointer type,
[expr.type]
concatenation
macro argument,
see
#
#
operator
string,
[lex.string]
concept
,
[lex.key]
,
[temp.concept]
,
[temp.concept]
,
[gram.temp]
model,
[res.on.requirements]
type,
[temp.concept]
concept-id,
[temp.names]
<concepts>
,
[version.syn]
,
[concepts.syn]
,
[diff.cpp17.library]
concurrent forward progress guarantees,
[intro.progress]
condition
s
rules for,
[stmt.pre]
<condition_variable>
,
[condition.variable.syn]
,
[diff.cpp03.library]
conditional-expression
throw-expression in,
[expr.cond]
conditionally-supported behavior,
see
behavior, conditionally-supported
conflict,
[intro.races]
conformance requirements,
[intro.compliance]
,
[intro.abstract]
class templates,
[intro.compliance]
classes,
[intro.compliance]
general,
[intro.compliance]
library,
[intro.compliance]
method of description,
[intro.compliance]
conjunction,
[temp.constr.op]
consistency
linkage,
[dcl.stc]
linkage specification,
[dcl.link]
type declaration,
[basic.link]
const
,
[lex.key]
,
[basic.type.qualifier]
,
[dcl.decl]
,
[gram.dcl]
cast away,
[expr.const.cast]
constructor and,
[class.this]
,
[class.ctor]
destructor and,
[class.this]
,
[class.dtor]
linkage of,
[basic.link]
overloading and,
[over.load]
const object,
see
object, const
undefined change to,
[dcl.type.cv]
const volatile member function,
[class.mfct.non-static]
const volatile object,
see
object, const volatile
const-default-constructible,
[dcl.init]
const-qualified,
[basic.type.qualifier]
const-volatile-qualified,
[basic.type.qualifier]
const_cast
,
[lex.key]
,
see
cast, const
,
[expr.post]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
const_local_iterator
,
[unord.req]
constant,
[lex.literal.kinds]
,
[expr.prim.literal]
enumeration,
[dcl.enum]
null pointer,
[conv.mem]
,
[conv.ptr]
constant destruction,
see
destruction, constant
constant expression,
see
expression, constant
,
[expr.const]
permitted result of,
[expr.const]
constant initialization,
[basic.start.static]
constant iterator,
[iterator.requirements.general]
constant subexpression,
[defns.const.subexpr]
constant-initialized,
[expr.const]
consteval
,
[lex.key]
,
[dcl.spec]
,
[gram.dcl]
constexpr
,
[lex.key]
,
[stmt.select]
,
[stmt.if]
,
[dcl.spec]
,
[gram.stmt]
,
[gram.dcl]
constexpr function,
[dcl.constexpr]
constexpr if,
[stmt.if]
constexpr iterators,
[iterator.requirements.general]
constexpr-compatible
defaulted comparison operator,
[class.compare.default]
defaulted special member function,
[special]
constinit
,
[lex.key]
,
[dcl.spec]
,
[dcl.constinit]
,
[gram.dcl]
,
[diff.cpp17.lex]
constituent expression,
[intro.execution]
constraint,
[temp.constr.constr]
associated,
see
associated constraints
atomic,
[temp.constr.atomic]
immediately-declared,
[temp.param]
normalization,
[temp.constr.normal]
satisfaction
atomic,
[temp.constr.atomic]
conjunction,
[temp.constr.op]
disjunction,
[temp.constr.op]
subsumption,
[temp.constr.order]
construction,
[class.cdtor]
dynamic cast and,
[class.cdtor]
member access,
[class.cdtor]
move,
[defns.move.constr]
pointer to member or base,
[class.cdtor]
typeid
operator,
[class.cdtor]
virtual function call,
[class.cdtor]
constructor,
[class.ctor]
,
[class.ctor]
address of,
[class.ctor]
array of class objects and,
[class.expl.init]
converting,
[class.conv.ctor]
copy,
[class.temporary]
,
[special]
,
[class.copy.ctor]
,
[functions.within.classes]
elision,
[class.copy.elision]
implicitly declared,
[class.copy.ctor]
implicitly defined,
[class.copy.ctor]
nontrivial,
[class.copy.ctor]
trivial,
[class.copy.ctor]
default,
[special]
,
[class.default.ctor]
non-trivial,
[class.default.ctor]
trivial,
[class.default.ctor]
exception handling,
see
exception handling, constructors and destructors
explicit call,
[class.ctor]
implicitly called,
[class.default.ctor]
implicitly defined,
[class.default.ctor]
inheritance of,
[class.default.ctor]
inherited,
[namespace.udecl]
move,
[special]
,
[class.copy.ctor]
elision,
[class.copy.elision]
implicitly declared,
[class.copy.ctor]
implicitly defined,
[class.copy.ctor]
non-trivial,
[class.copy.ctor]
trivial,
[class.copy.ctor]
non-trivial,
[class.default.ctor]
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
union
,
[class.union]
constructor, conversion by,
see
conversion, user-defined
contained value
any
,
[any.class]
optional
,
[optional.optional]
variant
,
[variant.variant]
container
contiguous,
[container.requirements.general]
reversible,
[container.requirements.general]
contains a value
optional
,
[optional.optional]
context
non-deduced,
[temp.deduct.type]
contextually converted constant expression of type
bool
,
see
conversion, contextual
contextually converted to bool,
see
conversion, contextual
contextually implicitly converted,
[conv]
contiguous container,
see
container, contiguous
continue
,
[lex.key]
,
[stmt.jump]
,
[gram.stmt]
and handler,
[except.pre]
and try block,
[except.pre]
control line,
see
preprocessing directive
conventions
lexical,
[lex.separate]
conversion
argument,
[dcl.fct]
array-to-pointer,
[conv.array]
better,
[over.ics.rank]
bool
,
[conv.integral]
boolean,
[conv.bool]
class,
[class.conv]
contextual,
[conv]
contextual to
bool
,
[conv]
contextual to constant expression of type
bool
,
[expr.const]
deduced return type of user-defined,
[class.conv.fct]
derived-to-base,
[over.best.ics]
floating to integral,
[conv.fpint]
floating-point,
[conv.double]
function pointer,
[conv.fctptr]
function-to-pointer,
[conv.func]
implementation-defined pointer integer,
[expr.reinterpret.cast]
implicit,
[conv]
,
[conv]
,
[class.conv]
implicit user-defined,
[class.conv]
inheritance of user-defined,
[class.conv.fct]
integer rank,
[conv.rank]
integral,
[conv.integral]
integral to floating,
[conv.fpint]
lvalue-to-rvalue,
[conv.lval]
,
[diff.expr]
narrowing,
[dcl.init.list]
null member pointer,
[conv.mem]
null pointer,
[conv.ptr]
overload resolution and,
[over.match.best]
overload resolution and pointer,
[over.over]
pointer,
[conv.ptr]
pointer-to-member,
[conv.mem]
void*
,
[conv.mem]
qualification,
[conv.qual]
return type,
[stmt.return]
standard,
[conv]
temporary materialization,
[conv.rval]
to signed,
[conv.integral]
to unsigned,
[conv.integral]
type of,
[class.conv.fct]
user-defined,
[class.conv.ctor]
,
[class.conv.fct]
,
[class.conv]
usual arithmetic,
[expr.arith.conv]
virtual user-defined,
[class.conv.fct]
conversion explicit type,
see
casting
conversion function,
see
conversion, user-defined
,
[class.conv.fct]
conversion rank,
[over.ics.scs]
conversion sequence
ambiguous,
[over.best.ics]
better,
[over.ics.rank]
implicit,
[over.best.ics]
indistinguishable,
[over.ics.rank]
standard,
[conv]
user-defined,
[over.ics.user]
worse,
[over.ics.rank]
converted constant expression,
see
expression, converted constant
converting constructor,
see
constructor, converting
copy
class object,
see
constructor, copy
,
see
assignment operator, copy
copy constructor
random number engine requirement,
[rand.req.eng]
copy deduction candidate,
[over.match.class.deduct]
copy elision,
see
constructor, copy, elision
copy-initialization,
[dcl.init]
copy-list-initialization,
[dcl.init.list]
core constant expression,
see
expression, core constant
<coroutine>
,
[version.syn]
,
[support.coroutine]
,
[coroutine.syn]
,
[coroutine.traits.primary]
,
[diff.cpp17.library]
coroutine,
[dcl.fct.def.coroutine]
promise type,
[dcl.fct.def.coroutine]
resumer,
[dcl.fct.def.coroutine]
coroutine return,
see
co_return
coroutine state,
[dcl.fct.def.coroutine]
counted range,
see
range, counted
Cpp17Allocator
,
[allocator.requirements]
Cpp17BinaryTypeTrait
,
[meta.rqmts]
Cpp17Clock
,
[time.clock.req]
Cpp17CopyAssignable
,
[utility.arg.requirements]
Cpp17CopyConstructible
,
[utility.arg.requirements]
Cpp17CopyInsertable
into
X
,
[container.requirements.general]
Cpp17DefaultConstructible
,
[utility.arg.requirements]
Cpp17DefaultInsertable
into
X
,
[container.requirements.general]
Cpp17Destructible
,
[utility.arg.requirements]
Cpp17EmplaceConstructible
into
X
from
args
,
[container.requirements.general]
Cpp17EqualityComparable
,
[utility.arg.requirements]
Cpp17Erasable
from
X
,
[container.requirements.general]
Cpp17Hash
,
[hash.requirements]
Cpp17LessThanComparable
,
[utility.arg.requirements]
Cpp17MoveAssignable
,
[utility.arg.requirements]
Cpp17MoveConstructible
,
[utility.arg.requirements]
Cpp17MoveInsertable
into
X
,
[container.requirements.general]
Cpp17NullablePointer
,
[nullablepointer.requirements]
Cpp17TransformationTrait
,
[meta.rqmts]
Cpp17UnaryTypeTrait
,
[meta.rqmts]
<csetjmp>
,
[extern.names]
,
[support.runtime]
,
[csetjmp.syn]
,
[diff.mods.to.behavior]
<csignal>
,
[support.runtime]
,
[csignal.syn]
<cstdalign>
absence thereof,
[zombie.names]
,
[diff.cpp17.library]
<cstdarg>
,
[dcl.fct]
,
[extern.names]
,
[support.runtime]
,
[cstdarg.syn]
<cstdbool>
absence thereof,
[zombie.names]
,
[diff.cpp17.library]
<cstddef>
,
[expr.sizeof]
,
[expr.alignof]
,
[expr.add]
,
[cstddef.syn]
,
[version.syn]
,
[diff.wchar.t]
,
[diff.null]
,
[diff.mods.to.declarations]
,
[diff.offsetof]
<cstdint>
,
[basic.fundamental]
,
[cstdint.syn]
,
[cinttypes.syn]
,
[atomics.ref.int]
,
[atomics.types.int]
,
[diff.cpp03.library]
<cstdio>
,
[support.start.term]
,
[iostream.objects.overview]
,
[narrow.stream.objects]
,
[wide.stream.objects]
,
[ios.init]
,
[filebuf.members]
,
[cstdio.syn]
,
[diff.null]
<cstdlib>
,
[basic.start.term]
,
[compliance]
,
[cstdlib.syn]
,
[support.start.term]
,
[new.delete.single]
,
[support.runtime]
,
[memory.general]
,
[c.malloc]
,
[c.mb.wcs]
,
[alg.c.library]
,
[c.math.rand]
,
[c.math.abs]
,
[facet.num.get.virtuals]
,
[diff.wchar.t]
,
[diff.null]
,
[diff.mods.to.behavior]
,
[depr.c.headers.other]
<cstring>
,
[class.mfct.non-static]
,
[byte.strings]
,
[cstring.syn]
,
[diff.null]
,
[diff.mods.to.declarations]
,
[depr.strstreambuf.cons]
,
[depr.ostrstream.cons]
<ctgmath>
absence thereof,
[zombie.names]
,
[diff.cpp17.library]
<ctime>
,
[ctime.syn]
,
[locale.syn]
,
[diff.null]
<ctype.h>
,
[cctype.syn]
,
[depr.c.headers]
<cuchar>
,
[extern.names]
,
[cuchar.syn]
,
[c.mb.wcs]
,
[diff.cpp03.library]
,
[diff.char16]
current instantiation,
[temp.dep.type]
dependent member of the,
[temp.dep.type]
member of the,
[temp.dep.type]
currently handled exception,
see
exception handling, currently handled exception
customization point,
[namespace.std]
cv-combined type,
see
type, cv-combined
cv-decomposition,
[conv.qual]
cv-qualification signature,
[conv.qual]
cv-qualifier,
[basic.type.qualifier]
top-level,
[basic.type.qualifier]
cv-unqualified type,
see
type, cv-unqualified
<cwchar>
,
[extern.names]
,
[char.traits.specializations.char]
,
[cwchar.syn]
,
[c.mb.wcs]
,
[diff.wchar.t]
,
[diff.null]
,
[diff.mods.to.declarations]
<cwctype>
,
[extern.names]
,
[cwctype.syn]
D
DAG
multiple inheritance,
[class.mi]
non-virtual base class,
[class.mi]
virtual base class,
[class.mi]
data member,
see
member
,
[class.mem]
static,
[class.mem]
data race,
[intro.races]
deadlock,
[defns.deadlock]
deallocation function
usual,
[basic.stc.dynamic.deallocation]
deallocation functions,
[basic.stc.dynamic]
decay
array,
see
conversion, array-to-pointer
function,
see
conversion, function-to-pointer
decl-reachable,
[module.global.frag]
declaration,
[basic.def]
,
[basic.pre]
,
[dcl.dcl]
,
[dcl.pre]
array,
[dcl.array]
asm
,
[dcl.asm]
bit-field,
[class.bit]
class name,
[basic.def]
constant pointer,
[dcl.ptr]
default argument,
[dcl.fct.default]
definition versus,
[basic.def]
disqualifying,
[concept.booleantestable]
ellipsis in function,
[expr.call]
,
[dcl.fct]
enumerator point of,
[basic.scope.pdecl]
exported,
[module.interface]
extern
,
[basic.def]
extern
reference,
[dcl.init.ref]
forward,
[dcl.stc]
forward class,
[class.name]
function,
[basic.def]
,
[dcl.fct]
,
[dcl.pre]
local class,
[class.local]
member,
[class.mem]
multiple,
[basic.link]
name,
[basic.def]
object,
[dcl.pre]
opaque enum,
[basic.def]
overloaded,
[over.pre]
overloaded name and
friend
,
[class.friend]
parameter,
[basic.def]
,
[dcl.fct]
parentheses in,
[dcl.ambig.res]
,
[dcl.meaning]
point of,
[basic.scope.pdecl]
,
[basic.scope.pdecl]
pointer,
[dcl.ptr]
reference,
[dcl.ref]
static
member,
[basic.def]
storage class,
[dcl.stc]
structured binding,
see
structured binding declaration
type,
[dcl.meaning]
typedef
,
[basic.def]
,
[dcl.pre]
typedef
as type,
[dcl.typedef]
declaration hiding,
see
name hiding
declarative region,
[basic.scope.declarative]
declarator,
[basic.def]
,
[dcl.pre]
,
[dcl.decl]
array,
[dcl.array]
function,
[dcl.fct]
meaning of,
[dcl.meaning]
multidimensional array,
[dcl.array]
pointer,
[dcl.ptr]
pointer-to-member,
[dcl.mptr]
reference,
[dcl.ref]
declared specialization,
see
specialization, declared
decltype
,
[lex.key]
,
[dcl.type.decltype]
,
[dcl.spec.auto]
,
[gram.dcl]
decrement operator
overloaded,
see
overloading, decrement operator
decrement operator function,
see
operator function, decrement
deducible template,
see
template, deducible
deduction
class template argument,
[temp.deduct.guide]
class template arguments,
[expr.type.conv]
,
[dcl.type.simple]
,
[dcl.type.class.deduct]
,
[over.match.class.deduct]
placeholder type,
[dcl.type.auto.deduct]
default
,
[lex.key]
,
[stmt.label]
,
[dcl.fct.def.general]
,
[gram.stmt]
,
[gram.dcl]
default access control,
see
access control, default
default argument
overload resolution and,
[over.match.viable]
default argument instantiation,
[temp.inst]
default constructor,
see
constructor, default
random number distribution requirement,
[rand.req.dist]
seed sequence requirement,
[rand.req.seedseq]
default initializers
overloading and,
[over.load]
default member initializer,
[class.mem]
default memory resource pointer,
[mem.res.global]
default-initialization,
[dcl.init]
default-inserted,
[container.requirements.general]
defaulted,
[dcl.fct.def.default]
deferred function,
see
function, deferred
define,
[basic.def]
defined
,
[cpp.cond]
definition,
[basic.def]
,
[basic.def]
alternate,
[replacement.functions]
class,
[class.mem]
,
[class.pre]
class name as type,
[class.name]
constructor,
[dcl.fct.def.general]
coroutine,
[dcl.fct.def.coroutine]
declaration as,
[dcl.pre]
function,
[dcl.fct.def]
deleted,
[dcl.fct.def.delete]
explicitly-defaulted,
[dcl.fct.def.default]
local class,
[class.local]
member function,
[class.mfct]
namespace,
[namespace.def]
nested class,
[class.nest]
program semantics affected by,
[temp.inst]
pure virtual function,
[class.abstract]
scope of class,
[class.name]
static member,
[class.static.data]
virtual function,
[class.virtual]
definition domain,
[basic.def.odr]
definitions,
[intro.defs]
delete
,
[lex.key]
,
[basic.stc.dynamic]
,
[expr.delete]
,
[dcl.fct.def.general]
,
[class.free]
,
[over.oper]
,
[temp.dep.expr]
,
[gram.expr]
,
[gram.dcl]
array,
[expr.delete]
destructor and,
[expr.delete]
,
[class.dtor]
operator
replaceable,
[replacement.functions]
overloading and,
[basic.stc.dynamic.deallocation]
single-object,
[expr.delete]
,
[expr.delete]
type of,
[class.free]
undefined,
[expr.delete]
deleter,
[unique.ptr]
denormalized value,
see
number, subnormal
dependency-ordered before,
[intro.races]
dependent base class,
see
base class, dependent
dependent member of the current instantiation,
see
current instantiation, dependent member of the
dependent name,
see
name, dependent
<deque>
,
[version.syn]
,
[sequences.general]
,
[deque.syn]
,
[iterator.range]
dereferenceable iterator,
see
iterator, dereferenceable
dereferencing,
see
indirection
derivation,
see
inheritance
derived class,
[class.derived]
most,
see
most derived class
derived object
most,
see
most derived object
destringization,
[cpp.pragma.op]
destroying operator delete,
see
operator delete, destroying
destruction,
[class.cdtor]
constant,
[expr.const]
dynamic cast and,
[class.cdtor]
member access,
[class.cdtor]
pointer to member or base,
[class.cdtor]
typeid
operator,
[class.cdtor]
virtual function call,
[class.cdtor]
destructor,
[class.dtor]
,
[class.dtor]
,
[functions.within.classes]
default,
[class.dtor]
exception handling,
see
exception handling, constructors and destructors
explicit call,
[class.dtor]
implicit call,
[class.dtor]
implicitly defined,
[class.dtor]
non-trivial,
[class.dtor]
program termination and,
[class.dtor]
prospective,
[class.dtor]
pure virtual,
[class.dtor]
selected,
[class.dtor]
union
,
[class.union]
virtual,
[class.dtor]
diagnosable rules,
[intro.compliance]
diagnostic message,
see
message, diagnostic
difference type,
[iterator.requirements.general]
digraph,
see
token, alternative
,
[lex.digraph]
direct base class,
see
base class, direct
direct member,
see
member, direct
direct-initialization,
[dcl.init]
direct-list-initialization,
[dcl.init.list]
direct-non-list-initialization,
[defns.direct-non-list-init]
directed acyclic graph,
see
DAG
directive, preprocessing,
see
preprocessing directive
directive-introducing token,
see
token, directive-introducing
directory,
[fs.general]
discard
random number engine requirement,
[rand.req.eng]
discard_block_engine
generation algorithm,
[rand.adapt.disc]
state,
[rand.adapt.disc]
textual representation,
[rand.adapt.disc]
transition algorithm,
[rand.adapt.disc]
discarded
declaration,
[module.global.frag]
discarded statement,
[stmt.if]
discarded-value expression,
[expr.context]
discrete probability function
bernoulli_distribution
,
[rand.dist.bern.bernoulli]
binomial_distribution
,
[rand.dist.bern.bin]
discrete_distribution
,
[rand.dist.samp.discrete]
geometric_distribution
,
[rand.dist.bern.geo]
negative_binomial_distribution
,
[rand.dist.bern.negbin]
poisson_distribution
,
[rand.dist.pois.poisson]
uniform_int_distribution
,
[rand.dist.uni.int]
discrete_distribution
discrete probability function,
[rand.dist.samp.discrete]
weights,
[rand.dist.samp.discrete]
disjunction,
[temp.constr.op]
disqualifying declaration,
see
declaration, disqualifying
disqualifying parameter,
see
parameter, disqualifying
distribution,
see
random number distribution
do
,
[lex.key]
,
[stmt.iter]
,
[gram.stmt]
dogs
obliviousness to interference,
[hardware.interference]
domain error,
[sf.cmath]
dominance
virtual base class,
[class.member.lookup]
dot
filename,
[fs.path.generic]
dot operator,
see
operator, class member access
dot-dot
filename,
[fs.path.generic]
double
,
[lex.key]
,
[lex.fcon]
,
[dcl.type.simple]
,
[gram.dcl]
dynamic binding,
see
function, virtual
dynamic initialization,
see
initialization, dynamic
dynamic type,
see
type, dynamic
dynamic_cast
,
[lex.key]
,
see
cast, dynamic
,
[expr.post]
,
[expr.const]
,
[temp.dep.expr]
,
[gram.expr]
E
E
(complete elliptic integrals),
[sf.cmath.comp.ellint.2]
E
(incomplete elliptic integrals),
[sf.cmath.ellint.2]
ECMA-262,
[intro.refs]
ECMAScript,
[re.synopt]
,
[re.grammar]
egrep
,
[re.synopt]
Ei
(exponential integrals),
[sf.cmath.expint]
elaborated type specifier,
see
class name, elaborated
element access functions,
[algorithms.parallel.defns]
element type,
[dcl.array]
eligible special member function,
see
special member function, eligible
eligible to be unblocked,
[atomics.wait]
elision
copy,
see
constructor, copy, elision
copy constructor,
see
constructor, copy, elision
move constructor,
see
constructor, move, elision
ellipsis
conversion sequence,
[expr.call]
,
[over.ics.ellipsis]
overload resolution and,
[over.match.viable]
elliptic integrals
complete
E
,
[sf.cmath.comp.ellint.2]
complete
K
,
[sf.cmath.comp.ellint.1]
complete
Π
,
[sf.cmath.comp.ellint.3]
incomplete
E
,
[sf.cmath.ellint.2]
incomplete
F
,
[sf.cmath.ellint.1]
incomplete
Π
,
[sf.cmath.ellint.3]
else
,
[lex.key]
,
[stmt.select]
,
[stmt.if]
,
[gram.stmt]
enclosing namespace set,
[namespace.def]
enclosing statement,
[stmt.pre]
encoded character type,
[fs.req]
encoding
multibyte,
[lex.string]
end-of-file,
[bitset.operators]
engine,
see
random number engine
engine adaptor,
see
random number engine adaptor
engines with predefined parameters
default_random_engine
,
[rand.predef]
knuth_b
,
[rand.predef]
minstd_rand
,
[rand.predef]
minstd_rand0
,
[rand.predef]
mt19937
,
[rand.predef]
mt19937_64
,
[rand.predef]
ranlux24
,
[rand.predef]
ranlux24_base
,
[rand.predef]
ranlux48
,
[rand.predef]
ranlux48_base
,
[rand.predef]
entity,
[basic.pre]
associated,
[basic.lookup.argdep]
implicitly movable,
[class.copy.elision]
local,
[basic.pre]
templated,
[temp.pre]
enum
,
[lex.key]
,
[basic.compound]
,
[dcl.type.elab]
,
[dcl.enum]
,
[gram.dcl]
overloading and,
[over.load]
type of,
[dcl.enum]
underlying type,
see
type, underlying
enum name
typedef
,
[dcl.typedef]
enumerated element,
[enumerated.types]
enumerated type,
see
type, enumerated
enumeration,
[dcl.enum]
linkage of,
[basic.link]
scoped,
[dcl.enum]
unscoped,
[dcl.enum]
using declaration,
[enum.udecl]
enumeration scope,
[basic.scope.enum]
,
[basic.scope.enum]
enumeration type
conversion to,
[expr.static.cast]
static_cast
conversion to,
[expr.static.cast]
enumerator
definition,
[basic.def.odr]
scoped,
[dcl.enum]
unscoped,
[dcl.enum]
value of,
[dcl.enum]
environment
program,
[basic.start.main]
epoch,
[time.clock.req]
equality operator function,
see
operator function, equality
equivalence
template type,
[temp.type]
type,
[dcl.typedef]
,
[class.name]
equivalent
expressions,
[temp.over.link]
function templates,
[temp.over.link]
functionally,
see
functionally equivalent
template-head
s,
[temp.over.link]
template-parameter
s,
[temp.over.link]
equivalent parameter declarations,
[over.load]
overloading and,
[over.load]
equivalent-key group,
[unord.req]
equivalently-valued,
[allocator.requirements]
<errno.h>
,
[errno]
,
[depr.c.headers]
escape character,
see
backslash character
escape sequence
format string,
[format.string.general]
undefined,
[lex.ccon]
Eulerian integral of the first kind,
see
beta
evaluation,
[intro.execution]
order of argument,
[expr.call]
signal-safe,
[support.signal]
unspecified order of,
[intro.execution]
,
[basic.start.dynamic]
unspecified order of argument,
[expr.call]
unspecified order of function call,
[expr.call]
<exception>
,
[version.syn]
,
[support.exception]
exception
arithmetic,
[expr.pre]
undefined arithmetic,
[expr.pre]
exception handling,
[except]
constructors and destructors,
[except.ctor]
currently handled exception,
[except.handle]
exception object,
[except.throw]
,
[except.throw]
constructor,
[except.throw]
destructor,
[except.throw]
function try block,
[except.pre]
goto
,
[except.pre]
handler,
[except.pre]
,
[except.throw]
,
[except.handle]
,
[res.on.exception.handling]
active,
[except.handle]
array in,
[except.handle]
incomplete type in,
[except.handle]
match,
[except.handle]
pointer to function in,
[except.handle]
rvalue reference in,
[except.handle]
memory,
[except.throw]
nearest handler,
[except.throw]
rethrow,
[expr.throw]
,
[except.throw]
rethrowing,
[except.throw]
switch
,
[except.pre]
terminate
called,
[expr.throw]
,
[except.throw]
,
[except.spec]
throwing,
[expr.throw]
,
[except.throw]
try block,
[except.pre]
exception object,
see
exception handling, exception object
exception specification,
[except.spec]
,
[except.spec]
noexcept
constant expression and,
[except.spec]
non-throwing,
[except.spec]
potentially-throwing,
[except.spec]
virtual function and,
[except.spec]
<execution>
,
[version.syn]
,
[execution.syn]
,
[execpol.objects]
,
[diff.cpp14.library]
execution agent,
[thread.req.lockable.general]
execution policy,
[execpol.general]
execution step,
[intro.progress]
exit
,
[basic.start.main]
,
[basic.start.term]
,
[stmt.jump]
explicit
,
[lex.key]
,
[dcl.fct.spec]
,
[gram.dcl]
explicit type conversion,
see
casting
explicit-specialization
,
[temp.expl.spec]
explicitly captured,
[expr.prim.lambda.capture]
explicitly initialized elements
aggregate,
[dcl.init.aggr]
exponential integrals
Ei
,
[sf.cmath.expint]
exponential_distribution
probability density function,
[rand.dist.pois.exp]
export
,
[lex.key]
,
[module.interface]
,
[cpp.pre]
,
[cpp.module]
,
[cpp.import]
,
[gram.module]
,
[gram.cpp]
exposure,
[basic.link]
expression,
[expr.pre]
additive operators,
[expr.add]
alignof
,
[expr.alignof]
assignment and compound assignment,
[expr.ass]
await,
[expr.await]
bitwise AND,
[expr.bit.and]
bitwise exclusive OR,
[expr.xor]
bitwise inclusive OR,
[expr.or]
cast,
[expr.type.conv]
,
[expr.cast]
class member access,
[expr.ref]
comma,
[expr.comma]
conditional operator,
[expr.cond]
const cast,
[expr.const.cast]
constant,
[expr.const]
,
[expr.const]
converted constant,
[expr.const]
core constant,
[expr.const]
decrement,
[expr.post.incr]
,
[expr.pre.incr]
delete
,
[expr.delete]
destructor call,
[expr.prim.id.dtor]
dynamic cast,
[expr.dynamic.cast]
equality operators,
[expr.eq]
equality-preserving,
[concepts.equality]
equivalent,
see
equivalent, expressions
fold,
[expr.prim.fold]
function call,
[expr.call]
functionally equivalent,
see
functionally equivalent, expressions
increment,
[expr.post.incr]
,
[expr.pre.incr]
integral constant,
[expr.const]
lambda,
[expr.prim.lambda]
left-shift-operator,
[expr.shift]
logical AND,
[expr.log.and]
logical OR,
[expr.log.or]
multiplicative operators,
[expr.mul]
new
,
[expr.new]
noexcept
,
[expr.unary.noexcept]
order of evaluation of,
[expr.pre]
parenthesized,
[expr.prim.paren]
pointer-to-member,
[expr.mptr.oper]
pointer-to-member constant,
[expr.unary.op]
postfix,
[expr.post]
potentially constant evaluated,
[expr.const]
potentially evaluated,
[basic.def.odr]
primary,
[expr.prim]
pseudo-destructor call,
[expr.prim.id.dtor]
reference,
[expr.type]
reinterpret cast,
[expr.reinterpret.cast]
relational operators,
[expr.rel]
requires,
[expr.prim.req]
right-shift-operator,
[expr.shift]
rvalue reference,
[basic.lval]
sizeof
,
[expr.sizeof]
spaceship,
[expr.spaceship]
static cast,
[expr.static.cast]
three-way comparison,
[expr.spaceship]
throw
,
[expr.throw]
type identification,
[expr.typeid]
type-dependent,
[temp.dep]
unary,
[expr.unary]
unary operator,
[expr.unary.op]
value-dependent,
[temp.dep]
yield,
[expr.yield]
expression-equivalent,
[defns.expression-equivalent]
extend,
see
namespace, extend
extended alignment,
see
alignment, extended
extended integer type,
[basic.fundamental]
extended signed integer type,
[basic.fundamental]
extended unsigned integer type,
[basic.fundamental]
extern
,
[lex.key]
,
[dcl.stc]
,
[dcl.link]
,
[temp.explicit]
,
[gram.dcl]
,
[gram.temp]
linkage of,
[dcl.stc]
extern "C"
,
[using.linkage]
,
[extern.names]
extern "C++"
,
[using.linkage]
,
[extern.names]
extern template
,
see
instantiation, explicit
external linkage,
see
linkage, external
extreme_value_distribution
probability density function,
[rand.dist.pois.extreme]
F
F
(incomplete elliptic integrals),
[sf.cmath.ellint.1]
facet,
[locale.facet]
false
,
[lex.key]
<fenv.h>
,
[cfenv.syn]
,
[depr.c.headers]
file,
[fs.general]
file attributes,
[fs.class.directory.entry]
cached,
[fs.class.directory.entry]
file system,
[fs.general]
file system race,
[fs.race.behavior]
file, source,
see
source file
filename,
[fs.path.generic]
<filesystem>
,
[version.syn]
,
[fs.filesystem.syn]
,
[diff.cpp14.library]
final
,
[lex.name]
,
[class.pre]
,
[class.mem]
,
[gram.class]
final overrider,
[class.virtual]
final suspend point,
[dcl.fct.def.coroutine]
finite state machine,
[defns.regex.collating.element]
fisher_f_distribution
probability density function,
[rand.dist.norm.f]
float
,
[lex.key]
,
[lex.fcon]
,
[dcl.type.simple]
,
[gram.dcl]
<float.h>
,
[cfloat.syn]
,
[depr.c.headers]
floating-point literal,
see
literal, floating-point
floating-point promotion,
[conv.fpprom]
floating-point type,
see
type, floating-point
implementation-defined,
[basic.fundamental]
fold
binary,
[expr.prim.fold]
unary,
[expr.prim.fold]
for
,
[lex.key]
,
[stmt.iter]
,
[stmt.for]
,
[stmt.ranged]
,
[gram.stmt]
scope of declaration in,
[stmt.for]
<format>
,
[version.syn]
,
[format.syn]
,
[diff.cpp17.library]
format specification
format string,
[format.string.general]
format specifier,
[defns.regex.finite.state.machine]
format string,
[format.string.general]
Formatter
,
[formatter.requirements]
forward
,
[forward]
forward progress guarantees
concurrent,
[intro.progress]
delegation of,
[intro.progress]
parallel,
[intro.progress]
weakly parallel,
[intro.progress]
<forward_list>
,
[version.syn]
,
[sequences.general]
,
[forward.list.syn]
,
[iterator.range]
,
[diff.cpp03.library]
forwarding reference,
[temp.deduct.call]
free store,
see also
new
,
see also
delete
,
[class.free]
freestanding implementation,
[intro.compliance]
friend
,
[lex.key]
,
[dcl.spec]
,
[dcl.type.elab]
,
[class.friend]
,
[gram.dcl]
access specifier and,
[class.friend]
class access and,
[class.friend]
inheritance and,
[class.friend]
local class and,
[class.friend]
template and,
[temp.friend]
virtual
and,
[class.virtual]
friend function
access and,
[class.friend]
inline,
[class.friend]
linkage of,
[class.friend]
member function and,
[class.friend]
nested class,
[class.nest]
<fstream>
,
[fstream.syn]
,
[fs.op.status]
full-expression,
[intro.execution]
function,
see also
friend function; member function; inline function; virtual function
addressable,
[namespace.std]
allocation,
[basic.stc.dynamic.allocation]
,
[expr.new]
comparison,
[defns.comparison]
conversion,
[class.conv.fct]
deallocation,
[basic.stc.dynamic.deallocation]
,
[class.free]
deferred,
[futures.async]
definition,
[basic.def.odr]
global,
[extern.names]
,
[res.on.macro.definitions]
handler,
[defns.handler]
handler of type,
[except.handle]
immediate,
[dcl.constexpr]
inline,
[dcl.inline]
linkage specification overloaded,
[dcl.link]
modifier,
[defns.modifier]
named by expression or conversion,
[basic.def.odr]
needed for constant evaluation,
[expr.const]
observer,
[defns.observer]
operator,
[over.oper]
template,
[over.oper]
overload resolution and,
[over.match.funcs]
overloaded,
see
overloading
overloading and pointer versus,
[over.load]
parameter of type,
[dcl.fct]
pointer to member,
[expr.mptr.oper]
program semantics affected by the existence of a function definition,
[temp.inst]
replacement,
[defns.replacement]
reserved,
[defns.reserved.function]
template parameter of type,
[temp.param]
viable,
[over.match]
virtual,
[class.virtual]
,
[class.virtual]
pure,
[class.abstract]
,
[class.abstract]
virtual function call,
[expr.call]
virtual member,
[derived.classes]
waiting,
[futures.state]
function argument,
see
argument
function call,
[expr.call]
recursive,
[expr.call]
undefined,
[expr.reinterpret.cast]
function call operator
overloaded,
[over.call]
function call operator function,
see
operator function, function call
function object,
[function.objects]
binders,
[func.bind]
mem_fn
,
[func.memfn]
reference_wrapper
,
[refwrap]
type,
[function.objects]
wrapper,
[func.wrap]
function parameter,
see
parameter
function parameter pack,
[temp.variadic]
function parameter scope,
[basic.scope.param]
function pointer type,
[basic.compound]
function return,
see
return
function return type,
see
return type
function try block,
see
exception handling, function try block
function-definition
,
[dcl.fct.def.general]
function-like macro,
see
macro, function-like
function-local predefined variable,
see
variable, function-local predefined
<functional>
,
[version.syn]
,
[functional.syn]
functionally equivalent
expressions,
[temp.over.link]
function templates,
[temp.over.link]
template-head
s,
[temp.over.link]
functions
candidate,
[temp.dep.candidate]
fundamental alignment,
see
alignment, fundamental
fundamental type,
[basic.fundamental]
destructor and,
[class.dtor]
fundamental type conversion,
see
conversion, user-defined
<future>
,
[future.syn]
,
[diff.cpp03.library]
future
shared state,
[futures.state]
G
gamma_distribution
probability density function,
[rand.dist.pois.gamma]
generate
seed sequence requirement,
[rand.req.seedseq]
generated destructor,
see
destructor, default
generation algorithm
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
generic lambda,
[expr.prim.lambda]
generic parameter type placeholder,
[dcl.spec.auto]
geometric_distribution
discrete probability function,
[rand.dist.bern.geo]
global module,
see
module, global
global module fragment,
[module.global.frag]
global name,
see
name, global
global namespace,
see
namespace, global
global namespace scope,
see
namespace scope, global
global scope,
see
scope, global
glvalue,
[basic.lval]
goto
,
[lex.key]
,
[stmt.while]
,
[stmt.jump]
,
[gram.stmt]
and handler,
[except.pre]
and try block,
[except.pre]
initialization and,
[stmt.dcl]
grammar,
[gram]
regular expression,
[re.grammar]
grep
,
[re.synopt]
H
H
n
(Hermite polynomials),
[sf.cmath.hermite]
handler,
see
exception handling, handler
happens after,
[intro.races]
happens before,
[intro.races]
hard link,
[fs.general]
hash
instantiation restrictions,
[unord.hash]
hash code,
[unord.req]
hash function,
[unord.req]
hash tables,
see
unordered associative containers
header,
[headers]
C,
[extern.names]
,
[res.on.macro.definitions]
,
[depr.c.headers.other]
C library,
[using.linkage]
C++ library,
[headers]
importable,
[module.import]
name,
[lex.header]
header unit,
[module.import]
preprocessing,
[cpp.import]
headers
C library,
[depr.c.headers]
heap with respect to
comp
and
proj
,
[alg.heap.operations]
Hermite polynomials
H
n
,
[sf.cmath.hermite]
hiding,
see
name hiding
high-order bit,
[intro.memory]
hosted implementation,
[intro.compliance]
I
I
ν
(Bessell functions),
[sf.cmath.cyl.bessel.i]
id
qualified,
[expr.prim.id.qual]
id-expression,
[expr.prim.id]
identical
atomic constraints,
see
atomic constraint, identical
identifier,
[lex.name]
,
[expr.prim.id.unqual]
,
[dcl.pre]
identifier label,
[stmt.label]
if
,
[lex.key]
,
[stmt.select]
,
[stmt.if]
,
[stmt.while]
,
[gram.stmt]
ill-formed program,
see
program, ill-formed
immediate function,
see
function, immediate
immediate function context,
[expr.const]
immediate invocation,
[expr.const]
immediate subexpression,
[intro.execution]
implementation
freestanding,
[compliance]
,
[compliance]
hosted,
[compliance]
implementation limits,
see
limits, implementation
implementation-defined behavior,
see
behavior, implementation-defined
implementation-dependent,
[temp.explicit]
,
[support.limits.general]
,
[istream.sentry]
,
[ostream.sentry]
implementation-generated,
[basic.def]
implicit conversion,
see
conversion, implicit
implicit conversion sequence,
see
conversion sequence, implicit
implicit object parameter,
[over.match.funcs]
implicit-lifetime class,
see
class, implicit-lifetime
implicit-lifetime type,
see
type, implicit-lifetime
implicitly movable entity,
see
entity, implicitly movable
implicitly-declared default constructor,
see
constructor, default
,
[class.default.ctor]
implied object argument,
[over.match.funcs]
implicit conversion sequences,
[over.match.funcs]
non-static member function and,
[over.match.funcs]
import
,
[lex.name]
,
[module.import]
,
[cpp.pre]
,
[cpp.import]
,
[using.headers]
,
[gram.cpp]
importable C++ library headers,
see
C++ library headers, importable
importable header,
see
header, importable
inclusion
conditional,
see
preprocessing directive, conditional inclusion
source file,
see
preprocessing directives, source-file inclusion
incomplete,
[expr.add]
incompletely-defined object type,
see
object type, incompletely-defined
increment operator
overloaded,
see
overloading, increment operator
increment operator function,
see
operator function, increment
incrementable,
[iterator.concept.winc]
independent_bits_engine
generation algorithm,
[rand.adapt.ibits]
state,
[rand.adapt.ibits]
textual representation,
[rand.adapt.ibits]
transition algorithm,
[rand.adapt.ibits]
indeterminate value,
[basic.indet]
,
see
value, indeterminate
indeterminately sequenced,
[intro.execution]
indirect base class,
see
base class, indirect
indirection,
[expr.unary.op]
inheritance,
[class.derived]
,
[class.derived]
using-declaration
and,
[namespace.udecl]
init-capture
pack,
[expr.prim.lambda.capture]
,
[temp.variadic]
initial suspend point,
[dcl.fct.def.coroutine]
initialization,
[basic.start.static]
,
[dcl.init]
aggregate,
[dcl.init.aggr]
array,
[dcl.init.aggr]
array of class objects,
[dcl.init.aggr]
,
[class.expl.init]
automatic,
[stmt.dcl]
base class,
[class.base.init]
by inherited constructor,
[class.inhctor.init]
character array,
[dcl.init.string]
class member,
[dcl.init]
class object,
see also
constructor
,
[dcl.init.aggr]
,
[class.init]
const
,
[dcl.type.cv]
,
[dcl.init]
const member,
[class.base.init]
constant,
[basic.start.static]
constructor and,
[class.init]
,
[class.expl.init]
copy,
[dcl.init]
default,
[dcl.init]
default constructor and,
[class.init]
definition and,
[dcl.pre]
direct,
[dcl.init]
dynamic,
[basic.start.static]
dynamic block-scope,
[stmt.dcl]
dynamic non-local,
[basic.start.dynamic]
explicit,
[class.expl.init]
jump past,
[stmt.dcl]
list-initialization,
[dcl.init.list]
local
static
,
[stmt.dcl]
local
thread_local
,
[stmt.dcl]
member,
[class.base.init]
member function call during,
[class.base.init]
member object,
[class.base.init]
order of,
[basic.start.dynamic]
,
[class.mi]
order of base class,
[class.base.init]
order of member,
[class.base.init]
order of virtual base class,
[class.base.init]
overloaded assignment and,
[class.expl.init]
parameter,
[expr.call]
reference,
[dcl.ref]
,
[dcl.init.ref]
reference member,
[class.base.init]
static,
[basic.start.static]
static and thread,
[basic.start.static]
static member,
[class.static.data]
union
,
[dcl.init.aggr]
,
[class.union.anon]
vacuous,
[basic.life]
virtual base class,
[class.copy.ctor]
zero-initialization,
[basic.start.static]
,
[dcl.init]
initializer
base class,
[dcl.fct.def.general]
member,
[dcl.fct.def.general]
pack expansion,
[class.base.init]
scope of member,
[class.base.init]
temporary and declarator,
[class.temporary]
initializer-list constructor,
[dcl.init.list]
seed sequence requirement,
[rand.req.seedseq]
<initializer_list>
,
[support.initlist]
,
[diff.cpp03.library]
initializing declaration,
[dcl.init]
injected-class-name,
[class.pre]
inline
,
[lex.key]
,
[dcl.spec]
,
[namespace.def]
,
[namespace.unnamed]
,
[res.on.macro.definitions]
,
[gram.dcl]
linkage of,
[basic.link]
inline function,
[dcl.inline]
,
see
function, inline
inline namespace,
see
namespace, inline
inline namespace set,
[namespace.def]
inline variable,
see
variable, inline
instantiation
explicit,
[temp.explicit]
point of,
[temp.point]
template implicit,
[temp.inst]
instantiation context,
[module.context]
instantiation units,
[lex.phases]
int
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
integer literal,
see
literal, integer
integer representation,
[basic.stc.dynamic.safety]
integer type,
[basic.fundamental]
integer-class type,
see
type, integer-class
integer-like,
[iterator.concept.winc]
integral constant expression,
see
expression, integral constant
integral promotion,
[conv.prom]
integral type,
[basic.fundamental]
implementation-defined
sizeof
,
[basic.fundamental]
inter-thread happens before,
[intro.races]
interface dependency,
[module.import]
internal linkage,
see
linkage, internal
interval boundaries
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
<inttypes.h>
,
[cinttypes.syn]
,
[depr.c.headers]
invalid iterator,
see
iterator, invalid
invalid pointer value,
see
value, invalid pointer
invocation
macro,
[cpp.replace]
<iomanip>
,
[version.syn]
,
[iomanip.syn]
,
[std.manip]
,
[ext.manip]
<ios>
,
[ios.syn]
<iosfwd>
,
[iosfwd.syn]
<iostream>
,
[temp.res]
,
[iostream.syn]
,
[iostream.objects.overview]
,
[ios.init]
isctype
regular expression traits,
[re.req]
<iso646.h>
,
[headers]
,
[diff.header.iso646.h]
,
[depr.c.headers]
,
[depr.iso646.h.syn]
,
[depr.c.headers.other]
<istream>
,
[version.syn]
,
[istream.syn]
,
[input.streams]
iteration-statement
,
[stmt.break]
,
[stmt.cont]
<iterator>
,
[version.syn]
,
[iterator.synopsis]
,
[iterator.range]
,
[range.access]
,
[depr.iterator.basic]
iterator,
[iterator.requirements.general]
constexpr,
[iterator.requirements.general]
dereferenceable,
[iterator.requirements.general]
invalid,
[iterator.requirements.general]
past-the-end,
[iterator.requirements.general]
J
j
n
(spherical Bessel functions),
[sf.cmath.sph.bessel]
J
ν
(Bessell functions),
[sf.cmath.cyl.bessel.j]
Jessie,
[class.conv.ctor]
K
K
(complete elliptic integrals),
[sf.cmath.comp.ellint.1]
K
ν
(Bessell functions),
[sf.cmath.cyl.bessel.k]
key parameter,
see
parameter, key
keyword,
[lex.key]
,
[gram.key]
L
L
n
(Laguerre polynomials),
[sf.cmath.laguerre]
L
m
n
(associated Laguerre polynomials),
[sf.cmath.assoc.laguerre]
label,
[stmt.goto]
case
,
[stmt.label]
,
[stmt.switch]
default
,
[stmt.label]
,
[stmt.switch]
scope of,
[basic.funscope]
,
[stmt.label]
Laguerre polynomials
L
n
,
[sf.cmath.laguerre]
L
m
n
,
[sf.cmath.assoc.laguerre]
lambda-introducer
,
[dcl.type.simple]
language linkage,
[dcl.link]
<latch>
,
[version.syn]
,
[latch.syn]
,
[diff.cpp17.library]
lattice,
see
DAG, subobject
layout
bit-field,
[class.bit]
class object,
[class.mem]
,
[class.mi]
layout-compatible,
[basic.types]
class,
[class.mem]
enumeration,
[dcl.enum]
layout-compatible type,
[basic.types]
left shift
undefined,
[expr.shift]
left shift operator,
see
operator, left shift
left-pad,
[format.context]
Legendre functions
Y
ℓ
m
,
[sf.cmath.sph.legendre]
Legendre polynomials
P
ℓ
,
[sf.cmath.legendre]
P
ℓ
m
,
[sf.cmath.assoc.legendre]
letter,
[character.seq]
lexical conventions,
see
conventions, lexical
library
C standard,
[library.c]
,
[character.seq]
,
[headers]
,
[using.linkage]
,
[diff.library]
,
[diff.mods.to.headers]
,
[depr.c.headers]
C++ standard,
[derived.classes]
,
[replacement.functions]
,
[res.on.arguments]
,
[derivation]
,
[res.on.exception.handling]
,
[library.general]
library clauses,
[intro.structure]
lifetime,
[basic.life]
<limits>
,
[support.limits.general]
,
[version.syn]
,
[limits.syn]
limits
implementation,
[defns.impl.limits]
<limits.h>
,
[climits.syn]
,
[depr.c.headers]
line number,
[cpp.line]
line splicing,
[lex.phases]
linear_congruential_engine
generation algorithm,
[rand.eng.lcong]
modulus,
[rand.eng.lcong]
state,
[rand.eng.lcong]
textual representation,
[rand.eng.lcong]
transition algorithm,
[rand.eng.lcong]
link,
[fs.general]
linkage,
[basic.pre]
,
[basic.link]
,
[basic.link]
const
and,
[basic.link]
external,
[basic.link]
,
[using.linkage]
,
[extern.names]
implementation-defined object,
[dcl.link]
inline
and,
[basic.link]
internal,
[basic.link]
module,
[basic.link]
no,
[basic.link]
static
and,
[basic.link]
linkage specification,
see
specification, linkage
linkage-specification
,
[dcl.link]
<list>
,
[version.syn]
,
[sequences.general]
,
[list.syn]
,
[iterator.range]
list-initialization,
[dcl.init.list]
literal,
[lex.literal]
,
[expr.prim.literal]
base of integer,
[lex.icon]
boolean,
[lex.bool]
char16_t
,
[lex.ccon]
char32_t
,
[lex.ccon]
character,
[lex.ccon]
ordinary,
[lex.ccon]
UTF-16,
[lex.ccon]
UTF-32,
[lex.ccon]
UTF-8,
[lex.ccon]
wide,
[lex.ccon]
complex,
[complex.literals]
constant,
[lex.literal.kinds]
float
,
[lex.fcon]
floating-point,
[lex.fcon]
implementation-defined value of
char
,
[lex.ccon]
integer,
[lex.icon]
long
,
[lex.icon]
long double
,
[lex.fcon]
multicharacter,
[lex.ccon]
implementation-defined value of,
[lex.ccon]
narrow-character,
[lex.string]
operator,
[over.literal]
raw,
[over.literal]
template,
[over.literal]
template numeric,
[over.literal]
template string,
[over.literal]
pointer,
[lex.nullptr]
string,
[lex.string]
char16_t
,
[lex.string]
char32_t
,
[lex.string]
narrow,
[lex.string]
raw,
[lex.pptoken]
,
[lex.string]
undefined change to,
[lex.string]
UTF-16,
[lex.string]
UTF-32,
[lex.string]
UTF-8,
[lex.string]
wide,
[lex.string]
suffix identifier,
[over.literal]
type of character,
[lex.ccon]
type of floating-point,
[lex.fcon]
type of integer,
[lex.icon]
unsigned
,
[lex.icon]
user-defined,
[lex.ext]
literal type,
see
type, literal
living dead
name of,
[zombie.names]
local class,
see
class, local
friend,
[class.friend]
member function in,
[class.mfct]
scope of,
[class.local]
local entity,
see
entity, local
local scope,
see
block scope
local variable,
see
variable, local
destruction of,
[stmt.jump]
,
[stmt.dcl]
local_iterator
,
[unord.req]
<locale>
,
[version.syn]
,
[locale.syn]
,
[depr.conversions]
locale,
[re.def]
,
[defns.regex.matched]
,
[re.req]
,
[re.synopt]
locale-specific behavior,
see
behavior, locale-specific
locale-specific form
format string,
[format.string.std]
<locale.h>
,
[clocale.syn]
,
[depr.c.headers]
lock-free execution,
[intro.progress]
lognormal_distribution
probability density function,
[rand.dist.norm.lognormal]
long
,
[lex.key]
,
[lex.fcon]
,
[dcl.type.simple]
,
[gram.dcl]
typedef
and,
[dcl.spec]
lookup
argument-dependent,
[basic.lookup.argdep]
class member,
[class.qual]
,
[basic.lookup.classref]
elaborated type specifier,
[basic.lookup.elab]
member name,
[class.member.lookup]
name,
[basic.lookup]
,
[basic.pre]
namespace aliases and,
[basic.lookup.udir]
namespace member,
[namespace.qual]
qualified name,
[basic.lookup.qual]
template name,
[temp.res]
unqualified name,
[basic.lookup.unqual]
using-directives and,
[basic.lookup.udir]
lookup_classname
regular expression traits,
[re.req]
,
[re.grammar]
lookup_collatename
regular expression traits,
[re.req]
low-order bit,
[intro.memory]
lowercase,
[character.seq]
lvalue,
[basic.lval]
,
[diff.expr]
lvalue reference,
[dcl.ref]
Lvalue-Callable,
[func.wrap.func]
M
macro
active,
[cpp.import]
argument substitution,
[cpp.subst]
definition,
[cpp.import]
function-like,
[cpp.replace]
,
[cpp.replace]
arguments,
[cpp.replace]
import,
[cpp.import]
masking,
[res.on.macro.definitions]
name,
[cpp.replace]
object-like,
[cpp.replace]
,
[cpp.replace]
point of definition,
[cpp.import]
point of import,
[cpp.import]
point of undefinition,
[cpp.import]
pragma operator,
[cpp.pragma.op]
predefined,
[cpp.predefined]
replacement,
[cpp.replace]
replacement list,
[cpp.replace]
rescanning and replacement,
[cpp.rescan]
scope of definition,
[cpp.scope]
main
function,
[basic.start.main]
implementation-defined linkage of,
[basic.start.main]
implementation-defined parameters to,
[basic.start.main]
parameters to,
[basic.start.main]
return from,
[basic.start.main]
,
[basic.start.term]
make progress
thread,
[intro.progress]
make-unsigned-like-t
,
[ranges.syn]
manifestly constant-evaluated,
[expr.const]
<map>
,
[version.syn]
,
[associative.general]
,
[associative.map.syn]
,
[iterator.range]
match_results
as sequence,
[re.results]
matched,
[defns.regex.format.specifier]
<math.h>
,
[cmath.syn]
,
[depr.c.headers]
mathematical special functions,
[sf.cmath]
max
random number distribution requirement,
[rand.req.dist]
mean
normal_distribution
,
[rand.dist.norm.normal]
poisson_distribution
,
[rand.dist.pois.poisson]
member
class
static
,
[basic.stc.static]
default initializer,
[class.mem]
direct,
[class.mem]
enumerator,
[dcl.enum]
static,
[class.static]
,
[class.mem]
template and
static
,
[temp.static]
member access operator
overloaded,
[over.ref]
member candidate,
[over.match.oper]
member data
static,
[class.static.data]
member function,
[class.mem]
call undefined,
[class.mfct.non-static]
class,
[class.mfct]
const,
[class.mfct.non-static]
const volatile,
[class.mfct.non-static]
constexpr-compatible,
[special]
constructor and,
[class.ctor]
destructor and,
[class.dtor]
friend,
[class.friend]
inline,
[class.mfct]
local class,
[class.local]
nested class,
[class.access.nest]
non-static,
[class.mfct.non-static]
overload resolution and,
[over.match.funcs]
static,
[class.static.mfct]
,
[class.mem]
this
,
[class.this]
union
,
[class.union]
volatile,
[class.mfct.non-static]
member names,
[basic.scope.namespace]
member of an unknown specialization,
[temp.dep.type]
member of the current instantiation,
see
current instantiation, member of the
member pointer to,
see
pointer to member
member subobject,
[intro.object]
members,
[basic.scope.namespace]
<memory>
,
[version.syn]
,
[memory.general]
,
[memory.syn]
,
[specialized.algorithms]
,
[depr.util.smartptr.shared.atomic]
memory location,
[intro.memory]
memory management,
see
new
,
see
delete
memory model,
[intro.memory]
<memory_resource>
,
[version.syn]
,
[mem.res.syn]
,
[diff.cpp14.library]
mersenne_twister_engine
generation algorithm,
[rand.eng.mers]
state,
[rand.eng.mers]
textual representation,
[rand.eng.mers]
transition algorithm,
[rand.eng.mers]
message
diagnostic,
[defns.diagnostic]
,
[intro.compliance]
min
random number distribution requirement,
[rand.req.dist]
model
concept,
[res.on.requirements]
modifiable,
[basic.lval]
modification order,
[intro.races]
module
,
[lex.name]
,
[module.unit]
,
[cpp.pre]
,
[cpp.module]
,
[gram.cpp]
exported,
[module.import]
global,
[module.unit]
named,
[module.unit]
reserved name of,
[module.unit]
module implementation unit,
[module.unit]
module interface unit,
[module.unit]
module partition,
[module.unit]
module unit,
[module.unit]
module unit purview,
see
purview, module unit
more constrained,
[temp.constr.order]
more cv-qualified,
[basic.type.qualifier]
more specialized
class template,
[temp.class.order]
function template,
[temp.deduct.partial]
most derived class,
[intro.object]
most derived object,
[intro.object]
bit-field,
[intro.object]
zero size subobject,
[intro.object]
move,
[forward]
class object,
see
constructor, move
,
see
assignment operator, move
multi-pass guarantee,
[iterator.concept.forward]
,
[forward.iterators]
multibyte character,
see
character, multibyte
multibyte encoding,
see
encoding, multibyte
multicharacter literal,
see
literal, multicharacter
multiline
,
[re.synopt]
multiple inheritance,
[class.derived]
,
[class.mi]
virtual
and,
[class.virtual]
multiple threads,
see
threads, multiple
mutable
,
[lex.key]
,
[dcl.stc]
,
[gram.dcl]
mutable iterator,
[iterator.requirements.general]
<mutex>
,
[version.syn]
,
[mutex.syn]
,
[diff.cpp03.library]
mutex types,
[thread.mutex.requirements.mutex]
N
n
n
(spherical Neumann functions),
[sf.cmath.sph.neumann]
N
ν
(Neumann functions),
[sf.cmath.cyl.neumann]
name,
[lex.name]
,
[basic.pre]
,
[basic.link]
,
[expr.prim.id]
address of cv-qualified,
[expr.unary.op]
dependent,
[temp.dep]
elaborated
enum
,
[dcl.type.elab]
exported,
[module.interface]
global,
[basic.scope.namespace]
length of,
[lex.name]
macro,
see
macro, name
point of declaration,
see
declaration, point of
predefined macro,
see
macro, predefined
qualified,
[basic.lookup.qual]
reserved,
[reserved.names]
same,
[basic.pre]
scope of,
[basic.scope.declarative]
unqualified,
[basic.lookup.unqual]
zombie,
[zombie.names]
name class,
see
class name
name hiding,
[basic.scope.pdecl]
,
[basic.scope.hiding]
,
[expr.prim.id.qual]
,
[stmt.dcl]
class definition,
[class.name]
function,
[over.dcl]
overloading versus,
[over.dcl]
user-defined conversion and,
[class.conv]
using-declaration and,
[namespace.udecl]
name space
label,
[stmt.label]
named module,
see
module, named
namespace,
[lex.key]
,
[namespace.def]
,
[namespace.unnamed]
,
[namespace.alias]
,
[namespace.udir]
,
[contents]
,
[gram.dcl]
alias,
[namespace.alias]
associated,
[basic.lookup.argdep]
definition,
[namespace.def]
enclosing,
[namespace.def]
extend,
[namespace.def]
global,
[lex.name]
,
[basic.scope.namespace]
inline,
[namespace.def]
member definition,
[namespace.memdef]
unnamed,
[namespace.unnamed]
namespace scope
global,
[basic.scope.namespace]
namespaces,
[basic.namespace]
NaN,
[sf.cmath]
narrow character type,
[basic.fundamental]
narrowing conversion,
[dcl.init.list]
native encoding,
[fs.path.type.cvt]
native pathname format,
[fs.class.path]
NDEBUG
,
[using.headers]
necessarily reachable,
see
reachable, necessarily
needed
exception specification,
[except.spec]
needed for constant evaluation,
[expr.const]
negative_binomial_distribution
discrete probability function,
[rand.dist.bern.negbin]
nested class,
see
class, nested
local class,
[class.local]
scope of,
[class.nest]
nested within,
[intro.object]
Neumann functions
n
n
,
[sf.cmath.sph.neumann]
N
ν
,
[sf.cmath.cyl.neumann]
<new>
,
[basic.stc.dynamic]
,
[version.syn]
,
[support.dynamic]
new
,
[lex.key]
,
[basic.stc.dynamic]
,
[expr.new]
,
[over.oper]
,
[temp.dep.expr]
,
[gram.expr]
array of class objects and,
[expr.new]
constructor and,
[expr.new]
default constructor and,
[expr.new]
exception and,
[expr.new]
initialization and,
[expr.new]
operator
replaceable,
[replacement.functions]
scoping and,
[expr.new]
storage allocation,
[expr.new]
type of,
[class.free]
unspecified constructor and,
[expr.new]
unspecified order of evaluation,
[expr.new]
new-expression
placement,
[expr.new]
new-extended alignment,
see
alignment, new-extended
new_handler
,
[basic.stc.dynamic.allocation]
no linkage,
[basic.link]
node handle,
[container.node.overview]
nodiscard call,
see
call, nodiscard
nodiscard type,
see
type, nodiscard
noexcept
,
[lex.key]
,
[expr.prim.req.compound]
,
[expr.unary.noexcept]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
non-initialization odr-use,
see
odr-use, non-initialization
non-member candidate,
[over.match.oper]
non-static data member,
[class.mem]
non-static member,
[class.mem]
non-static member function,
[class.mem]
non-throwing exception specification,
[except.spec]
non-virtual base class,
see
base class, non-virtual
normal distributions,
[rand.dist.norm]
normal form
constraint,
[temp.constr.normal]
path,
[fs.path.generic]
normal_distribution
mean,
[rand.dist.norm.normal]
probability density function,
[rand.dist.norm.normal]
standard deviation,
[rand.dist.norm.normal]
normalization,
see
constraint, normalization
path,
[fs.path.generic]
normative references,
see
references, normative
not
,
[lex.key]
not_eq
,
[lex.key]
notation
syntax,
[syntax]
ntbs
,
[byte.strings]
,
[depr.istrstream.cons]
,
[depr.ostrstream.cons]
empty,
[byte.strings]
length,
[byte.strings]
static,
[byte.strings]
value,
[byte.strings]
NTCTS,
[defns.ntcts]
ntmbs
,
[multibyte.strings]
static,
[multibyte.strings]
null character,
see
character, null
null member pointer conversion,
see
conversion, null member pointer
null pointer conversion,
see
conversion, null pointer
null pointer value,
see
value, null pointer
null statement,
[stmt.expr]
null wide character,
see
wide-character, null
nullptr
,
[lex.key]
number
hex,
[lex.ccon]
octal,
[lex.ccon]
preprocessing,
[lex.ppnumber]
subnormal,
[denorm.style]
,
[numeric.limits.members]
<numbers>
,
[version.syn]
,
[numbers.syn]
,
[diff.cpp17.library]
<numeric>
,
[version.syn]
,
[numeric.ops.overview]
numeric type,
see
type, numeric
numeric_limits
,
[limits.syn]
specializations for arithmetic types,
[basic.fundamental]
O
object,
see also
object model
,
[basic.pre]
,
[intro.object]
byte copying and,
[basic.types]
callable,
[func.def]
complete,
[intro.object]
const,
[basic.type.qualifier]
const volatile,
[basic.type.qualifier]
definition,
[basic.def.odr]
destructor and placement of,
[class.dtor]
destructor static,
[basic.start.term]
exception,
see
exception handling, exception object
implicit creation,
[intro.object]
linkage specification,
[dcl.link]
local
static
,
[basic.stc.static]
nested within,
[intro.object]
nonzero size,
[intro.object]
providing storage for,
[intro.object]
reified,
[range.access]
suitable created,
[intro.object]
unnamed,
[class.ctor]
volatile,
[basic.type.qualifier]
zero size,
[intro.object]
object class,
see
class object
object expression,
[expr.ref]
,
[expr.mptr.oper]
object lifetime,
[basic.life]
object model,
[intro.object]
object pointer type,
[basic.compound]
object temporary,
see
temporary
object type,
[basic.types]
incompletely-defined,
[basic.types]
object-like macro,
see
macro, object-like
observable behavior,
see
behavior, observable
odr-usable,
[basic.def.odr]
odr-use,
[basic.def.odr]
non-initialization,
[basic.start.dynamic]
one-definition rule,
[basic.def.odr]
operating system dependent,
[fs.conform.os]
operator
,
[lex.key]
,
[lex.operators]
,
[class.conv.fct]
,
[over.call.object]
,
[over.match.oper]
,
[over.match.best]
,
[over.best.ics]
,
[over.ics.rank]
,
[over.oper]
,
[over.unary]
,
[over.binary]
,
[over.ass]
,
[over.call]
,
[over.sub]
,
[over.ref]
,
[over.inc]
,
[over.literal]
,
[gram.class]
,
[gram.over]
%=
,
[expr.ass]
&=
,
[expr.ass]
*=
,
[expr.ass]
+=
,
[expr.pre.incr]
,
[expr.ass]
-=
,
[expr.ass]
/=
,
[expr.ass]
<<=
,
[expr.ass]
>>=
,
[expr.ass]
^=
,
[expr.ass]
|=
,
[expr.ass]
addition,
[expr.add]
additive,
[expr.add]
address-of,
[expr.unary]
assignment,
[expr.ass]
,
[functions.within.classes]
bitwise,
[expr.bit.and]
bitwise AND,
[expr.bit.and]
bitwise exclusive OR,
[expr.xor]
bitwise inclusive OR,
[expr.or]
cast,
[expr.unary]
,
[dcl.name]
class member access,
[expr.ref]
comma,
[expr.comma]
comparison
constexpr-compatible,
[class.compare.default]
implicitly defined,
[class.compare.default]
secondary,
[class.compare.secondary]
conditional expression,
[expr.cond]
copy assignment,
see
assignment operator, copy
decrement,
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
division,
[expr.mul]
equality,
[expr.eq]
defaulted,
[class.eq]
deleted,
[class.compare.default]
function call,
[expr.call]
,
[over.oper]
greater than,
[expr.rel]
greater than or equal to,
[expr.rel]
implementation,
[over.oper]
increment,
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
indirection,
[expr.unary]
inequality,
[expr.eq]
defaulted,
[class.compare.secondary]
left shift,
[expr.shift]
less than,
[expr.rel]
less than or equal to,
[expr.rel]
logical AND,
[expr.log.and]
logical negation,
[expr.unary]
,
[expr.unary.op]
logical OR,
[expr.log.or]
move assignment,
see
assignment operator, move
multiplication,
[expr.mul]
multiplicative,
[expr.mul]
ones' complement,
[expr.unary]
,
[expr.unary.op]
overloaded,
[expr.pre]
,
[over.oper]
pointer to member,
[expr.mptr.oper]
pragma,
see
macro, pragma operator
precedence of,
[expr.pre]
relational,
[expr.rel]
defaulted,
[class.compare.secondary]
remainder,
[expr.mul]
right shift,
[expr.shift]
scope resolution,
[basic.lookup.qual]
,
[expr.prim.id.qual]
,
[expr.new]
,
[class.mfct]
,
[class.derived]
,
[class.virtual]
side effects and comma,
[expr.comma]
side effects and logical AND,
[expr.log.and]
side effects and logical OR,
[expr.log.or]
sizeof
,
[expr.unary]
,
[expr.sizeof]
spaceship,
[expr.spaceship]
subscripting,
[expr.sub]
,
[over.oper]
subtraction,
[expr.add]
three-way comparison,
[expr.spaceship]
defaulted,
[class.spaceship]
deleted,
[class.compare.default]
unary,
[expr.unary]
,
[expr.unary.op]
unary minus,
[expr.unary]
,
[expr.unary.op]
unary plus,
[expr.unary]
,
[expr.unary.op]
operator delete,
see also
delete
,
[expr.new]
,
[expr.delete]
,
[class.free]
destroying,
[basic.stc.dynamic.deallocation]
operator function
binary,
[over.binary]
class member access,
[over.ref]
comparison,
[over.binary]
decrement,
[over.inc]
equality,
[over.binary]
function call,
[over.call]
increment,
[over.inc]
prefix unary,
[over.unary]
relational,
[over.binary]
simple assignment,
[over.ass]
subscripting,
[over.sub]
three-way comparison,
[over.binary]
operator new
,
see also
new
,
[expr.new]
operator overloading,
see
overloading, operator
operator use
scope resolution,
[class.static.data]
operator!=
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
operator()
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
operator<<
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
operator==
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
operator>>
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
operators
built-in,
[expr.pre]
optimization of temporary,
see
temporary, elimination of
<optional>
,
[version.syn]
,
[optional.syn]
,
[diff.cpp14.library]
optional object,
[optional.general]
or
,
[lex.key]
or_eq
,
[lex.key]
order of evaluation in expression,
see
expression, order of evaluation of
order of execution
base class constructor,
[class.default.ctor]
base class destructor,
[class.dtor]
constructor and array,
[class.init]
constructor and static data members,
[class.expl.init]
destructor,
[class.dtor]
destructor and array,
[class.dtor]
member constructor,
[class.default.ctor]
member destructor,
[class.dtor]
ordering
function template partial,
see
template, function, partial ordering
ordinary character literal,
[lex.ccon]
ordinary string literal,
[lex.string]
<ostream>
,
[version.syn]
,
[ostream.syn]
,
[output.streams]
over-aligned type,
see
type, over-aligned
overflow,
[expr.pre]
undefined,
[expr.pre]
overload resolution,
[over.pre]
overload set,
[basic.lookup]
overloaded function,
see
overloading
address of,
[expr.unary.op]
,
[over.over]
overloaded operator,
see
overloading, operator
inheritance of,
[over.oper]
overloading,
[dcl.fct]
,
[class.name]
,
[over]
,
[over.pre]
,
[temp.over.link]
access control and,
[over.dcl]
address of overloaded function,
[over.over]
argument lists,
[over.match.funcs]
array versus pointer,
[over.load]
assignment operator,
[over.ass]
binary operator,
[over.binary]
built-in operators and,
[over.built]
candidate functions,
[over.match.funcs]
declaration matching,
[over.dcl]
declarations,
[over.load]
example of,
[over.pre]
function call operator,
[over.call]
function versus pointer,
[over.load]
member access operator,
[over.ref]
operator,
[over.oper]
prohibited,
[over.load]
resolution,
[over.match]
best viable function,
[over.match.best]
better viable function,
[over.match.best]
contexts,
[over.match]
function call syntax,
[over.match.call]
function template,
[temp.over]
implicit conversions and,
[over.best.ics]
initialization,
[over.match.ctor]
,
[over.match.copy]
,
[over.match.conv]
,
[over.match.ref]
,
[over.match.list]
operators,
[over.match.oper]
scoping ambiguity,
[class.member.lookup]
template,
[temp.func.order]
template name,
[temp.res]
viable functions,
[over.match.viable]
subscripting operator,
[over.sub]
unary operator,
[over.unary]
user-defined literal,
[over.literal]
using directive and,
[namespace.udir]
using-declaration and,
[namespace.udecl]
overloads
floating-point,
[cmplx.over]
override
,
[lex.name]
,
[class.mem]
,
[gram.class]
overrider
final,
[class.virtual]
own,
[unique.ptr]
P
P
ℓ
(Legendre polynomials),
[sf.cmath.legendre]
P
ℓ
m
(associated Legendre polynomials),
[sf.cmath.assoc.legendre]
pack,
[temp.variadic]
unexpanded,
[temp.variadic]
pack expansion,
[temp.variadic]
pattern,
[temp.variadic]
padding bits,
[basic.types]
pair
tuple interface to,
[pairs.general]
parallel algorithm,
[algorithms.parallel.defns]
parallel forward progress guarantees,
[intro.progress]
param
random number distribution requirement,
[rand.req.dist]
seed sequence requirement,
[rand.req.seedseq]
param_type
random number distribution requirement,
[rand.req.dist]
parameter,
[defns.parameter]
,
[defns.parameter.macro]
,
[defns.parameter.templ]
catch clause,
[defns.parameter]
disqualifying,
[concept.booleantestable]
function,
[defns.parameter]
function-like macro,
[defns.parameter.macro]
key,
[concept.booleantestable]
macro,
[cpp.replace]
reference,
[dcl.ref]
scope of,
[basic.scope.param]
template,
[defns.parameter.templ]
,
[basic.def]
void
,
[dcl.fct]
parameter declaration,
[basic.def]
parameter list
variable,
[expr.call]
,
[dcl.fct]
parameter mapping,
[temp.constr.atomic]
parameter-type-list,
[dcl.fct]
parameterized type,
see
template
parent directory,
[fs.general]
past-the-end iterator,
see
iterator, past-the-end
path,
[fs.class.path]
absolute,
[fs.class.path]
normalization,
[fs.path.generic]
relative,
[fs.class.path]
path equality,
[fs.path.nonmember]
pathname,
[fs.class.path]
pathname resolution,
[fs.class.path]
pattern,
see
pack expansion, pattern
perfect forwarding call wrapper,
[func.require]
period,
[character.seq]
phase completion step,
[thread.barrier.class]
phase synchronization point,
see
barrier, phase synchronization point
phases of translation,
see
translation, phases
Π
(complete elliptic integrals),
[sf.cmath.comp.ellint.3]
Π
(incomplete elliptic integrals),
[sf.cmath.ellint.3]
piecewise construction,
[pairs.pair]
piecewise_constant_distribution
interval boundaries,
[rand.dist.samp.pconst]
probability density function,
[rand.dist.samp.pconst]
weights,
[rand.dist.samp.pconst]
piecewise_linear_distribution
interval boundaries,
[rand.dist.samp.plinear]
probability density function,
[rand.dist.samp.plinear]
weights at boundaries,
[rand.dist.samp.plinear]
placeholder type deduction,
[dcl.type.auto.deduct]
placement
new-expression
,
see
new-expression
, placement
plain lock-free atomic operation,
[support.signal]
POD,
[depr.meta.types]
point,
[basic.compound]
point of
declaration,
see
declaration, point of
macro definition,
see
macro, point of definition
macro import,
see
macro, point of import
macro undefinition,
see
macro, point of undefinition
pointer,
see also
void
*
composite pointer type,
[expr.type]
integer representation of safely-derived,
[basic.stc.dynamic.safety]
safely-derived,
[basic.stc.dynamic.safety]
strict total order,
[defns.order.ptr]
to traceable object,
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
zero,
see
value, null pointer
pointer literal,
see
literal, pointer
pointer past the end of,
[basic.compound]
pointer to,
[basic.compound]
pointer to member,
[basic.compound]
,
[expr.mptr.oper]
,
[dcl.mptr]
pointer-interconvertible,
[basic.compound]
Poisson distributions,
[rand.dist.pois]
poisson_distribution
discrete probability function,
[rand.dist.pois.poisson]
mean,
[rand.dist.pois.poisson]
polymorphic class,
see
class, polymorphic
pool resource classes,
[mem.res.pool.overview]
pools,
[mem.res.pool.overview]
population,
[alg.random.sample]
POSIX,
[intro.refs]
extended regular expressions,
[re.synopt]
regular expressions,
[re.synopt]
postfix
+
+
,
[expr.post.incr]
postfix
+
+
and
-
-
overloading,
[over.inc]
postfix
-
-
,
[expr.post.incr]
potential results,
[basic.def.odr]
potential scope,
[basic.scope.declarative]
potentially concurrent,
[intro.races]
potentially constant evaluated,
[expr.const]
potentially evaluated,
[basic.def.odr]
potentially-constant,
[expr.const]
potentially-overlapping subobject,
[intro.object]
potentially-throwing
exception specification,
[except.spec]
expression,
[except.spec]
precedence of operator,
see
operator, precedence of
prefix
L
,
[lex.ccon]
,
[lex.string]
R
,
[lex.string]
U
,
[lex.ccon]
,
[lex.string]
u
,
[lex.ccon]
,
[lex.string]
u8
,
[lex.ccon]
,
[lex.string]
prefix
+
+
,
[expr.pre.incr]
prefix
+
+
and
-
-
overloading,
[over.inc]
prefix
-
-
,
[expr.pre.incr]
prefix unary operator function,
see
operator function, prefix unary
preprocessing,
[cpp.pre]
preprocessing directive,
[cpp]
,
[cpp.pre]
conditional inclusion,
[cpp.cond]
error,
[cpp.error]
header inclusion,
[cpp.include]
import,
[cpp.import]
line control,
[cpp.line]
macro replacement,
see
macro, replacement
module,
[cpp.module]
null,
[cpp.null]
pragma,
[cpp.pragma]
source-file inclusion,
[cpp.include]
primary class template,
see
template, primary
primary equivalence class,
[defns.regex.matched]
primary module interface unit,
[module.unit]
private
,
[lex.key]
,
[module.private.frag]
,
[class.derived]
,
see
access control,
private
,
[cpp.pre]
,
[gram.module]
,
[gram.class]
,
[gram.cpp]
probability density function
cauchy_distribution
,
[rand.dist.norm.cauchy]
chi_squared_distribution
,
[rand.dist.norm.chisq]
exponential_distribution
,
[rand.dist.pois.exp]
extreme_value_distribution
,
[rand.dist.pois.extreme]
fisher_f_distribution
,
[rand.dist.norm.f]
gamma_distribution
,
[rand.dist.pois.gamma]
lognormal_distribution
,
[rand.dist.norm.lognormal]
normal_distribution
,
[rand.dist.norm.normal]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
student_t_distribution
,
[rand.dist.norm.t]
uniform_real_distribution
,
[rand.dist.uni.real]
weibull_distribution
,
[rand.dist.pois.weibull]
program,
[basic.link]
,
[basic.link]
ill-formed,
[defns.ill.formed]
startup,
[basic.start.main]
termination,
[basic.start.term]
well-formed,
[defns.well.formed]
,
[intro.abstract]
program execution,
[intro.abstract]
abstract machine,
[intro.abstract]
as-if rule,
see
as-if rule
program semantics
affected by the existence of a variable or function definition,
[temp.inst]
projection,
[defns.projection]
promise object,
[dcl.fct.def.coroutine]
promise type,
see
coroutine, promise type
promoted integral type,
[over.built]
promotion
bool to int,
[conv.prom]
default argument promotion,
[expr.call]
floating-point,
[conv.fpprom]
integral,
[conv.prom]
prospective destructor,
see
destructor, prospective
protected
,
[lex.key]
,
[class.derived]
,
see
access control,
protected
,
[gram.class]
protection,
see
access control
,
[protection.within.classes]
prototype parameter
concept,
[temp.concept]
provides storage,
[intro.object]
prvalue,
[basic.lval]
pseudo-destructor,
[expr.prim.id.dtor]
ptrdiff_t
,
[expr.add]
implementation-defined type of,
[expr.add]
public
,
[lex.key]
,
[class.derived]
,
see
access control,
public
,
[gram.class]
punctuator,
[lex.operators]
purview
global module,
[module.unit]
module unit,
[module.unit]
named module,
[module.unit]
Q
qualification
explicit,
[basic.lookup.qual]
<queue>
,
[container.adaptors.general]
,
[queue.syn]
R
<random>
,
[rand.synopsis]
,
[diff.cpp03.library]
random number distribution
bernoulli_distribution
,
[rand.dist.bern.bernoulli]
binomial_distribution
,
[rand.dist.bern.bin]
cauchy_distribution
,
[rand.dist.norm.cauchy]
chi_squared_distribution
,
[rand.dist.norm.chisq]
discrete_distribution
,
[rand.dist.samp.discrete]
exponential_distribution
,
[rand.dist.pois.exp]
extreme_value_distribution
,
[rand.dist.pois.extreme]
fisher_f_distribution
,
[rand.dist.norm.f]
gamma_distribution
,
[rand.dist.pois.gamma]
geometric_distribution
,
[rand.dist.bern.geo]
lognormal_distribution
,
[rand.dist.norm.lognormal]
negative_binomial_distribution
,
[rand.dist.bern.negbin]
normal_distribution
,
[rand.dist.norm.normal]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
poisson_distribution
,
[rand.dist.pois.poisson]
requirements,
[rand.req.dist]
student_t_distribution
,
[rand.dist.norm.t]
uniform_int_distribution
,
[rand.dist.uni.int]
uniform_real_distribution
,
[rand.dist.uni.real]
weibull_distribution
,
[rand.dist.pois.weibull]
random number distributions
Bernoulli,
[rand.dist.bern]
normal,
[rand.dist.norm]
Poisson,
[rand.dist.pois]
sampling,
[rand.dist.samp]
uniform,
[rand.dist.uni]
random number engine
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
requirements,
[rand.req.eng]
subtract_with_carry_engine
,
[rand.eng.sub]
with predefined parameters,
[rand.predef]
random number engine adaptor
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
with predefined parameters,
[rand.predef]
random number generation,
[rand]
distributions,
[rand.dist]
engines,
[rand.eng]
predefined engines and adaptors,
[rand.predef]
requirements,
[rand.req]
synopsis,
[rand.synopsis]
utilities,
[rand.util]
random number generator,
see
uniform random bit generator
random_device
implementation leeway,
[rand.device]
range,
[iterator.requirements.general]
counted,
[iterator.requirements.general]
,
[range.counted]
<ranges>
,
[version.syn]
,
[tuple.helper]
,
[ranges.syn]
,
[range.access]
,
[diff.cpp17.library]
,
[depr.tuple]
<ratio>
,
[ratio.syn]
,
[diff.cpp03.library]
raw string literal,
[lex.string]
reachable
declaration,
[module.reach]
necessarily
translation unit,
[module.reach]
translation unit,
[module.reach]
reachable from,
[iterator.requirements.general]
ready,
[re.results]
,
[futures.state]
redefinition
typedef
,
[dcl.typedef]
reference,
[basic.compound]
assignment to,
[expr.ass]
call by,
[expr.call]
forwarding,
[temp.deduct.call]
lvalue,
[basic.compound]
null,
[dcl.ref]
rvalue,
[basic.compound]
sizeof
,
[expr.sizeof]
reference collapsing,
[dcl.ref]
reference lifetime,
[basic.life]
reference-compatible,
[dcl.init.ref]
reference-related,
[dcl.init.ref]
references
normative,
[intro.refs]
<regex>
,
[version.syn]
,
[iterator.range]
,
[re.req]
,
[re.syn]
,
[diff.cpp03.library]
regex_iterator
end-of-sequence,
[re.regiter]
regex_token_iterator
end-of-sequence,
[re.tokiter]
regex_traits
specializations,
[re.traits]
region
declarative,
[basic.pre]
,
[basic.scope.declarative]
intervening,
[basic.scope.declarative]
register
,
[lex.key]
register
storage class,
[diff.cpp14.dcl.dcl]
regular expression,
[re]
grammar,
[re.grammar]
matched,
[defns.regex.format.specifier]
requirements,
[re.req]
regular expression traits,
[re.grammar]
char_class_type
,
[re.req]
isctype
,
[re.req]
lookup_classname
,
[re.req]
,
[re.grammar]
lookup_collatename
,
[re.req]
requirements,
[re.req]
,
[re.traits]
transform
,
[re.req]
,
[re.grammar]
transform_primary
,
[re.req]
,
[re.grammar]
translate
,
[re.req]
,
[re.grammar]
translate_nocase
,
[re.req]
,
[re.grammar]
reified object,
see
object, reified
reinterpret_cast
,
[lex.key]
,
see
cast, reinterpret
,
[expr.post]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
relational operator function,
see
operator function, relational
relative path,
see
path, relative
relaxed pointer safety,
[basic.stc.dynamic.safety]
release sequence,
[intro.races]
remainder operator,
see
operator, remainder
remote time zone database,
[time.zone.db.remote]
replacement
macro,
see
macro, replacement
replacement field
format string,
[format.string.general]
representation
object,
[basic.types]
value,
[basic.types]
represents the address,
[basic.compound]
requirement,
[expr.prim.req]
compound,
[expr.prim.req.compound]
nested,
[expr.prim.req.nested]
simple,
[expr.prim.req.simple]
type,
[expr.prim.req.type]
requirements,
[structure.requirements]
container,
[container.requirements]
,
[unord.req]
,
[array.overview]
,
[array.cons]
,
[re.results]
not required for unordered associated containers,
[unord.req]
iterator,
[iterator.requirements.general]
numeric type,
[numeric.requirements]
random number distribution,
[rand.req.dist]
random number engine,
[rand.req.eng]
regular expression traits,
[re.req]
,
[re.traits]
seed sequence,
[rand.req.seedseq]
sequence,
[re.results]
uniform random bit generator,
[rand.req.urng]
unordered associative container,
[unord.req]
requires
,
[lex.key]
,
[expr.prim.req]
,
[expr.prim.req.simple]
,
[expr.prim.req.nested]
,
[temp.pre]
,
[gram.expr]
,
[gram.temp]
requires-clause
trailing,
[dcl.decl]
rescanning and replacement,
see
macro, rescanning and replacement
reserved identifier,
[lex.name]
reset,
[unique.ptr]
random number distribution requirement,
[rand.req.dist]
resolution,
see
overloading, resolution
restriction,
[res.on.arguments]
,
[res.on.macro.definitions]
,
[res.on.exception.handling]
,
[depr.res.on.required]
address of bit-field,
[class.bit]
anonymous
union
,
[class.union.anon]
bit-field,
[class.bit]
constructor,
[class.ctor]
destructor,
[class.dtor]
extern
,
[dcl.stc]
local class,
[class.local]
operator overloading,
[over.oper]
overloading,
[over.oper]
pointer to bit-field,
[class.bit]
reference,
[dcl.ref]
static
,
[dcl.stc]
static member local class,
[class.local]
union
,
[class.union]
result
glvalue,
[basic.lval]
prvalue,
[basic.lval]
result object,
[basic.lval]
result_type
entity characterization based on,
[rand]
random number distribution requirement,
[rand.req.dist]
seed sequence requirement,
[rand.req.seedseq]
rethrow,
see
exception handling, rethrow
return
,
[lex.key]
,
[stmt.jump]
,
[stmt.return]
,
[gram.stmt]
and handler,
[except.pre]
and try block,
[except.pre]
constructor and,
[stmt.return]
reference and,
[dcl.init.ref]
return
statement,
see
return
return type,
[dcl.fct]
covariant,
[class.virtual]
overloading and,
[over.load]
reversible container,
see
container, reversible
rewritten candidate,
[over.match.oper]
right shift operator,
see
operator, right shift
rounding,
[conv.fpint]
rvalue,
[basic.lval]
lvalue conversion to,
see
conversion, lvalue-to-rvalue
,
[diff.expr]
rvalue reference,
[dcl.ref]
S
safely-derived pointer,
[basic.stc.dynamic.safety]
integer representation,
[basic.stc.dynamic.safety]
sample,
[alg.random.sample]
sampling distributions,
[rand.dist.samp]
satisfy,
see
constraint, satisfaction
scalar type,
see
type, scalar
scope,
[intro.scope]
,
[basic.pre]
,
[basic.scope]
,
[basic.scope.declarative]
,
[dcl.pre]
anonymous
union
at namespace,
[class.union.anon]
block,
[basic.scope.block]
class,
[basic.scope.class]
declarations and,
[basic.scope.declarative]
destructor and exit from,
[stmt.jump]
enumeration,
[basic.scope.enum]
exception declaration,
[basic.scope.block]
function,
[basic.funscope]
function parameter,
[basic.scope.param]
function prototype,
see
scope, function parameter
global,
[basic.scope.namespace]
iteration-statement
,
[stmt.iter]
macro definition,
see
macro, scope of definition
name lookup and,
[basic.lookup]
namespace,
[basic.scope.namespace]
overloading and,
[over.dcl]
potential,
[basic.scope.declarative]
selection-statement
,
[stmt.select]
template parameter,
[basic.scope.temp]
scope name hiding and,
[basic.scope.hiding]
scope resolution operator,
see
operator, scope resolution
scoped enumeration,
see
enumeration, scoped
<scoped_allocator>
,
[version.syn]
,
[allocator.adaptor.syn]
,
[diff.cpp03.library]
secondary comparison operator,
[class.compare.secondary]
seed
random number engine requirement,
[rand.req.eng]
seed sequence,
[rand.req.seedseq]
requirements,
[rand.req.seedseq]
selected destructor,
see
destructor, selected
semantics
class member,
[expr.ref]
<semaphore>
,
[version.syn]
,
[semaphore.syn]
,
[diff.cpp17.library]
sentinel,
[iterator.requirements.general]
separate compilation,
see
compilation, separate
separate translation,
see
compilation, separate
sequence constructor
seed sequence requirement,
[rand.req.seedseq]
sequenced after,
[intro.execution]
sequenced before,
[intro.execution]
sequencing operator,
see
operator, comma
<set>
,
[version.syn]
,
[associative.general]
,
[associative.set.syn]
,
[iterator.range]
<setjmp.h>
,
[csetjmp.syn]
,
[depr.c.headers]
shared lock,
[thread.sharedmutex.requirements]
shared mutex types,
[thread.sharedmutex.requirements]
shared state,
see
future, shared state
shared timed mutex type,
[thread.sharedtimedmutex.requirements]
<shared_mutex>
,
[version.syn]
,
[shared.mutex.syn]
,
[diff.cpp11.library]
shift operator
left,
see
operator, left shift
right,
see
operator, right shift
short
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
typedef
and,
[dcl.spec]
shuffle_order_engine
generation algorithm,
[rand.adapt.shuf]
state,
[rand.adapt.shuf]
textual representation,
[rand.adapt.shuf]
transition algorithm,
[rand.adapt.shuf]
side effect
visible,
[intro.races]
side effects,
[intro.abstract]
,
[class.temporary]
,
[intro.execution]
,
[intro.races]
,
[intro.execution]
,
[stmt.expr]
,
[class.base.init]
,
[class.copy.elision]
,
[cpp.replace]
,
[res.on.data.races]
visible,
[intro.races]
signal,
[intro.execution]
signal-safe
_Exit
,
[support.start.term]
abort
,
[support.start.term]
evaluation,
see
evaluation, signal-safe
forward
,
[forward]
initializer_list
functions,
[support.initlist]
memcpy
,
[cstring.syn]
memmove
,
[cstring.syn]
move
,
[forward]
move_if_noexcept
,
[forward]
numeric_limits
members,
[numeric.limits.members]
quick_exit
,
[support.start.term]
signal
,
[support.signal]
type traits,
[meta]
<signal.h>
,
[csignal.syn]
,
[depr.c.headers]
signature,
[defns.signature]
,
[defns.signature.friend]
,
[defns.signature.templ]
,
[defns.signature.templ.friend]
,
[defns.signature.spec]
,
[defns.signature.member]
,
[defns.signature.member.templ]
,
[defns.signature.member.spec]
signed
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
typedef
and,
[dcl.spec]
signed integer representation
ones' complement,
[expr.unary.op]
two's complement,
[basic.fundamental]
,
[dcl.enum]
,
[ratio.ratio]
,
[atomics.ref.int]
,
[atomics.types.int]
signed integer type,
[basic.fundamental]
signed-integer-class type,
see
type, signed-integer-class
signed-integer-like,
[iterator.concept.winc]
significand,
[lex.fcon]
similar types,
[conv.qual]
simple assignment operator function,
see
operator function, simple assignment
simple call wrapper,
[func.require]
simply happens before,
[intro.races]
size
seed sequence requirement,
[rand.req.seedseq]
size_t
,
[expr.sizeof]
sizeof
,
[lex.key]
,
[expr.unary]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
smart pointers,
[util.smartptr.weak.bad]
source file,
[lex.separate]
,
[using.headers]
,
[alt.headers]
source file character,
see
character, source file
<source_location>
,
[version.syn]
,
[source.location.syn]
,
[diff.cpp17.library]
space
white,
[lex.pptoken]
<span>
,
[version.syn]
,
[views.general]
,
[span.syn]
,
[iterator.range]
,
[diff.cpp17.library]
special member function,
see
constructor
,
see
assignment operator
,
see
destructor
eligible,
[special]
specialization,
[temp.spec]
class template partial,
[temp.class.spec]
,
[temp.class.spec]
declared,
[temp.inst]
program-defined,
[defns.prog.def.spec]
template,
[temp.spec]
template explicit,
[temp.expl.spec]
specification
linkage,
[dcl.link]
extern
,
[dcl.link]
implementation-defined,
[dcl.link]
nesting,
[dcl.link]
template argument,
[temp.arg.explicit]
specifications
C standard library exception,
[res.on.exception.handling]
C++,
[res.on.exception.handling]
specifier,
[dcl.spec]
consteval
,
[dcl.constexpr]
constexpr
,
[dcl.constexpr]
constructor,
[dcl.constexpr]
function,
[dcl.constexpr]
,
[dcl.constexpr]
constinit
,
[dcl.constinit]
cv-qualifier,
[dcl.type.cv]
declaration,
[dcl.spec]
explicit
,
[dcl.fct.spec]
friend
,
[dcl.friend]
,
[protection.within.classes]
function,
[dcl.fct.spec]
inline
,
[dcl.inline]
static
,
[dcl.stc]
storage class,
[dcl.stc]
type,
see
type specifier
typedef
,
[dcl.typedef]
virtual
,
[dcl.fct.spec]
specifier access,
see
access specifier
spherical harmonics
Y
ℓ
m
,
[sf.cmath.sph.legendre]
<sstream>
,
[sstream.syn]
stable algorithm,
[defns.stable]
,
[algorithm.stable]
<stack>
,
[container.adaptors.general]
,
[stack.syn]
stack unwinding,
[except.ctor]
standard
structure of,
[intro.structure]
standard deviation
normal_distribution
,
[rand.dist.norm.normal]
standard integer type,
[basic.fundamental]
standard signed integer type,
[basic.fundamental]
standard unsigned integer type,
[basic.fundamental]
standard-layout class,
see
class, standard-layout
standard-layout struct,
see
struct, standard-layout
standard-layout type,
see
type, standard-layout
standard-layout union,
see
union, standard-layout
start
program,
[basic.start.dynamic]
startup
program,
[using.linkage]
,
[replacement.functions]
state,
[any.class]
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
state entity,
[func.def]
statement,
[stmt.stmt]
break
,
[stmt.jump]
,
[stmt.break]
compound,
[stmt.block]
continue
,
[stmt.jump]
,
[stmt.cont]
continue
in
for
,
[stmt.for]
declaration,
[stmt.dcl]
declaration in
for
,
[stmt.for]
declaration in
if
,
[stmt.pre]
declaration in
switch
,
[stmt.pre]
,
[stmt.switch]
declaration in
while
,
[stmt.while]
do
,
[stmt.iter]
,
[stmt.do]
empty,
[stmt.expr]
expression,
[stmt.expr]
fallthrough,
[dcl.attr.fallthrough]
for
,
[stmt.iter]
,
[stmt.for]
goto
,
[stmt.label]
,
[stmt.jump]
,
[stmt.goto]
if
,
[stmt.select]
,
[stmt.if]
iteration,
[stmt.iter]
jump,
[stmt.jump]
labeled,
[stmt.label]
null,
[stmt.expr]
range based
for
,
[stmt.ranged]
selection,
[stmt.select]
switch
,
[stmt.select]
,
[stmt.switch]
,
[stmt.break]
while
,
[stmt.iter]
,
[stmt.while]
static
,
[lex.key]
,
[dcl.stc]
,
[gram.dcl]
destruction of local,
[stmt.dcl]
linkage of,
[basic.link]
,
[dcl.stc]
overloading and,
[over.load]
static data member,
see
data member, static
static initialization,
see
initialization, static
static member,
see
member, static
static member function,
see
member function, static
static storage duration,
[basic.stc.static]
static type,
see
type, static
static_assert
,
[lex.key]
,
[dcl.pre]
,
[gram.dcl]
not macro,
[cassert.syn]
static_cast
,
[lex.key]
,
see
cast, static
,
[expr.post]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
STATICALLY-WIDEN
,
[time.general]
<stdalign.h>
,
[diff.header.stdalign.h]
,
[depr.c.headers]
,
[depr.stdalign.h.syn]
,
[depr.c.headers.other]
<stdarg.h>
,
[cstdarg.syn]
,
[depr.c.headers]
<stdatomic.h>
absence thereof,
[headers]
,
[diff.mods.to.headers]
<stdbool.h>
,
[diff.expr]
,
[diff.header.stdbool.h]
,
[depr.c.headers]
,
[depr.stdbool.h.syn]
,
[depr.c.headers.other]
<stddef.h>
,
[lex.ccon]
,
[lex.string]
,
[cstddef.syn]
,
[support.types.layout]
,
[diff.mods.to.declarations]
,
[depr.c.headers]
<stdexcept>
,
[std.exceptions]
<stdint.h>
,
[cstdint.syn]
,
[cinttypes.syn]
,
[depr.c.headers]
<stdio.h>
,
[cstdio.syn]
,
[depr.c.headers]
<stdlib.h>
,
[cstdlib.syn]
,
[depr.c.headers]
,
[depr.c.headers.other]
<stdnoreturn.h>
absence thereof,
[headers]
,
[diff.mods.to.headers]
stop request,
[thread.stoptoken.intro]
stop state,
[thread.stoptoken.intro]
<stop_token>
,
[version.syn]
,
[thread.stoptoken.syn]
,
[diff.cpp17.library]
storage class,
[basic.pre]
storage duration,
[basic.stc]
,
[basic.stc]
automatic,
[basic.stc]
,
[basic.stc.auto]
class member,
[basic.stc.inherit]
dynamic,
[basic.stc]
,
[basic.stc.dynamic]
,
[expr.new]
local object,
[basic.stc.auto]
static,
[basic.stc]
,
[basic.stc.static]
thread,
[basic.stc]
,
[basic.stc.thread]
storage management,
see
new
,
see
delete
stream
arbitrary-positional,
[defns.arbitrary.stream]
repositional,
[defns.repositional.stream]
<streambuf>
,
[streambuf.syn]
strict pointer safety,
[basic.stc.dynamic.safety]
<string>
,
[version.syn]
,
[char.traits.require]
,
[char.traits.specializations]
,
[string.syn]
,
[iterator.range]
string
distinct,
[lex.string]
null terminator,
[basic.string]
null-terminated byte,
see
ntbs
null-terminated character type,
[defns.ntcts]
null-terminated multibyte,
see
ntmbs
sizeof
,
[lex.string]
type of,
[lex.string]
width,
[format.string.std]
string literal,
see
literal, string
<string.h>
,
[cstring.syn]
,
[depr.c.headers]
<string_view>
,
[version.syn]
,
[string.view.synop]
,
[iterator.range]
,
[diff.cpp14.library]
stringize,
see
#
operator
stringizing argument,
[cpp.stringize]
strongly happens before,
[intro.races]
<strstream>
,
[depr.strstream.syn]
struct
,
[lex.key]
,
[dcl.enum]
,
[class.pre]
,
[gram.dcl]
,
[gram.class]
standard-layout,
[class.prop]
structural type,
see
type, structural
structure tag,
see
class name
structured binding,
[dcl.struct.bind]
structured binding declaration,
[dcl.struct.bind]
,
[dcl.pre]
student_t_distribution
probability density function,
[rand.dist.norm.t]
sub-expression
regular expression,
[defns.regex.regular.expression]
subexpression,
[intro.execution]
subnormal number,
see
number, subnormal
subobject,
see also
object model
,
[intro.object]
,
[intro.object]
subscripting operator
overloaded,
[over.sub]
subscripting operator function,
see
operator function, subscripting
subsequence rule
overloading,
[over.ics.rank]
substatement,
[stmt.pre]
substitutability,
[cmp.categories.pre]
subsume,
see
constraint, subsumption
subtract_with_carry_engine
carry,
[rand.eng.sub]
generation algorithm,
[rand.eng.sub]
state,
[rand.eng.sub]
textual representation,
[rand.eng.sub]
transition algorithm,
[rand.eng.sub]
subtraction
implementation-defined pointer,
[expr.add]
subtraction operator,
see
operator, subtraction
suffix
F
,
[lex.fcon]
f
,
[lex.fcon]
L
,
[lex.icon]
,
[lex.fcon]
l
,
[lex.icon]
,
[lex.fcon]
U
,
[lex.icon]
u
,
[lex.icon]
suitable created object,
see
object, suitable created
summary
compatibility with ISO C,
[diff.iso]
compatibility with ISO C++ 2003,
[diff.cpp03]
compatibility with ISO C++ 2011,
[diff.cpp11]
compatibility with ISO C++ 2014,
[diff.cpp14]
compatibility with ISO C++ 2017,
[diff.cpp17]
syntax,
[gram]
surrogate call function,
[over.call.object]
swappable,
[swappable.requirements]
swappable with,
[swappable.requirements]
switch
,
[lex.key]
,
[stmt.select]
,
[stmt.switch]
,
[gram.stmt]
and handler,
[except.pre]
and try block,
[except.pre]
symbolic link,
[fs.general]
synchronize with,
[intro.races]
<syncstream>
,
[version.syn]
,
[syncstream.syn]
,
[diff.cpp17.library]
synonym,
[namespace.alias]
type name as,
[dcl.typedef]
syntax
class member,
[expr.ref]
synthesized three-way comparison,
see
three-way comparison, synthesized
<system_error>
,
[system.error.syn]
,
[diff.cpp03.library]
T
target object,
[func.def]
template
,
[lex.key]
,
[expr.prim.id.qual]
,
[dcl.type.simple]
,
[dcl.type.elab]
,
[class.derived]
,
[over.match.class.deduct]
,
[over.ref]
,
[temp]
,
[temp.pre]
,
[temp.explicit]
,
[temp.expl.spec]
,
[temp.pre]
,
[gram.expr]
,
[gram.dcl]
,
[gram.class]
,
[gram.temp]
alias,
[temp.alias]
class,
[temp.class]
deducible,
[dcl.type.simple]
deducible arguments of,
[over.match.class.deduct]
function,
[temp.fct.spec]
abbreviated,
[dcl.fct]
equivalent,
see
equivalent, function template
functionally equivalent,
see
functionally equivalent, function template
key parameter of,
[concept.booleantestable]
partial ordering,
[temp.func.order]
member function,
[temp.mem.func]
primary,
[temp.class.spec]
static data member,
[temp.pre]
variable,
[temp.pre]
template instantiation,
[temp.spec]
template name
linkage of,
[temp.pre]
template parameter,
[basic.def]
template parameter object,
[temp.param]
template parameter pack,
[temp.variadic]
template parameter scope,
[basic.scope.temp]
template-argument
default,
[temp.param]
template-argument-equivalent,
[temp.type]
template-id
valid,
[temp.names]
templated,
[temp.pre]
temporary,
[class.temporary]
constructor for,
[class.temporary]
destruction of,
[class.temporary]
destructor for,
[class.temporary]
elimination of,
[class.temporary]
,
[class.copy.elision]
implementation-defined generation of,
[class.temporary]
order of destruction of,
[class.temporary]
terminate
,
[except.terminate]
called,
[expr.throw]
,
[except.throw]
,
[except.spec]
,
[except.terminate]
termination
program,
[basic.start.main]
,
[basic.start.term]
terminology
pointer,
[basic.compound]
textual representation
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
<tgmath.h>
,
[diff.mods.to.headers]
,
[depr.c.headers]
,
[depr.tgmath.h.syn]
,
[depr.c.headers.other]
this
,
[lex.key]
,
[expr.prim]
,
[expr.prim.this]
,
[expr.prim.lambda.capture]
,
[class.this]
,
[gram.expr]
type of,
[class.this]
this
pointer,
see
this
<thread>
,
[version.syn]
,
[thread.syn]
,
[diff.cpp03.library]
thread,
[intro.multithread]
thread of execution,
[intro.multithread]
thread storage duration,
see
storage duration, thread
thread_local
,
[lex.key]
,
[dcl.stc]
,
[temp.explicit]
,
[temp.expl.spec]
,
[gram.dcl]
threads
multiple,
[intro.multithread]
<threads.h>
absence thereof,
[headers]
,
[diff.mods.to.headers]
three-way comparison
synthesized,
[class.spaceship]
three-way comparison operator function,
see
operator function, three-way comparison
throw
,
[lex.key]
,
[expr.throw]
,
[temp.dep.expr]
,
[gram.expr]
throwing,
see
exception handling, throwing
<time.h>
,
[ctime.syn]
,
[depr.c.headers]
timed mutex types,
[thread.timedmutex.requirements]
to-unsigned-like
,
[ranges.syn]
token,
[lex.token]
alternative,
[lex.digraph]
directive-introducing,
[cpp.pre]
preprocessing,
[lex.pptoken]
traceable pointer object,
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
trailing
requires-clause
,
see
requires-clause
, trailing
traits,
[defns.traits]
transform
regular expression traits,
[re.req]
,
[re.grammar]
transform_primary
regular expression traits,
[re.req]
,
[re.grammar]
transition algorithm
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
translate
regular expression traits,
[re.req]
,
[re.grammar]
translate_nocase
regular expression traits,
[re.req]
,
[re.grammar]
translation
phases,
[lex.phases]
separate,
see
compilation, separate
translation unit,
[lex.separate]
,
[basic.link]
name and,
[basic.pre]
transparently replaceable,
[basic.life]
trigraph sequence,
[diff.cpp14.lex]
trivial class,
see
class, trivial
trivial type,
see
type, trivial
trivially copyable class,
see
class, trivially copyable
trivially copyable type,
see
type, trivially copyable
true
,
[lex.key]
truncation,
[conv.fpint]
try
,
[lex.key]
,
[except.pre]
try block,
see
exception handling, try block
TU-local
entity,
[basic.link]
value or object,
[basic.link]
<tuple>
,
[version.syn]
,
[utility.syn]
,
[tuple.syn]
,
[tuple.helper]
,
[diff.cpp03.library]
,
[depr.tuple]
tuple
and
pair
,
[pairs.general]
type,
[basic.pre]
,
[basic.types]
allocated,
[expr.new]
arithmetic,
[basic.fundamental]
promoted,
[over.built]
array,
[basic.compound]
bitmask,
[bitmask.types]
,
[bitmask.types]
Boolean,
[basic.fundamental]
callable,
[func.def]
char
,
[basic.fundamental]
char16_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
char32_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
char8_t
,
[basic.fundamental]
character,
[basic.fundamental]
character container,
[defns.character.container]
class and,
[class.pre]
compound,
[basic.compound]
const
,
[dcl.type]
cv-combined,
[conv.qual]
cv-unqualified,
[basic.type.qualifier]
destination,
[dcl.init]
double
,
[basic.fundamental]
dynamic,
[defns.dynamic.type]
,
[defns.dynamic.type.prvalue]
enumerated,
[basic.compound]
,
[enumerated.types]
,
[bitmask.types]
,
[enumerated.types]
example of incomplete,
[basic.types]
extended integer,
[basic.fundamental]
extended signed integer,
[basic.fundamental]
extended unsigned integer,
[basic.fundamental]
float
,
[basic.fundamental]
floating-point,
[basic.fundamental]
function,
[basic.compound]
,
[dcl.fct]
fundamental,
[basic.fundamental]
implementation-defined
sizeof
,
[basic.fundamental]
implicit-lifetime,
[basic.types]
incomplete,
[basic.def]
,
[basic.def.odr]
,
[basic.scope.pdecl]
,
[basic.types]
,
[conv.lval]
,
[expr.sub]
,
[expr.call]
,
[expr.type.conv]
,
[expr.ref]
,
[expr.dynamic.cast]
,
[expr.unary.op]
,
[expr.sizeof]
,
[expr.new]
,
[expr.delete]
,
[class.derived]
incompletely-defined object,
[basic.types]
int
,
[basic.fundamental]
integer-class,
[iterator.concept.winc]
integral,
[basic.fundamental]
promoted,
[over.built]
literal,
[basic.types]
long
,
[basic.fundamental]
long double
,
[basic.fundamental]
long long
,
[basic.fundamental]
narrow character,
[basic.fundamental]
nodiscard,
[dcl.attr.nodiscard]
numeric,
[numeric.requirements]
ordinary character,
[basic.fundamental]
,
[basic.fundamental]
over-aligned,
[basic.align]
pointer,
[basic.compound]
polymorphic,
[class.virtual]
program-defined,
[defns.prog.def.type]
referenceable,
[defns.referenceable]
scalar,
[basic.types]
short
,
[basic.fundamental]
signed char
,
[basic.fundamental]
signed integer,
[basic.fundamental]
signed-integer-class,
[iterator.concept.winc]
similar,
see
similar types
standard integer,
[basic.fundamental]
standard signed integer,
[basic.fundamental]
standard unsigned integer,
[basic.fundamental]
standard-layout,
[basic.types]
static,
[defns.static.type]
structural,
[temp.param]
trivial,
[basic.types]
trivially copyable,
[basic.types]
,
[basic.types]
underlying,
[basic.fundamental]
char16_t
,
[basic.fundamental]
,
[conv.prom]
char32_t
,
[basic.fundamental]
,
[conv.prom]
char8_t
,
[basic.fundamental]
enumeration,
[conv.prom]
,
[dcl.enum]
fixed,
[dcl.enum]
wchar_t
,
[basic.fundamental]
,
[conv.prom]
unsigned
,
[basic.fundamental]
unsigned char
,
[basic.fundamental]
unsigned int
,
[basic.fundamental]
unsigned integer,
[basic.fundamental]
unsigned long
,
[basic.fundamental]
unsigned long long
,
[basic.fundamental]
unsigned short
,
[basic.fundamental]
unsigned-integer-class,
[iterator.concept.winc]
void
,
[basic.fundamental]
volatile
,
[dcl.type]
wchar_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
type checking
argument,
[expr.call]
type concept,
see
concept, type
type conversion, explicit,
see
casting
type generator,
see
template
type name,
[dcl.name]
nested,
[class.nested.type]
scope of,
[class.nested.type]
type pun,
[expr.reinterpret.cast]
type specifier
auto
,
[dcl.spec.auto]
bool
,
[dcl.type.simple]
char
,
[dcl.type.simple]
char16_t
,
[dcl.type.simple]
char32_t
,
[dcl.type.simple]
char8_t
,
[dcl.type.simple]
const
,
[dcl.type.cv]
decltype
,
[dcl.type.decltype]
decltype(auto)
,
[dcl.spec.auto]
double
,
[dcl.type.simple]
elaborated,
[basic.lookup.elab]
,
[dcl.type.elab]
enum
,
[dcl.type.elab]
float
,
[dcl.type.simple]
int
,
[dcl.type.simple]
long
,
[dcl.type.simple]
short
,
[dcl.type.simple]
signed
,
[dcl.type.simple]
simple,
[dcl.type.simple]
unsigned
,
[dcl.type.simple]
void
,
[dcl.type.simple]
volatile
,
[dcl.type.cv]
wchar_t
,
[dcl.type.simple]
type-id-only context,
[temp.res]
type-name
,
[dcl.type.simple]
type_info
,
[expr.typeid]
<type_traits>
,
[version.syn]
,
[meta.type.synop]
,
[diff.cpp03.library]
,
[depr.meta.types]
typedef
,
[lex.key]
,
[dcl.spec]
,
[gram.dcl]
function,
[dcl.fct]
overloading and,
[over.load]
typeid
,
[lex.key]
,
[expr.post]
,
[expr.typeid]
,
[expr.const]
,
[temp.dep.expr]
,
[temp.dep.constexpr]
,
[gram.expr]
construction and,
[class.cdtor]
destruction and,
[class.cdtor]
<typeindex>
,
[type.index.synopsis]
,
[diff.cpp03.library]
<typeinfo>
,
[expr.typeid]
,
[support.rtti]
typename
,
[lex.key]
,
[expr.prim.req.type]
,
[dcl.type.simple]
,
[dcl.type.elab]
,
[namespace.udecl]
,
[over.match.class.deduct]
,
[temp.param]
,
[temp.res]
,
[gram.expr]
,
[gram.dcl]
,
[gram.temp]
types
implementation-defined,
[type.descriptions.general]
U
<uchar.h>
,
[cuchar.syn]
,
[depr.c.headers]
unary fold,
[expr.prim.fold]
unary left fold,
[expr.prim.fold]
unary operator
interpretation of,
[over.unary]
overloaded,
[over.unary]
unary right fold,
[expr.prim.fold]
unblock,
[defns.unblock]
undefined,
[defns.required.behavior]
,
[defns.reserved.function]
,
[reserved.names]
,
[alt.headers]
,
[res.on.arguments]
,
[valarray.comparison]
,
[class.gslice.overview]
,
[indirect.array.assign]
,
[indirect.array.comp.assign]
,
[fpos.operations]
undefined behavior,
see
behavior, undefined
underlying type,
see
type, underlying
unevaluated operand,
[expr.context]
Unicode required set,
[cpp.predefined]
uniform distributions,
[rand.dist.uni]
uniform random bit generator
requirements,
[rand.req.urng]
uniform_int_distribution
discrete probability function,
[rand.dist.uni.int]
uniform_real_distribution
probability density function,
[rand.dist.uni.real]
union
,
[lex.key]
,
[basic.compound]
,
[class.pre]
,
[class.union]
,
[class.union.anon]
,
[class.union]
,
[gram.class]
anonymous,
[class.union.anon]
global anonymous,
[class.union.anon]
standard-layout,
[class.prop]
union-like class,
[class.union.anon]
unique pointer,
[unique.ptr]
unit
translation,
[using.headers]
,
[macro.names]
universal character name,
[lex.phases]
Unix time,
[time.clock.system.overview]
unnamed bit-field,
[class.bit]
unordered associative containers,
[unord.req]
complexity,
[unord.req]
equality function,
[unord.req]
equivalent keys,
[unord.req]
,
[unord.multimap.overview]
,
[unord.multiset.overview]
exception safety,
[unord.req.except]
hash function,
[unord.req]
iterator invalidation,
[unord.req]
iterators,
[unord.req]
lack of comparison functions,
[unord.req]
requirements,
[unord.req]
,
[unord.req.except]
unique keys,
[unord.req]
,
[unord.map.overview]
,
[unord.set.overview]
<unordered_map>
,
[version.syn]
,
[unord.general]
,
[unord.map.syn]
,
[iterator.range]
,
[diff.cpp03.library]
unordered_map
element access,
[unord.map.elem]
unique keys,
[unord.map.overview]
unordered_multimap
equivalent keys,
[unord.multimap.overview]
unordered_multiset
equivalent keys,
[unord.multiset.overview]
<unordered_set>
,
[version.syn]
,
[unord.general]
,
[unord.set.syn]
,
[iterator.range]
,
[diff.cpp03.library]
unordered_set
unique keys,
[unord.set.overview]
unscoped enumeration,
see
enumeration, unscoped
unsequenced,
[intro.execution]
unsigned
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
typedef
and,
[dcl.spec]
unsigned integer type,
[basic.fundamental]
unsigned-integer-class type,
see
type, unsigned-integer-class
unsigned-integer-like,
[iterator.concept.winc]
unspecified,
[new.delete.single]
,
[type.info]
,
[partial.sort]
,
[stringbuf.virtuals]
,
[depr.strstreambuf.cons]
,
[depr.strstreambuf.virtuals]
unspecified behavior,
see
behavior, unspecified
unwinding
stack,
[except.ctor]
uppercase,
[lex.name]
,
[character.seq]
upstream,
[mem.res.monotonic.buffer]
upstream allocator,
[mem.res.pool.overview]
usable
binary operator expression,
[class.compare.default]
usable candidate,
see
candidate, usable
usable in constant expressions,
[expr.const]
user-defined conversion sequence,
see
conversion sequence, user-defined
user-defined literal,
see
literal, user-defined
overloaded,
[over.literal]
user-provided,
[dcl.fct.def.default]
uses-allocator construction,
[allocator.uses.construction]
using
,
[lex.key]
,
[dcl.pre]
,
[namespace.unnamed]
,
[namespace.udir]
,
[namespace.udecl]
,
[dcl.attr.grammar]
,
[gram.dcl]
using-declaration,
[namespace.udecl]
using-directive,
[namespace.udir]
usual arithmetic conversions,
see
conversion, usual arithmetic
usual deallocation function,
[basic.stc.dynamic.deallocation]
UTF-16 character literal,
[lex.ccon]
UTF-16 string literal,
[lex.string]
UTF-32 character literal,
[lex.ccon]
UTF-32 string literal,
[lex.string]
UTF-8 character literal,
[lex.ccon]
UTF-8 string literal,
[lex.string]
<utility>
,
[swappable.requirements]
,
[version.syn]
,
[utility.syn]
,
[tuple.helper]
,
[diff.cpp03.library]
,
[depr.relops]
,
[depr.tuple]
V
vacuous initialization,
see
initialization, vacuous
<valarray>
,
[valarray.syn]
valid but unspecified state,
[defns.valid]
value,
[basic.types]
call by,
[expr.call]
denormalized,
see
number, subnormal
indeterminate,
[basic.indet]
,
[basic.indet]
invalid pointer,
[basic.compound]
null member pointer,
[conv.mem]
null pointer,
[basic.compound]
,
[conv.ptr]
undefined unrepresentable integral,
[conv.fpint]
value category,
[basic.lval]
value computation,
[class.temporary]
,
[intro.execution]
,
[intro.races]
,
[expr.post.incr]
,
[expr.new]
,
[expr.ass]
value type,
[iterator.requirements.general]
value-initialization,
[dcl.init]
variable,
[basic.pre]
function-local predefined,
[dcl.fct.def.general]
indeterminate uninitialized,
[dcl.init]
inline,
[dcl.inline]
local,
[basic.scope.block]
needed for constant evaluation,
[expr.const]
program semantics affected by the existence of a variable definition,
[temp.inst]
variable arguments,
[cpp.replace]
variable template
definition of,
[temp.pre]
<variant>
,
[version.syn]
,
[variant.syn]
,
[diff.cpp14.library]
,
[depr.variant]
variant member,
[class.union.anon]
<vector>
,
[version.syn]
,
[sequences.general]
,
[vector.syn]
,
[iterator.range]
vectorization-unsafe,
[algorithms.parallel.defns]
<version>
,
[version.syn]
,
[diff.cpp17.library]
virtual
,
[lex.key]
,
[dcl.fct.spec]
,
[class.derived]
,
[gram.dcl]
,
[gram.class]
virtual base class,
see
base class, virtual
virtual function,
see
function, virtual
virtual function call,
[class.virtual]
constructor and,
[class.cdtor]
destructor and,
[class.cdtor]
undefined pure,
[class.abstract]
visibility,
[basic.scope.hiding]
visible,
[basic.scope.hiding]
visible side effect,
see
side effect, visible
void
,
[lex.key]
,
[dcl.type.simple]
,
[gram.dcl]
void&
,
[dcl.ref]
void*
type,
[basic.compound]
volatile
,
[lex.key]
,
[basic.type.qualifier]
,
[dcl.decl]
,
[gram.dcl]
constructor and,
[class.this]
,
[class.ctor]
destructor and,
[class.this]
,
[class.dtor]
implementation-defined,
[dcl.type.cv]
overloading and,
[over.load]
volatile object,
see
object, volatile
volatile-qualified,
[basic.type.qualifier]
W
waiting function,
see
function, waiting
<wchar.h>
,
[cwchar.syn]
,
[depr.c.headers]
wchar_t
,
[lex.key]
,
see
type,
wchar_t
,
[dcl.type.simple]
,
[gram.dcl]
<wctype.h>
,
[cwctype.syn]
,
[depr.c.headers]
weakly parallel forward progress guarantees,
[intro.progress]
weibull_distribution
probability density function,
[rand.dist.pois.weibull]
weights
discrete_distribution
,
[rand.dist.samp.discrete]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
weights at boundaries
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
well-formed program,
see
program, well-formed
while
,
[lex.key]
,
[stmt.iter]
,
[stmt.for]
,
[gram.stmt]
white space,
[lex.token]
wide string literal,
[lex.string]
wide-character,
[lex.ccon]
null,
[lex.charset]
wide-character literal,
[lex.ccon]
wide-character set
basic execution,
[lex.charset]
execution,
[lex.charset]
width,
[basic.fundamental]
,
[class.bit]
,
[format.string.std]
worse conversion sequence,
see
conversion sequence, worse
X
xor
,
[lex.key]
xor_eq
,
[lex.key]
xvalue,
[basic.lval]
Y
Y
ℓ
m
(spherical associated Legendre functions),
[sf.cmath.sph.legendre]
Z
zero
division by undefined,
[expr.pre]
remainder undefined,
[expr.pre]
undefined division by,
[expr.mul]
zero-initialization,
[dcl.init]
zeta functions
ζ
,
[sf.cmath.riemann.zeta]