## operator, [cpp.concat]
#define, [cpp.replace]
#elif, [cpp.cond]
#else, [cpp.cond]
#endif, [cpp.cond]
#ifdef, [cpp.cond]
#ifndef, [cpp.cond]
..., see ellipsis
bit-field declaration, [class.bit]
label specifier, [stmt.label]
_­_­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_­conditional_­explicit, [cpp.predefined]
_­_­cpp_­constexpr, [cpp.predefined]
_­_­cpp_­coroutines, [cpp.predefined]
_­_­cpp_­decltype, [cpp.predefined]
_­_­cpp_­decltype_­auto, [cpp.predefined]
_­_­cpp_­deduction_­guides, [cpp.predefined]
_­_­cpp_­delegating_­constructors, [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_­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_­namespace_­attributes, [cpp.predefined]
_­_­cpp_­noexcept_­function_­type, [cpp.predefined]
_­_­cpp_­nontype_­template_­args, [cpp.predefined]
_­_­cpp_­nontype_­template_­parameter_­auto, [cpp.predefined]
_­_­cpp_­nontype_­template_­parameter_­class, [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_­variable_­templates, [cpp.predefined]
_­_­cpp_­variadic_­templates, [cpp.predefined]
_­_­cpp_­variadic_­using, [cpp.predefined]
_­_­has_­cpp_­attribute, [cpp.cond]
_­_­has_­include, [cpp.cond]
__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]
__VA_­ARGS__, [cpp.replace], [cpp.subst]
__VA_­OPT__, [cpp.replace], [cpp.subst]
block statement, [stmt.block]
class declaration, [class]
class definition, [class]
enum declaration, [dcl.enum]
initializer list, [dcl.init.aggr]
0, see also zero, null
null character, see character, null
string terminator, [lex.string]
template function, see template, function, abbreviated
absolute path, [fs.class.path]
abstract class, see class, abstract
access control, [class.access]
anonymous union, [class.union.anon]
base class member, [class.derived]
class member, [expr.ref]
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]
using-declaration and, [namespace.udecl]
virtual function, [class.access.virt]
union member, [class.union]
addition operator, see operator, addition
addressable function, [namespace.std]
aggregate initialization, [dcl.init.aggr]
<algorithm>, [algorithm.syn]
alias template, [temp.alias]
alignment, [basic.align]
extended, [basic.align]
fundamental, [basic.align]
new-extended, [basic.align]
stricter, [basic.align]
stronger, [basic.align]
alignment requirement
implementation-defined, [basic.align]
allocated type, see type, allocated
alignment storage, []
implementation-defined bit-field, [class.bit]
unspecified, [class.mem]
allocation functions, []
alternative token, see token, alternative
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, []
ambiguous conversion sequence, see conversion sequence, ambiguous
Amendment 1, [extern.names]
and_­eq, [lex.key]
anonymous union, [class.union.anon]
anonymous union object, [class.union.anon]
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, []
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
argument and virtual function
argument forwarding call wrapper, [func.require]
argument list
empty, [dcl.fct]
variable, [dcl.fct]
argument passing, []
reference and, [dcl.init.ref]
argument substitution, see macro, argument substitution
argument type
unknown, [dcl.fct]
pointer, [expr.add]
<array>, [array.syn]
as aggregate, [array.overview]
contiguous storage, [array.overview]
handler of type, [except.handle]
overloading and pointer versus, [over.load]
parameter of type, [dcl.fct]
template parameter of type, [temp.param]
tuple interface to, [array.tuple]
zero sized, []
array size
default, [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]
and lvalue, [expr.ass]
conversion by, [expr.ass]
reference, [dcl.init.ref]
assignment operator
copy, [special], [class.copy.assign]
implicitly declared, [class.copy.assign]
implicitly defined, [class.copy.assign]
non-trivial, [class.copy.assign]
virtual bases and, [class.copy.assign]
overloaded, [over.ass]
associated constraints, [temp.constr.decl]
associative containers
exception safety, [associative.reqmts.except]
asynchronous provider, [futures.state]
asynchronous return object, [futures.state]
at least as constrained, [temp.constr.order]
at least as specialized as, see more specialized
<atomic>, [atomics.syn]
atomic constraint, [temp.constr.atomic]
atomic operations, see operation, atomic
atomic smart pointers, [util.smartptr.atomic]
declaration, [module.unit]
entity, []
attribute, [dcl.attr]
alignment, [dcl.align]
carries dependency, [dcl.attr.depend]
maybe unused, [dcl.attr.unused]
no unique address, [dcl.attr.nouniqueaddr]
syntax and semantics, [dcl.attr.grammar]
automatic storage duration, see storage duration, automatic
backslash character, [lex.ccon]
bad_­alloc, []
bad_­typeid, [expr.typeid]
base characteristic, [meta.rqmts]
base class, [class.derived], [class.mi]
dependent, [temp.dep.type]
indirect, [class.derived]
non-virtual, [class.mi]
overloading and, [over.dcl]
base class subobject, [intro.object]
base-2 representation, [basic.fundamental]
Bernoulli distributions, [rand.dist.bern]
discrete probability function, [rand.dist.bern.bernoulli]
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 right fold, [expr.prim.fold]
bind directly, [dcl.init.ref]
reference, [dcl.init.ref]
discrete probability function, [rand.dist.bern.bin]
<bit>, [bit.syn]
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]
bitor, [lex.key]
<bitset>, [bitset.syn]
block, [defns.block]
initialization in, [stmt.dcl]
block scope, [basic.scope.block]
block statement, see statement, compound
block structure, [stmt.dcl]
block with forward progress guarantee delegation, [intro.progress]
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]
names that want to eat your, [zombie.names]
break, [lex.key]
buckets, [unord.req]
built-in candidate, [over.match.oper]
built-in operators, see operators, built-in
linkage to, []
standard, [intro.scope]
standard library, [intro.refs]
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]
callable object, see object, callable
callable type, see type, callable, [func.wrap.func]
candidate function, [over.match]
carries a dependency, [intro.races]
subtract_­with_­carry_­engine, [rand.eng.sub]
casting away constness, [expr.const.cast]
interfering with canines, [hardware.interference]
probability density function, [rand.dist.norm.cauchy]
<cctype>, [cctype.syn]
<cfenv>, [cfenv.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]
regular expression traits, [re.req]
character, [defns.character]
decimal-point, [character.seq]
source file, [lex.phases]
terminating null, [byte.strings]
underscore, []
in identifier, []
character literal, see literal, character
character sequence, [character.seq]
character set, [lex.charset]
basic execution, [lex.charset], [intro.memory]
execution, [lex.charset]
character string, [lex.string]
character string literal, [cpp.stringize]
<charconv>, [charconv.syn]
point of error, [temp.res]
syntax, [temp.res]
probability density function, [rand.dist.norm.chisq]
<chrono>, [time.syn]
<cinttypes>, [cinttypes.syn]
class, [lex.key], [basic.compound], [dcl.enum], [class], [temp.param], [gram.dcl], [gram.class], [gram.temp]
cast to incomplete, [expr.cast]
constructor and abstract, [class.abstract]
definition, [basic.def.odr]
derived, [derivation]
linkage of, []
linkage specification, []
member function, see member function, class
polymorphic, [class.virtual]
scope of enumerator, [dcl.enum]
standard-layout, [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 name
point of declaration, []
scope of, []
class object
assignment to, [expr.ass]
member, [class.mem]
class object copy, see constructor, copy
class object initialization, see constructor
closure object, [expr.prim.lambda]
co_­await, [lex.key], [expr.await]
co_­yield, [lex.key], [expr.yield]
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
common comparison type, [class.spaceship]
common initial sequence, [class.mem]
pointer, [expr.eq]
pointer to function, [expr.eq]
undefined pointer, [expr.add]
comparison category types, [cmp.categories.pre]
compatible with
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]
composite pointer type, [expr.type]
macro argument, see ## operator
string, [lex.string]
concurrent forward progress guarantees, [intro.progress]
rules for, [stmt.stmt]
<condition_­variable>, [condition.variable.syn]
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]
method of description, [intro.compliance]
conjunction, [temp.constr.op]
linkage, []
linkage specification, []
type declaration, []
const object, see object, const
undefined change to, []
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_­local_­iterator, [unord.req]
constant expression, see expression, constant, [expr.const]
permitted result of, [expr.const]
constant initialization, [basic.start.static]
constant initializer, [expr.const]
constant subexpression, [defns.const.subexpr]
constexpr function, [dcl.constexpr]
constexpr if, [stmt.if]
constexpr iterators, [iterator.requirements.general]
constituent expression, [intro.execution]
constraint, [temp.constr.constr]
associated, see associated constraints
immediately-declared, [temp]
normalization, [temp.constr.normal]
conjunction, [temp.constr.op]
disjunction, [temp.constr.op]
subsumption, [temp.constr.order]
construction, [class.cdtor]
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]
constructor, [class.ctor]
address of, [class.ctor]
array of class objects and, [class.expl.init]
converting, [class.conv.ctor]
explicit call, [class.ctor]
implicitly called, [class.default.ctor]
implicitly defined, [class.default.ctor]
inheritance of, [class.default.ctor]
move, [special], [class.copy.ctor]
implicitly declared, [class.copy.ctor]
implicitly defined, [class.copy.ctor]
non-trivial, [class.copy.ctor]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
constructor, conversion by, see conversion, user-defined
contained value
contains a value
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, [container.requirements.general]
continue, [lex.key]
and handler, [except]
and try block, [except]
contract condition, [dcl.attr.contract.cond]
contract violation, [dcl.attr.contract.check]
control line, see preprocessing directive
argument, [dcl.fct]
array-to-pointer, [conv.array]
boolean, [conv.bool]
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, []
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 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, []
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]
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, []
implicit, []
indistinguishable, [over.ics.rank]
standard, [conv]
user-defined, [over.ics.user]
converted constant expression, see expression, converted constant
converting constructor, see constructor, converting
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>, [coroutine.syn]
coroutine return, see co_­return
coroutine state, [dcl.fct.def.coroutine]
Cpp17BinaryTypeTrait, [meta.rqmts]
Cpp17CopyInsertable into X, [container.requirements.general]
Cpp17DefaultInsertable into X, [container.requirements.general]
Cpp17EmplaceConstructible into X from args, [container.requirements.general]
Cpp17Erasable from X, [container.requirements.general]
Cpp17MoveInsertable into X, [container.requirements.general]
Cpp17TransformationTrait, [meta.rqmts]
Cpp17UnaryTypeTrait, [meta.rqmts]
<cstdint>, [cstdint.syn]
<ctype.h>, [cctype.syn]
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-unqualified type, see type, cv-unqualified
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]
deallocation function
deallocation functions, []
decimal floating literal, see literal, decimal floating
decl-reachable, []
declaration, [basic.def], [basic], [dcl.dcl]
bit-field, [class.bit]
class name, [basic.def]
constant pointer, [dcl.ptr]
default argument, [dcl.fct.default]
definition versus, [basic.def]
ellipsis in function, [], [dcl.fct]
enumerator point of, [basic.scope.pdecl]
extern, [basic.def]
extern reference, [dcl.init.ref]
forward, []
forward class, []
local class, [class.local]
member, [class.mem]
multiple, []
object, [dcl.dcl]
opaque enum, [basic.def]
overloaded, [over]
overloaded name and friend, [class.friend]
pointer, [dcl.ptr]
reference, [dcl.ref]
static member, [basic.def]
storage class, []
structured binding, see structured binding declaration
typedef as type, [dcl.typedef]
declaration hiding, see name hiding
declarative region, [basic.scope.declarative]
declarator, [basic.def], [dcl.dcl], [dcl.decl]
function, [dcl.fct]
meaning of, [dcl.meaning]
multidimensional array, [dcl.array]
pointer, [dcl.ptr]
pointer-to-member, [dcl.mptr]
reference, [dcl.ref]
decrement operator
class template argument, []
placeholder type, []
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, []
default-initialization, [dcl.init]
deferred function, [futures.async]
define, [basic.def]
defined, [cpp.cond]
definition, [basic.def], [basic.def]
class name as type, []
declaration as, [dcl.dcl]
function, [dcl.fct.def]
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, []
static member, []
virtual function, [class.virtual]
definitions, [intro.defs]
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>, [deque.syn]
dereferencing, see indirection
derivation, see inheritance
derived class, [class.derived]
derived object
destringization, [cpp.pragma.op]
destroying operator delete, see operator delete, destroying
destruction, [class.cdtor]
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], [functions.within.classes]
default, [class.dtor]
explicit call, [class.dtor]
implicit call, [class.dtor]
implicitly defined, [class.dtor]
non-trivial, [class.dtor]
program termination and, [class.dtor]
pure virtual, [class.dtor]
virtual, [class.dtor]
diagnosable rules, [intro.compliance]
diagnostic message, see message, diagnostic
direct base class, see base class, direct
direct member, [class.mem]
direct-initialization, [dcl.init]
direct-list-initialization, [dcl.init.list]
direct-non-list-initialization, []
directed acyclic graph, see DAG
directive, preprocessing, see preprocessing directive
directory, [fs.general]
random number engine requirement, [rand.req.eng]
generation algorithm, [rand.adapt.disc]
textual representation, [rand.adapt.disc]
transition algorithm, [rand.adapt.disc]
declaration, []
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, []
discrete probability function, [rand.dist.samp.discrete]
disjunction, [temp.constr.op]
distribution, see random number distribution
obliviousness to interference, [hardware.interference]
domain error, [sf.cmath]
virtual base class, [class.member.lookup]
dynamic binding, see function, virtual
dynamic initialization, [basic.start.static]
dynamic type, see type, dynamic
E (complete elliptic integrals), [sf.cmath.comp.ellint.2]
E (incomplete elliptic integrals), [sf.cmath.ellint.2]
ECMA-262, [intro.refs]
Ei (exponential integrals), [sf.cmath.expint]
elaborated type specifier, see class name, elaborated
element access functions, [algorithms.parallel.defns]
copy constructor, see constructor, copy, elision
move constructor, see constructor, move, elision
conversion sequence, [], [over.ics.ellipsis]
overload resolution and, [over.match.viable]
elliptic integrals
incomplete E, [sf.cmath.ellint.2]
incomplete F, [sf.cmath.ellint.1]
incomplete Π, [sf.cmath.ellint.3]
empty future object, [futures.unique.future]
empty shared_­future object, [futures.shared.future]
enclosing namespace set, [namespace.def]
enclosing statement, [stmt.stmt]
encoded character type, [fs.req]
multibyte, [lex.string]
end-of-file, [bitset.operators]
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]
local, [basic]
templated, [temp]
enum name
typedef, [dcl.typedef]
enumerated element, [enumerated.types]
enumerated type, see type, enumerated
enumeration, [dcl.enum]
linkage of, []
scoped, [dcl.enum]
unscoped, [dcl.enum]
enumeration type
conversion to, [expr.static.cast]
conversion to, [expr.static.cast]
definition, [basic.def.odr]
scoped, [dcl.enum]
unscoped, [dcl.enum]
value of, [dcl.enum]
strong structural, []
template type, [temp.type]
expressions, []
function templates, []
functionally, see functionally equivalent
template-heads, []
template-parameters, []
equivalent parameter declarations, [over.load]
overloading and, [over.load]
equivalent-key group, [unord.req]
equivalently-valued, [allocator.requirements]
<errno.h>, [errno]
escape character, see backslash character
escape sequence
undefined, [lex.ccon]
Eulerian integral of the first kind, see beta
evaluation, [intro.execution]
order of argument, []
signal-safe, [support.signal]
unspecified order of argument, []
unspecified order of function call, []
<exception>, [exception.syn]
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]
goto, [except]
handler, [except], [except.throw], [except.handle], [res.on.exception.handling]
array in, [except.handle]
incomplete type in, [except.handle]
pointer to function in, [except.handle]
rvalue reference in, [except.handle]
nearest handler, [except.throw]
rethrowing, [except.throw]
switch, [except]
try block, [except]
exception specification, [except.spec], [except.spec]
constant expression and, [except.spec]
non-throwing, [except.spec]
potentially-throwing, [except.spec]
virtual function and, [except.spec]
<execution>, [execution.syn]
execution policy, [execpol.general]
execution step, [intro.progress]
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]
probability density function, [rand.dist.pois.exp]
expression, [expr.pre]
additive operators, [expr.add]
assignment and compound assignment, [expr.ass]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
conditional operator, [expr.cond]
const cast, [expr.const.cast]
converted constant, [expr.const]
core constant, [expr.const]
destructor call, []
dynamic cast, [expr.dynamic.cast]
equality operators, [expr.eq]
equality-preserving, [concepts.equality]
equivalent, see equivalent, expressions
function call, []
functionally equivalent, see functionally equivalent, expressions
integral constant, [expr.const]
left-shift-operator, [expr.shift]
logical AND, [expr.log.and]
logical OR, [expr.log.or]
multiplicative operators, [expr.mul]
order of evaluation of, [expr.pre]
parenthesized, [expr.prim.paren]
pointer-to-member, [expr.mptr.oper]
pointer-to-member constant, [expr.unary.op]
postfix, []
potentially constant evaluated, [expr.const]
potentially evaluated, [basic.def.odr]
primary, [expr.prim]
pseudo-destructor call, []
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]
spaceship, [expr.spaceship]
static cast, [expr.static.cast]
three-way comparison, [expr.spaceship]
type identification, [expr.typeid]
type-dependent, [temp.dep]
unary operator, [expr.unary.op]
value-dependent, [temp.dep]
expression-equivalent, [defns.expression-equivalent]
extend, see namespace, extend
extended alignment, [basic.align]
extended integer type, [basic.fundamental]
extended signed integer type, [basic.fundamental]
extended unsigned integer type, [basic.fundamental]
extern template, see instantiation, explicit
external linkage, []
probability density function, [rand.dist.pois.extreme]
F (incomplete elliptic integrals), [sf.cmath.ellint.1]
false, [lex.key]
file system, [fs.general]
file system race, [fs.race.behavior]
file, source, see source file
<filesystem>, [fs.filesystem.syn]
final overrider, [class.virtual]
final suspend point, [dcl.fct.def.coroutine]
finite state machine, [defns.regex.collating.element]
probability density function, [rand.dist.norm.f]
floating literal, see literal, floating
floating-point literal, see literal, floating
floating-point promotion, [conv.fpprom]
floating-point type, see type, floating-point
implementation-defined, [basic.fundamental]
forward, [forward]
forward progress guarantees
concurrent, [intro.progress]
delegation of, [intro.progress]
weakly parallel, [intro.progress]
<forward_­list>, [forward.list.syn]
forwarding reference, []
free store, see also new, delete, []
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]
linkage of, [class.friend]
member function and, [class.friend]
nested class, [class.nest]
<fstream>, [fstream.syn]
full-expression, [intro.execution]
function, see also friend function; member function; inline function; virtual function
comparison, [defns.comparison]
conversion, [class.conv.fct]
definition, [basic.def.odr]
handler of type, [except.handle]
inline, [dcl.inline]
linkage specification overloaded, []
named by expression or conversion, [basic.def.odr]
needed for constant evaluation, [expr.const]
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]
template parameter of type, [temp.param]
viable, [over.match]
virtual function call, []
virtual member, [derived.classes]
function argument, see argument
function call, []
recursive, []
function call operator
overloaded, []
function object, [function.objects]
binders, [func.bind]
mem_­fn, [func.memfn]
reference_­wrapper, [refwrap]
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-definition, [dcl.fct.def.general]
function-like macro, see macro, function-like
function-local predefined variable, see variable, function-local predefined
<functional>, [functional.syn]
functionally equivalent
expressions, []
function templates, []
template-heads, []
fundamental alignment, [basic.align]
fundamental type, [basic.fundamental]
destructor and, [class.dtor]
fundamental type conversion, see conversion, user-defined
<future>, [future.syn]
shared state, [futures.state]
probability density function, [rand.dist.pois.gamma]
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]
discrete probability function, [rand.dist.bern.geo]
global module, see module, global
global module fragment, []
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]
and try block, [except]
initialization and, [stmt.dcl]
grammar, [gram]
regular expression, [re.grammar]
(Hermite polynomials), [sf.cmath.hermite]
happens after, [intro.races]
happens before, [intro.races]
instantiation restrictions, [unord.hash]
hash code, [unord.req]
hash function, [unord.req]
header unit, [module.import]
preprocessing, [cpp.module]
C library, [depr.c.headers]
heap with respect to comp and proj, [alg.heap.operations]
Hermite polynomials , [sf.cmath.hermite]
hexadecimal floating literal, see literal, hexadecimal floating
hiding, see name hiding
high-order bit, [intro.memory]
hosted implementation, [intro.compliance]
(Bessell functions), [sf.cmath.cyl.bessel.i]
id-expression, []
atomic constraints, see atomic constraint, identical
identifier label, [stmt.label]
ill-formed program, see program, ill-formed
immediate function, [dcl.constexpr]
immediate function context, [expr.const]
immediate invocation, [expr.const]
immediate subexpression, [intro.execution]
freestanding, [compliance], [compliance]
hosted, [compliance]
implementation limits, see limits, implementation
implementation-defined behavior, see behavior, implementation-defined
implementation-generated, [basic.def]
implicit conversion, see conversion, implicit
implicit conversion sequence, see conversion sequence, implicit
implicit object parameter, [over.match.funcs]
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]
importable header, see header, importable
incomplete, [expr.add]
incompletely-defined object type, see object type, incompletely-defined
increment operator
generation algorithm, [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]
initial suspend point, [dcl.fct.def.coroutine]
initialization, [basic.start.static], [dcl.init]
aggregate, [dcl.init.aggr]
array of class objects, [dcl.init.aggr], [class.expl.init]
automatic, [stmt.dcl]
automatic object, [dcl.init]
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 member, [class.base.init]
default, [dcl.init]
default constructor and, [class.init]
definition and, [dcl.dcl]
direct, [dcl.init]
dynamic block-scope, [stmt.dcl]
dynamic non-local, [basic.start.dynamic]
jump past, [stmt.dcl]
list-initialization, [dcl.init.list]
local static, [stmt.dcl]
local thread_­local, [stmt.dcl]
member function call during, [class.base.init]
member object, [class.base.init]
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, []
reference member, [class.base.init]
static and thread, [basic.start.static]
static member, []
vacuous, []
virtual base class, [class.copy.ctor]
zero-initialization, [dcl.init]
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]
initializing declaration, [dcl.init]
injected-class-name, [class]
inline function, [dcl.inline], see function, inline
inline namespace, see namespace, inline
inline namespace set, [namespace.def]
inline variable, see variable, inline
explicit, [temp.explicit]
point of, [temp.point]
template implicit, [temp.inst]
instantiation context, [module.context]
instantiation units, [lex.phases]
integer literal, see literal, integer
integer representation, []
integer type, [basic.fundamental]
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, []
interval boundaries
piecewise_­constant_­distribution, [rand.dist.samp.pconst]
piecewise_­linear_­distribution, [rand.dist.samp.plinear]
<inttypes.h>, [cinttypes.syn]
invalid pointer value, see value, invalid pointer
<iomanip>, [iomanip.syn]
<ios>, [ios.syn]
<iosfwd>, [iosfwd.syn]
<iostream>, [iostream.syn]
regular expression traits, [re.req]
<istream>, [istream.syn]
iteration-statement, [stmt.break], [stmt.cont]
(spherical Bessel functions), [sf.cmath.sph.bessel]
(Bessell functions), [sf.cmath.cyl.bessel.j]
K (complete elliptic integrals), [sf.cmath.comp.ellint.1]
(Bessell functions), [sf.cmath.cyl.bessel.k]
(Laguerre polynomials), [sf.cmath.laguerre]
(associated Laguerre polynomials), [sf.cmath.assoc.laguerre]
lambda-introducer, [dcl.type.simple]
language linkage, []
lattice, see DAG, subobject
bit-field, [class.bit]
class object, [class.mem], [class.mi]
layout-compatible, [basic.types]
enumeration, [dcl.enum]
layout-compatible type, [basic.types]
left shift
undefined, [expr.shift]
left shift operator, see operator, left shift
Legendre functions , [sf.cmath.sph.legendre]
Legendre polynomials
lexical conventions, see conventions, lexical
library clauses, [intro.structure]
lifetime, []
<limits>, [limits.syn]
implementation, [defns.impl.limits]
line number, [cpp.line]
line splicing, [lex.phases]
generation algorithm, [rand.eng.lcong]
textual representation, [rand.eng.lcong]
transition algorithm, [rand.eng.lcong]
linkage, [basic], [], []
const and, []
implementation-defined object, []
inline and, []
internal, []
module, []
static and, []
linkage specification, see specification, linkage
linkage-specification, []
<list>, [list.syn]
list-initialization, [dcl.init.list]
literal, [lex.literal], [expr.prim.literal]
base of integer, [lex.icon]
binary, [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]
decimal, [lex.icon]
decimal floating, [lex.fcon]
double, [lex.fcon]
float, [lex.fcon]
floating, [lex.fcon]
hexadecimal, [lex.icon]
hexadecimal floating, [lex.fcon]
implementation-defined value of char, [lex.ccon]
long double, [lex.fcon]
multicharacter, [lex.ccon]
implementation-defined value of, [lex.ccon]
narrow-character, [lex.ccon]
octal, [lex.icon]
operator, [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]
undefined change to, [lex.string]
UTF-16, [lex.string]
UTF-32, [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, [basic.types]
living dead
local class, see class, local
member function in, [class.mfct]
scope of, [class.local]
local entity, see entity, local
local scope, see block scope
local variable, [basic.scope.block]
destruction of, [stmt.jump], [stmt.dcl]
local_­iterator, [unord.req]
locale-specific behavior, see behavior, locale-specific
<locale.h>, [clocale.syn]
lock-free execution, [intro.progress]
probability density function, [rand.dist.norm.lognormal]
argument-dependent, [basic.lookup.argdep]
elaborated type specifier, [basic.lookup.elab]
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]
regular expression traits, [re.req], [re.grammar]
regular expression traits, [re.req]
low-order bit, [intro.memory]
lowercase, [character.seq]
lvalue reference, [dcl.ref]
Lvalue-Callable, [func.wrap.func]
argument substitution, [cpp.subst]
function-like, [cpp.replace], [cpp.replace]
arguments, [cpp.replace]
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]
macro definition, [cpp.module]
active, [cpp.module]
point of definition, [cpp.module]
point of undefinition, [cpp.module]
macro import, [cpp.module]
point of, [cpp.module]
main function, [basic.start.main]
implementation-defined linkage of, [basic.start.main]
implementation-defined parameters to, [basic.start.main]
parameters to, [basic.start.main]
make progress
manifestly constant-evaluated, [expr.const]
as sequence, [re.results]
mathematical special functions, [sf.cmath]
random number distribution requirement, [rand.req.dist]
normal_­distribution, [rand.dist.norm.normal]
poisson_­distribution, [rand.dist.pois.poisson]
class static, []
default initializer, [class.mem]
enumerator, [dcl.enum]
template and static, [temp.static]
member access operator
overloaded, [over.ref]
member candidate, [over.match.oper]
member data
member function, [class.mem]
call undefined, [class.mfct.non-static]
const volatile, [class.mfct.non-static]
constructor and, [class.ctor]
destructor and, [class.dtor]
inline, [class.mfct]
local class, [class.local]
nested class, [class.access.nest]
overload resolution and, [over.match.funcs]
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]
<memory>, [memory.syn]
memory location, [intro.memory]
memory management, see new, delete
memory model, [intro.memory]
<memory_­resource>, [mem.res.syn]
generation algorithm, [rand.eng.mers]
textual representation, [rand.eng.mers]
transition algorithm, [rand.eng.mers]
random number distribution requirement, [rand.req.dist]
modifiable, [basic.lval]
modification order, [intro.races]
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]
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
<mutex>, [mutex.syn]
(spherical Neumann functions), [sf.cmath.sph.neumann]
(Neumann functions), [sf.cmath.cyl.neumann]
name, [], [basic], []
address of cv-qualified, [expr.unary.op]
dependent, [temp.dep]
length of, []
macro, see macro, name
point of declaration, [basic.scope.pdecl]
predefined macro, see macro, predefined
same, [basic]
name class, see class name
name hiding, [basic.scope.pdecl], [basic.scope.hiding], [], [stmt.dcl]
class definition, []
function, [over.dcl]
overloading versus, [over.dcl]
user-defined conversion and, [class.conv]
using-declaration and, [namespace.udecl]
name space
named module, see module, named
namespace scope
namespaces, [basic.namespace]
narrow character type, [basic.fundamental]
narrowing conversion, [dcl.init.list]
native encoding, [fs.path.type.cvt]
native pathname format, [fs.class.path]
necessarily reachable, see reachablenecessarily
exception specification, [except.spec]
needed for constant evaluation, [expr.const]
discrete probability function, [rand.dist.bern.negbin]
nested class, see class, nested
local class, [class.local]
scope of, [class.nest]
nested within, [intro.object]
<new>, [new.syn]
new, [lex.key], [], [], [temp.dep.expr], [gram.expr]
array of class objects and, []
constructor and, []
default constructor and, []
exception and, []
initialization and, []
scoping and, []
storage allocation, []
type of, []
unspecified constructor and, []
unspecified order of evaluation, []
placement, []
new-extended alignment, [basic.align]
no linkage, []
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
probability density function, [rand.dist.norm.normal]
standard deviation, [rand.dist.norm.normal]
normative references, see references, normative
not_­eq, [lex.key]
syntax, [syntax]
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]
numeric type, see type, numeric
numeric_­limits, [limits.syn]
specializations for arithmetic types, [basic.fundamental]
object, see also object model, [basic], [intro.object]
byte copying and, [basic.types]
callable, [func.def]
complete, [intro.object]
const volatile, [basic.type.qualifier]
definition, [basic.def.odr]
destructor and placement of, [class.dtor]
destructor static, [basic.start.term]
linkage specification, []
local static, []
nested within, [intro.object]
nonzero size, [intro.object]
providing storage for, [intro.object]
unnamed, [class.ctor]
zero size, [intro.object]
object class, see class object
object expression, [expr.ref], [expr.mptr.oper]
object lifetime, []
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.oper], [over.literal], [gram.class], [gram.over]
addition, [expr.add]
additive, [expr.add]
address-of, [expr.unary]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
conditional expression, [expr.cond]
copy assignment, see assignment operator, copy
division, [expr.mul]
equality, [expr.eq]
defaulted, [class.eq]
function call, [], [over.oper]
greater than, [expr.rel]
greater than or equal to, [expr.rel]
implementation, [over.oper]
indirection, [expr.unary]
inequality, [expr.eq]
defaulted, [class.eq]
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]
precedence of, [expr.pre]
relational, [expr.rel]
defaulted, [class.rel]
remainder, [expr.mul]
right shift, [expr.shift]
side effects and comma, [expr.comma]
side effects and logical AND, [expr.log.and]
side effects and logical OR, [expr.log.or]
spaceship, [expr.spaceship]
subscripting, [expr.sub], [over.oper]
subtraction, [expr.add]
three-way comparison, [expr.spaceship]
operator new, see also new, []
operator overloading, see overloading, operator
operator use
scope resolution, []
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
built-in, [expr.pre]
optimization of temporary, see temporary, elimination of
<optional>, [optional.syn]
optional object, [optional.general]
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 objects, [class.expl.init]
destructor, [class.dtor]
destructor and array, [class.dtor]
member constructor, [class.default.ctor]
member destructor, [class.dtor]
function template partial, see template, function, partial ordering
ordinary character literal, [lex.ccon]
ordinary string literal, [lex.string]
<ostream>, [ostream.syn]
over-aligned type, see type, over-aligned
overflow, [expr.pre]
undefined, [expr.pre]
overload resolution, [over]
overloaded function, see overloading
overloaded operator, see overloading, operator
inheritance of, [over.oper]
overloading, [dcl.fct], [], [over], [over], []
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]
function call operator, []
function versus pointer, [over.load]
member access operator, [over.ref]
operator, [over.oper]
prohibited, [over.load]
resolution, [over.match]
best viable function, []
better viable function, []
contexts, [over.match]
function call syntax, []
function template, [temp.over]
implicit conversions and, []
scoping ambiguity, [class.member.lookup]
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]
floating-point, [cmplx.over]
(Legendre polynomials), [sf.cmath.legendre]
(associated Legendre polynomials), [sf.cmath.assoc.legendre]
pack expansion, [temp.variadic]
padding bits, [basic.types]
tuple interface to, [pairs.general]
parallel algorithm, [algorithms.parallel.defns]
parallel forward progress guarantees, [intro.progress]
random number distribution requirement, [rand.req.dist]
seed sequence requirement, [rand.req.seedseq]
random number distribution requirement, [rand.req.dist]
parameter declaration, [basic.def]
parameter list
parameter mapping, [temp.constr.atomic]
parameter-type-list, [dcl.fct]
parameterized type, see template
parent directory, [fs.general]
path equality, [fs.path.nonmember]
pathname, [fs.class.path]
pathname resolution, [fs.class.path]
perfect forwarding call wrapper, [func.require]
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]
interval boundaries, [rand.dist.samp.pconst]
probability density function, [rand.dist.samp.pconst]
interval boundaries, [rand.dist.samp.plinear]
probability density function, [rand.dist.samp.plinear]
weights at boundaries, [rand.dist.samp.plinear]
placeholder type deduction, []
placement new-expression, see new-expression, placement
plain lock-free atomic operation, [support.signal]
point of declaration, [basic.scope.pdecl]
point of macro import, see macro import, point of
pointer, see also void*
composite pointer type, [expr.type]
integer representation of safely-derived, []
pointer literal, see literal, pointer
pointer past the end of, [basic.compound]
pointer to, [basic.compound]
pointer-interconvertible, [basic.compound]
Poisson distributions, [rand.dist.pois]
discrete probability function, [rand.dist.pois.poisson]
polymorphic class, see class, polymorphic
pool resource classes, [mem.res.pool.overview]
POSIX, [intro.refs]
extended regular expressions, [re.synopt]
regular expressions, [re.synopt]
postfix ++, []
postfix ++ and --
overloading, []
postfix --, []
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-overlapping subobject, [intro.object]
exception specification, [except.spec]
expression, [except.spec]
precedence of operator, see operator, precedence of
prefix ++, [expr.pre.incr]
prefix ++ and --
overloading, []
prefix --, [expr.pre.incr]
preprocessing, [cpp]
preprocessing directive, [cpp], [cpp]
conditional inclusion, [cpp.cond]
header inclusion, [cpp.include]
line control, [cpp.line]
macro replacement, see macro, replacement
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]
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 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 coroutinepromise type
promoted arithmetic type, [over.built]
promoted integral type, [over.built]
bool to int, [conv.prom]
default argument promotion, []
floating-point, [conv.fpprom]
integral, [conv.prom]
prototype parameter
provides storage, [intro.object]
prvalue, [basic.lval]
pseudo-destructor, []
ptrdiff_­t, [expr.add]
implementation-defined type of, [expr.add]
punctuator, [lex.operators]
global module, [module.unit]
module unit, [module.unit]
named module, [module.unit]
<queue>, [queue.syn]
<random>, [rand.synopsis]
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, []
uniform_­real_­distribution, [rand.dist.uni.real]
weibull_­distribution, [rand.dist.pois.weibull]
random number distributions
Bernoulli, [rand.dist.bern]
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
implementation leeway, [rand.device]
<ratio>, [ratio.syn]
raw string literal, [lex.string]
declaration, [module.reach]
declaration, [module.reach]
translation unit, [module.reach]
translation unit, [module.reach]
typedef, [dcl.typedef]
reference, [basic.compound]
assignment to, [expr.ass]
call by, []
forwarding, []
null, [dcl.ref]
reference collapsing, [dcl.ref]
reference lifetime, []
reference-compatible, [dcl.init.ref]
normative, [intro.refs]
<regex>, [re.syn]
end-of-sequence, [re.regiter]
end-of-sequence, [re.tokiter]
specializations, [re.traits]
register, [lex.key]
register storage class, [diff.cpp14.dcl.dcl]
regular expression, [re]
grammar, [re.grammar]
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_­primary, [re.req], [re.grammar]
translate_­nocase, [re.req], [re.grammar]
relative path, [fs.class.path]
relaxed pointer safety, []
release sequence, [intro.races]
remainder operator, see operator, remainder
remote time zone database, []
represents the address, [basic.compound]
requirements, [structure.requirements]
container, [container.requirements], [unord.req], [array.overview], [array.cons], [re.results]
not required for unordered associated containers, [unord.req]
Cpp17Allocator, [allocator.requirements]
Cpp17CopyAssignable, [utility.arg.requirements]
Cpp17CopyConstructible, [utility.arg.requirements]
Cpp17DefaultConstructible, [utility.arg.requirements]
Cpp17Destructible, [utility.arg.requirements]
Cpp17EqualityComparable, [utility.arg.requirements]
Cpp17LessThanComparable, [utility.arg.requirements]
Cpp17MoveAssignable, [utility.arg.requirements]
Cpp17MoveConstructible, [utility.arg.requirements]
Cpp17NullablePointer, [nullablepointer.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]
trailing, [dcl.decl]
rescanning and replacement, see macro, rescanning and replacement
reserved identifier, []
reset, [unique.ptr]
random number distribution requirement, [rand.req.dist]
resolution, see overloading, resolution
restriction, [res.on.arguments], [res.on.required], [res.on.macro.definitions], [res.on.exception.handling]
address of bit-field, [class.bit]
anonymous union, [class.union.anon]
bit-field, [class.bit]
constructor, [class.ctor]
destructor, [class.dtor]
extern, []
local class, [class.local]
operator overloading, [over.oper]
overloading, [over.oper]
pointer to bit-field, [class.bit]
reference, [dcl.ref]
static, []
static member local class, [class.local]
glvalue, [basic.lval]
prvalue, [basic.lval]
result object, [basic.lval]
entity characterization based on, [rand]
random number distribution requirement, [rand.req.dist]
seed sequence requirement, [rand.req.seedseq]
return, [lex.key], [stmt.jump], [stmt.return], [gram.stmt]
and handler, [except]
and try block, [except]
constructor and, [stmt.return]
reference and, [dcl.init.ref]
return statement, see return
return type, [dcl.fct]
covariant, [class.virtual]
overloading and, [over.load]
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]
safely-derived pointer, []
integer representation, []
sampling distributions, [rand.dist.samp]
scalar type, [basic.types]
scope, [intro.scope], [basic], [basic.scope], [basic.scope.declarative], [dcl.dcl]
anonymous union at namespace, [class.union.anon]
declarations and, [basic.scope.declarative]
destructor and exit from, [stmt.jump]
enumeration, [basic.scope.enum]
exception declaration, [basic.scope.block]
function parameter, [basic.scope.param]
function prototype, see scope, function parameter
iteration-statement, [stmt.iter]
macro definition, see macro, scope of definition
name lookup and, [basic.lookup]
overloading and, [over.dcl]
selection-statement, []
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>, [allocator.adaptor.syn]
random number engine requirement, [rand.req.eng]
seed sequence, [rand.req.seedseq]
requirements, [rand.req.seedseq]
class member, [expr.ref]
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
<setjmp.h>, [csetjmp.syn]
setlocale, [character.seq]
shared state, see future, shared state
<shared_­mutex>, [shared.mutex.syn]
shift operator
generation algorithm, [rand.adapt.shuf]
textual representation, [rand.adapt.shuf]
transition algorithm, [rand.adapt.shuf]
side effect
visible, [intro.races]
evaluation, see evaluation, signal-safe
forward, [forward]
initializer_­list functions, [support.initlist]
memmove, [cstring.syn]
move, [forward]
move_­if_­noexcept, [forward]
numeric_­limits members, [numeric.limits.members]
quick_­exit, [support.start.term]
type traits, [meta]
<signal.h>, [csignal.syn]
signed integer representation
ones' complement, [expr.unary.op]
signed integer type, [basic.fundamental]
significand, [lex.fcon]
similar types, [conv.qual]
simple call wrapper, [func.require]
simply happens before, [intro.races]
seed sequence requirement, [rand.req.seedseq]
size_­t, [expr.sizeof]
smart pointers, [util.smartptr.weak.bad]
source file character, see character, source file
<span>, [span.syn]
special member function, see constructor, see assignment operator, see destructor
class template, [temp.names]
class template partial, [temp.class.spec], [temp.class.spec]
program-defined, [defns.prog.def.spec]
template, [temp.spec]
template explicit, [temp.expl.spec]
linkage, []
extern, []
implementation-defined, []
nesting, []
template argument, [temp.arg.explicit]
C standard library exception, [res.on.exception.handling]
specifier, [dcl.spec]
consteval, [dcl.constexpr]
cv-qualifier, []
declaration, [dcl.spec]
explicit, [dcl.fct.spec]
function, [dcl.fct.spec]
inline, [dcl.inline]
static, []
storage class, []
type, see type specifier
typedef, [dcl.typedef]
specifier access, see access specifier
spherical harmonics , [sf.cmath.sph.legendre]
<sstream>, [sstream.syn]
<stack>, [stack.syn]
stack unwinding, [except.ctor]
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 types, [basic.types]
standard-layout union, see union, standard-layout
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]
compound, [stmt.block]
continue in for, [stmt.for]
declaration, [stmt.dcl]
declaration in for, [stmt.for]
declaration in if, [stmt.stmt]
declaration in switch, [stmt.stmt], [stmt.switch]
declaration in while, [stmt.while]
expression, [stmt.expr]
iteration, [stmt.iter]
labeled, [stmt.label]
range based for, [stmt.ranged]
selection, []
static, [lex.key], [], [gram.dcl]
destruction of local, [stmt.dcl]
linkage of, [], []
overloading and, [over.load]
static data member, [class.mem]
static initialization, [basic.start.static]
static member, [class.mem]
static member function, [class.mem]
static storage duration, []
static type, see type, static
static_­assert, [lex.key], [dcl.dcl], [gram.dcl]
not macro, [cassert.syn]
<stdarg.h>, [cstdarg.syn]
<stdio.h>, [cstdio.syn]
storage class, [basic]
storage management, see new, delete
arbitrary-positional, []
<streambuf>, [streambuf.syn]
strict pointer safety, []
<string>, [string.syn]
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]
string literal, see literal, string
<string.h>, [cstring.syn]
<string_­view>, [string.view.synop]
stringize, see # operator
stringizing argument, [cpp.stringize]
strong structural equality, see equality, strong structural
strongly happens before, [intro.races]
structural comparison operator, see operator, structural comparison
structure tag, see class name
structured binding, [dcl.struct.bind]
structured binding declaration, [dcl.struct.bind], [dcl.dcl]
probability density function, [rand.dist.norm.t]
subexpression, [intro.execution]
subnormal number, see number, subnormal
subscripting operator
overloaded, [over.sub]
subsequence rule
overloading, [over.ics.rank]
substatement, [stmt.stmt]
substitutability, [cmp.categories.pre]
generation algorithm, [rand.eng.sub]
textual representation, [rand.eng.sub]
transition algorithm, [rand.eng.sub]
implementation-defined pointer, [expr.add]
subtraction operator, see operator, subtraction
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, []
swappable with, [swappable.requirements]
switch, [lex.key], [], [stmt.switch], [gram.stmt]
and handler, [except]
and try block, [except]
synchronize with, [intro.races]
<syncstream>, [syncstream.syn]
synonym, [namespace.alias]
type name as, [dcl.typedef]
class member, [expr.ref]
<system_­error>, [system.error.syn]
target object, [func.def]
template instantiation, [temp.spec]
template name
linkage of, [temp]
template parameter, [basic.def]
template parameter object, [temp.param]
template parameter pack, [temp.variadic]
template parameter scope, [basic.scope.temp]
default, [temp.param]
templated entity, [temp]
temporary, [class.temporary]
constructor for, [class.temporary]
destruction of, [class.temporary]
destructor for, [class.temporary]
implementation-defined generation of, [class.temporary]
order of destruction of, [class.temporary]
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]
this pointer, see this
<thread>, [thread.syn]
thread of execution, [intro.multithread]
thread storage duration, see storage duration, thread
thread_­local, [lex.key], [], [gram.dcl]
<time.h>, [ctime.syn]
token, [lex.token]
alternative, [lex.digraph]
preprocessing, [lex.pptoken]
trailing requires-clause, see requires-clause, trailing
regular expression traits, [re.req], [re.grammar]
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]
regular expression traits, [re.req], [re.grammar]
regular expression traits, [re.req], [re.grammar]
phases, [lex.phases]
separate, see compilation, separate
translation unit, [lex.separate], []
name and, [basic]
trigraph sequence, [diff.cpp14.lex]
trivial class, see class, trivial
trivial types, [basic.types]
trivially copyable class, see class, trivially copyable
trivially copyable types, [basic.types]
true, [lex.key]
truncation, [conv.fpint]
<tuple>, [tuple.syn]
and pair, [pairs.general]
type, [basic], [basic.types]
allocated, []
arithmetic, [basic.fundamental]
promoted, [over.built]
callable, [func.def]
character container, [defns.character.container]
class and, [class]
const, [dcl.type]
cv-combined, [expr.type]
cv-unqualified, [basic.type.qualifier]
destination, [dcl.init]
example of incomplete, [basic.types]
extended integer, [basic.fundamental]
extended signed integer, [basic.fundamental]
extended unsigned integer, [basic.fundamental]
floating-point, [basic.fundamental]
fundamental, [basic.fundamental]
implementation-defined sizeof, [basic.fundamental]
incompletely-defined object, [basic.types]
long double, [basic.fundamental]
narrow character, [basic.fundamental]
over-aligned, [basic.align]
polymorphic, [class.virtual]
program-defined, [defns.prog.def.type]
referenceable, [defns.referenceable]
signed char, [basic.fundamental]
signed integer, [basic.fundamental]
similar, see similar types
standard integer, [basic.fundamental]
standard signed integer, [basic.fundamental]
standard unsigned integer, [basic.fundamental]
trivially copyable, [basic.types]
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]
volatile, [dcl.type]
type checking
argument, []
type concept, see concept, type
type conversion, explicit, see casting
type generator, see template
type-id-only context, [temp.res]
type_­info, [expr.typeid]
typedef, [lex.key], [dcl.spec], [gram.dcl]
function, [dcl.fct]
overloading and, [over.load]
<typeinfo>, [typeinfo.syn]
implementation-defined, [type.descriptions.general]
<uchar.h>, [cuchar.syn]
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]
undefined behavior, see behavior, undefined
unevaluated operand, [expr.context]
Unicode required set, [cpp.predefined]
uniform distributions, [rand.dist.uni]
uniform random bit generator
requirements, [rand.req.urng]
discrete probability function, []
probability density function, [rand.dist.uni.real]
union-like class, [class.union.anon]
unique pointer, [unique.ptr]
universal character name, [lex.phases]
unnamed bit-field, [class.bit]
unordered associative containers, [unord.req]
complexity, [unord.req]
equality function, [unord.req]
exception safety, [unord.req.except]
hash function, [unord.req]
iterator invalidation, [unord.req]
iterators, [unord.req]
lack of comparison functions, [unord.req]
<unordered_­map>, []
element access, []
equivalent keys, [unord.multimap.overview]
equivalent keys, [unord.multiset.overview]
<unordered_­set>, [unord.set.syn]
unscoped enumeration, see enumeration, unscoped
unsequenced, [intro.execution]
unsigned integer type, [basic.fundamental]
unspecified behavior, see behavior, unspecified
upstream allocator, [mem.res.pool.overview]
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, []
using-declaration, [namespace.udecl]
using-directive, [namespace.udir]
usual arithmetic conversions, see conversion, usual arithmetic
usual deallocation function, []
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]
vacuous initialization, []
<valarray>, [valarray.syn]
valid but unspecified state, [defns.valid]
value, [basic.types]
call by, []
denormalized, see number, subnormal
invalid pointer, [basic.compound]
null member pointer, [conv.mem]
undefined unrepresentable integral, [conv.fpint]
value category, [basic.lval]
value-initialization, [dcl.init]
variable, [basic]
function-local predefined, [dcl.fct.def.general]
indeterminate uninitialized, [dcl.init]
inline, [dcl.inline]
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]
<variant>, [variant.syn]
variant member, [class.union.anon]
<vector>, [vector.syn]
vectorization-unsafe, [algorithms.parallel.defns]
violation continuation mode, [dcl.attr.contract.check]
violation handler, [dcl.attr.contract.check]
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]
visible side effect, see side effect, visible
void&, [dcl.ref]
volatile, [lex.key], [basic.type.qualifier], [dcl.decl], [gram.dcl]
constructor and, [class.this], [class.ctor]
destructor and, [class.this], [class.dtor]
implementation-defined, []
overloading and, [over.load]
volatile object, see object, volatile
volatile-qualified, [basic.type.qualifier]
waiting function, [futures.state]
<wchar.h>, [cwchar.syn]
<wctype.h>, [cwctype.syn]
weakly parallel forward progress guarantees, [intro.progress]
probability density function, [rand.dist.pois.weibull]
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
white space, [lex.token]
wide string literal, [lex.string]
wide-character, [lex.ccon]
wide-character literal, [lex.ccon]
wide-character set
basic execution, [lex.charset]
execution, [lex.charset]
worse conversion sequence, see conversion sequence, worse
xor_­eq, [lex.key]
xvalue, [basic.lval]
(spherical associated Legendre functions), [sf.cmath.sph.legendre]
division by undefined, [expr.pre]
remainder undefined, [expr.pre]
undefined division by, [expr.mul]
zero-initialization, [dcl.init]
zeta functions ζ, [sf.cmath.riemann.zeta]