Index

## 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]
_­_­func_­_­, [dcl.fct.def.general]
__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]
{}
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]
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]
union default member, [class]
using-declaration and, [namespace.udecl]
virtual function, [class.access.virt]
active
union member, [class.union]
addition operator, see operator, addition
aggregate initialization, [dcl.init.aggr]
<algorithm>, [algorithm.syn]
alias
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]
allocation
alignment storage, [expr.new]
implementation-defined bit-field, [class.bit]
unspecified, [class.mem]
allocation functions, [basic.stc.dynamic]
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]
Amendment 1, [extern.names]
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, [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
argument and virtual function
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]
arithmetic
pointer, [expr.add]
<array>, [array.syn]
array
as aggregate, [array.overview]
contiguous storage, [array.overview]
handler of type, [except.handle]
multidimensional, [dcl.array]
overloading and pointer versus, [over.load]
parameter of type, [dcl.fct]
storage of, [dcl.array]
template parameter of type, [temp.param]
tuple interface to, [array.tuple]
zero sized, [array.zero]
array size
default, [dcl.array]
arrow operator, see operator, class member access
as-if rule, [intro.execution]
asm
implementation-defined, [dcl.asm]
assembler, [dcl.asm]
assignment
and lvalue, [expr.ass]
conversion by, [expr.ass]
reference, [dcl.init.ref]
assignment operator
overloaded, [over.ass]
associative containers
exception safety, [associative.reqmts]
requirements, [associative.reqmts]
asynchronous provider, [futures.state]
asynchronous return object, [futures.state]
at least as specialized as, see more specialized
<atomic>, [atomics.syn]
atomic operations, see operation, atomic
attribute, [dcl.attr]
alignment, [dcl.align]
carries dependency, [dcl.attr.depend]
maybe unused, [dcl.attr.unused]
syntax and semantics, [dcl.attr.grammar]
automatic storage duration, [basic.stc.auto]
backslash character, [lex.ccon]
bad_­alloc, [expr.new]
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]
virtual, [class.mi]
base class subobject, [intro.object]
Bernoulli distributions, [rand.dist.bern]
bernoulli_­distribution
discrete probability function, [rand.dist.bern.bernoulli]
beta functions B, [sf.cmath.beta]
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]
BinaryTypeTrait, [meta.rqmts]
bind directly, [dcl.init.ref]
binding
reference, [dcl.init.ref]
binomial_­distribution
discrete probability function, [rand.dist.bern.bin]
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]
bitmask
<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]
body
Boolean, [class.bit]
boolean literal, see literal, boolean, [lex.bool]
Boolean type, [basic.fundamental]
bound arguments, [func.bind.bind]
bound, of array, [dcl.array]
brains
names that want to eat your, [zombie.names]
buckets, [unord.req]
C
linkage to, [dcl.link]
standard, [intro.scope]
standard library, [intro.refs]
call
operator function, [over.oper]
pseudo destructor, [expr.pseudo]
call signature, [func.def]
call wrapper, [func.require], [func.def]
forwarding, [func.require]
callable object, [func.def]
carries a dependency, [intro.races]
carry
subtract_­with_­carry_­engine, [rand.eng.sub]
casting away constness, [expr.const.cast]
catch, [except]
cats
interfering with canines, [hardware.interference]
cauchy_­distribution
probability density function, [rand.dist.norm.cauchy]
<cctype>, [cctype.syn]
<cfenv>, [cfenv.syn]
char
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, see type, char16_­t
char16_­t character, [lex.ccon]
char32_­t, see type, char32_­t
char32_­t character, [lex.ccon]
character, [defns.character]
decimal-point, [character.seq]
source file, [lex.phases]
underscore, [lex.name]
in identifier, [lex.name]
character literal, see literal, character
character set, [lex.charset]
basic execution, [intro.memory], [lex.charset]
execution, [lex.charset]
character string, [lex.string]
character string literal, [cpp.stringize]
checking
point of error, [temp.res]
syntax, [temp.res]
chi_­squared_­distribution
probability density function, [rand.dist.norm.chisq]
<chrono>, [time.syn]
<cinttypes>, [cinttypes.syn]
class, [basic.compound], [class]
cast to incomplete, [expr.cast]
constructor and abstract, [class.abstract]
definition, [basic.def]
derived, [derivation]
linkage of, [basic.link]
linkage specification, [dcl.link]
local, see local class
member function, see member function, class
nested, see nested class
pointer to abstract, [class.abstract]
polymorphic, [class.virtual]
scope of enumerator, [dcl.enum]
standard-layout, [class]
trivial, [class]
trivially copyable, [class]
union-like, [class.union.anon]
unnamed, [dcl.typedef]
variant member of, [class.union.anon]
class name
point of declaration, [class.name]
scope of, [class.name]
class object
assignment to, [expr.ass]
member, [class.mem]
class object copy, see constructor, copy
class object initialization, see constructor
<clocale>, [character.seq]
closure object, [expr.prim.lambda]
collating element, [re.def]
comma operator, see operator, comma
common initial sequence, [class.mem]
comparison
pointer, [expr.eq]
pointer to function, [expr.eq]
undefined pointer, [expr.add]
compatible with
compilation
separate, [lex.separate]
compiler control line, see preprocessing directives
complete object, [intro.object]
complete object of, [intro.object]
completely defined, [class.mem]
composite pointer type, [expr]
concatenation
macro argument, see ## operator
string, [lex.string]
concurrent forward progress guarantees, [intro.progress]
conditions
rules for, [stmt.stmt]
<condition_­variable>, [condition_variable.syn]
conditional-expression
throw-expression in, [expr.cond]
conditionally-supported behavior, see behavior, conditionally-supported
conflict, [intro.races]
conformance requirements, [intro.compliance], [intro.execution]
class templates, [intro.compliance]
method of description, [intro.compliance]
consistency
linkage, [dcl.stc]
linkage specification, [dcl.link]
type declaration, [basic.link]
const, [basic.type.qualifier]
constructor and, [class.this], [class.ctor]
destructor and, [class.this], [class.dtor]
linkage of, [basic.link]
overloading and, [over.load]
const-object
undefined change to, [dcl.type.cv]
const-default-constructible, [dcl.init]
const-qualified, [basic.type.qualifier]
const-volatile-qualified, [basic.type.qualifier]
const_­cast, see cast, const
const_­local_­iterator, [unord.req]
constant expression, [expr.const]
permitted result of, [expr.const]
constant initialization, [basic.start.static]
constant initializer, [basic.start.static]
constant subexpression, [defns.const.subexpr]
constexpr function, [dcl.constexpr]
constexpr if, [stmt.if]
constituent expression, [intro.execution]
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]
default, [special], [class.ctor]
non-trivial, [class.ctor]
trivial, [class.ctor]
explicit call, [class.ctor]
implicitly called, [class.ctor]
implicitly defined, [class.ctor]
inheritance of, [class.ctor]
move, [special], [class.copy.ctor], [class.copy.ctor]
implicitly declared, [class.copy.ctor]
implicitly defined, [class.copy.ctor]
inaccessible, [class.copy]
non-trivial, [class.copy.ctor]
non-trivial, [class.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
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, [container.requirements.general]
contiguous iterators, [iterator.requirements.general]
continue
and handler, [except]
and try block, [except]
control line, see preprocessing directives
conventions
conversion
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, [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], [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]
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]
usual arithmetic, [expr]
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]
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]
CopyInsertable into X, [container.requirements.general]
<cstdbool>, [support.runtime]
<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
cv-decomposition, [conv.qual]
cv-qualification signature, [conv.qual]
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]
deallocation function
deallocation functions, [basic.stc.dynamic]
DECAY_­COPY, [thread.decaycopy]
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, [expr.call], [dcl.fct]
enumerator point of, [basic.scope.pdecl]
extern, [basic.def]
extern reference, [dcl.init.ref]
forward, [dcl.stc]
forward class, [class.name]
local class, [class.local]
member, [class.mem]
multiple, [basic.link]
opaque enum, [basic.def]
overloaded, [over]
overloaded name and friend, [class.friend]
pointer, [dcl.ptr]
reference, [dcl.ref]
static member, [basic.def]
storage class, [dcl.stc]
structured binding, see structured binding declaration
typedef, [basic.def]
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
deduction
class template argument, [temp.deduct.guide]
placeholder type, [dcl.type.auto.deduct]
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]
DefaultInsertable into X, [container.requirements.general]
deferred function, [futures.async]
defined, [cpp.cond]
definition, [basic.def], [basic.def]
class name as type, [class.name]
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]
pure virtual function, [class.abstract]
scope of class, [class.name]
static member, [class.static.data]
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 also indirection
derivation, see inheritance
derived class, [class.derived]
derived object
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 member, [class.mem]
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 directives
discard
random number engine requirement, [rand.req.eng]
discard_­block_­engine
generation algorithm, [rand.adapt.disc]
textual representation, [rand.adapt.disc]
transition algorithm, [rand.adapt.disc]
discarded statement, [stmt.if]
discarded-value expression, [expr]
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]
distribution, see random number distribution
dogs
obliviousness to interference, [hardware.interference]
domain error, [sf.cmath]
dominance
virtual base class, [class.member.lookup]
dynamic binding, see virtual function
dynamic initialization, [basic.start.static]
dynamic type, see type, dynamic
dynamic_­cast, see cast, 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]
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
incomplete E, [sf.cmath.ellint_2]
incomplete F, [sf.cmath.ellint_1]
incomplete Π, [sf.cmath.ellint_3]
EmplaceConstructible into X from args, [container.requirements.general]
empty future object, [futures.unique_future]
empty shared_­future object, [futures.shared_future]
encoded character type, [fs.req]
encoding
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]
templated, [temp]
enum, [basic.compound]
overloading and, [over.load]
type of, [dcl.enum]
underlying type, see type, underlying
enum name
typedef, [dcl.typedef]
enumeration, [dcl.enum]
linkage of, [basic.link]
scoped, [dcl.enum]
unscoped, [dcl.enum]
enumeration type
conversion to, [expr.static.cast]
static_­cast
conversion to, [expr.static.cast]
enumerator
definition, [basic.def]
value of, [dcl.enum]
environment
equivalence
template type, [temp.type]
equivalent
expression, see expression, equivalent
function template, see template, function, equivalent
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, [expr.call]
signal-safe, [support.signal]
unspecified order of argument, [expr.call]
unspecified order of function call, [expr.call]
example
class definition, [class.mem]
const, [dcl.ptr]
constant pointer, [dcl.ptr]
constructor, [class.ctor]
constructor and initialization, [class.expl.init]
declaration, [basic.def], [dcl.fct]
declarator, [dcl.name]
definition, [basic.def]
delete, [class.free]
derived class, [class.derived]
destructor and delete, [class.free]
ellipsis, [dcl.fct]
enumeration, [dcl.enum]
explicit destructor call, [class.dtor]
explicit qualification, [class.member.lookup]
friend, [class.name]
friend function, [class.friend]
function declaration, [dcl.fct]
function definition, [dcl.fct.def.general]
linkage consistency, [dcl.stc]
local class, [class.local]
nested class, [class.nest]
nested class definition, [class.nest], [class.access.nest]
nested class forward declaration, [class.nest]
nested type name, [class.nested.type]
pointer to member, [dcl.mptr]
pure virtual function, [class.abstract]
scope of delete, [class.free]
scope resolution operator, [class.member.lookup]
static member, [class.static.data]
subscripting, [dcl.array]
type name, [dcl.name]
typedef, [dcl.typedef]
unnamed parameter, [dcl.fct.def.general]
variable parameter list, [dcl.fct]
virtual function, [class.virtual]
exception
arithmetic, [expr]
undefined arithmetic, [expr]
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]
noexcept
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]
exponential integrals Ei, [sf.cmath.expint]
exponential_­distribution
probability density function, [rand.dist.pois.exp]
expression, [expr]
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]
dynamic cast, [expr.dynamic.cast]
equality operators, [expr.eq]
equivalent, [temp.over.link]
function call, [expr.call]
functionally equivalent, [temp.over.link]
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, [intro.execution]
parenthesized, [expr.prim.paren]
pointer to member constant, [expr.unary.op]
pointer-to-member, [expr.mptr.oper]
postfix, [expr.post]
primary, [expr.prim]
pseudo-destructor call, [expr.pseudo]
reference, [expr]
reinterpret cast, [expr.reinterpret.cast]
relational operators, [expr.rel]
right-shift-operator, [expr.shift]
rvalue reference, [expr]
static cast, [expr.static.cast]
type identification, [expr.typeid]
type-dependent, [temp.dep]
unary operator, [expr.unary.op]
value-dependent, [temp.dep]
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, [dcl.stc], [gram.dcl]
linkage of, [dcl.stc]
external linkage, [basic.link]
extreme_­value_­distribution
probability density function, [rand.dist.pois.extreme]
F (incomplete elliptic integrals), [sf.cmath.ellint_1]
file, source, see source file
<filesystem>, [fs.filesystem.syn]
final overrider, [class.virtual]
finite state machine, [defns.regex.collating.element]
fisher_­f_­distribution
probability density function, [rand.dist.norm.f]
floating literal, see literal, floating
floating-point literal, see literal, floating
floating-point type, [basic.fundamental]
implementation-defined, [basic.fundamental]
for
scope of declaration in, [stmt.for]
forward progress guarantees
concurrent, [intro.progress]
delegation of, [intro.progress]
weakly parallel, [intro.progress]
<forward_­list>, [forward_list.syn]
forwarding call wrapper, [func.require]
forwarding reference, [temp.deduct.call]
free store, see also new, delete, [class.free]
freestanding implementation, [intro.compliance]
friend
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]
handler of type, [except.handle]
linkage specification overloaded, [dcl.link]
operator, [over.oper]
overload resolution and, [over.match.funcs]
overloading and pointer versus, [over.load]
parameter of type, [dcl.fct]
pointer to member, [expr.mptr.oper]
replacement, [defns.replacement]
template parameter of type, [temp.param]
viable, [over.match]
virtual function call, [expr.call]
virtual member, [derived.classes]
function argument, see argument
function call, [expr.call]
recursive, [expr.call]
function call operator
overloaded, [over.call]
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 pointer type, [basic.compound]
function prototype, [basic.scope.proto]
function return, see return
function return type, see return type
function, overloaded, see overloading
function, virtual, see virtual function
function-definition, [dcl.fct.def.general]
function-like macro, see macro, function-like
functionally equivalent
functions
fundamental alignment, [basic.align]
fundamental type
destructor and, [class.dtor]
fundamental type conversion, see conversion, user-defined
<future>, [future.syn]
future
shared state, [futures.state]
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
definition of, [dcl.spec.auto]
geometric_­distribution
discrete probability function, [rand.dist.bern.geo]
global namespace, [basic.scope.namespace]
global namespace scope, [basic.scope.namespace]
glvalue, [basic.lval]
goto
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]
hash
instantiation restrictions, [unord.hash]
hash code, [unord.req]
hash function, [unord.req]
headers
C library, [depr.c.headers]
Hermite polynomials , [sf.cmath.hermite]
hiding, see name hiding
high-order bit, [intro.memory]
hosted implementation, [intro.compliance]
(Bessell functions), [sf.cmath.cyl_bessel_i]
id
id-expression, [expr.prim.id]
identifier label, [stmt.label]
ill-formed program, see program, ill-formed
immediate subexpression, [intro.execution]
implementation
freestanding, [compliance]
hosted, [compliance]
implementation limits, see limits, implementation
implementation-defined behavior, see behavior, implementation-defined
implementation-dependent, [istream::sentry]
implementation-generated, [basic.def]
implicit capture
implicit conversion, see conversion, implicit
implicit object parameter, [over.match.funcs]
implicitly-declared default constructor, see constructor, default, [class.ctor]
implied object argument, [over.match.funcs]
implicit conversion sequences, [over.match.funcs]
non-static member function and, [over.match.funcs]
incomplete, [expr.add]
increment operator
independent_­bits_­engine
generation algorithm, [rand.adapt.ibits]
textual representation, [rand.adapt.ibits]
transition algorithm, [rand.adapt.ibits]
indeterminate value, [dcl.init]
indeterminately sequenced, [intro.execution]
indirection, [expr.unary.op]
inheritance, [class.derived], [class.derived]
using-declaration and, [namespace.udecl]
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]
non-vacuous, [basic.life]
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 member, [class.base.init]
static and thread, [basic.start.static]
static member, [class.static.data]
virtual base class, [class.copy.ctor]
zero-initialization, [dcl.init]
initializer
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]
instantiation
explicit, [temp.explicit]
point of, [temp.point]
template implicit, [temp.inst]
instantiation units, [lex.phases]
integer literal, see literal, integer
integer representation, [basic.stc.dynamic.safety]
integer type, [basic.fundamental]
integral type, [basic.fundamental]
implementation-defined sizeof, [basic.fundamental]
inter-thread happens before, [intro.races]
internal linkage, [basic.link]
interval boundaries
piecewise_­constant_­distribution, [rand.dist.samp.pconst]
piecewise_­linear_­distribution, [rand.dist.samp.plinear]
<inttypes.h>, [cinttypes.syn]
invalid pointer value, [basic.compound]
invocation
<iomanip>, [iomanip.syn]
<ios>, [ios.syn]
<iosfwd>, [iosfwd.syn]
<iostream>, [iostream.syn]
isctype
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]
lattice, see DAG, subobject
layout
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, [basic.life]
<limits>, [limits.syn]
limits
implementation, [defns.impl.limits]
line splicing, [lex.phases]
linear_­congruential_­engine
generation algorithm, [rand.eng.lcong]
textual representation, [rand.eng.lcong]
transition algorithm, [rand.eng.lcong]
linkage, [basic], [basic.link], [basic.link]
const and, [basic.link]
implementation-defined object, [dcl.link]
inline and, [basic.link]
internal, [basic.link]
static and, [basic.link]
linkage specification, see specification, linkage
linkage-specification, [dcl.link]
<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]
char16_­t, [lex.ccon]
char32_­t, [lex.ccon]
ordinary, [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]
pointer, [lex.nullptr]
string, [lex.string]
char16_­t, [lex.string]
char32_­t, [lex.string]
narrow, [lex.string]
type of, [lex.string]
undefined change to, [lex.string]
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, [class.local]
member function in, [class.mfct]
scope of, [class.local]
local lambda expression, [expr.prim.lambda.capture]
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]
lognormal_­distribution
probability density function, [rand.dist.norm.lognormal]
long
typedef and, [dcl.spec]
lookup
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]
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 reference, [basic.compound], [dcl.ref]
Lvalue-Callable, [func.wrap.func]
macro
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]
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
match_­results
as sequence, [re.results]
mathematical special functions, [sf.cmath]
max
random number distribution requirement, [rand.req.dist]
uniform random bit generator requirement, [rand.req.urng]
mean
normal_­distribution, [rand.dist.norm.normal]
poisson_­distribution, [rand.dist.pois.poisson]
member
class static, [basic.stc.static]
default initializer, [class.mem]
enumerator, [dcl.enum]
template and static, [temp.static]
member access operator
overloaded, [over.ref]
member data
member function, [class.mem]
call undefined, [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]
volatile, [class.this]
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 location, [intro.memory]
memory management, see also new, delete
memory model, [intro.memory]
<memory_­resource>, [mem.res.syn]
mersenne_­twister_­engine
generation algorithm, [rand.eng.mers]
textual representation, [rand.eng.mers]
transition algorithm, [rand.eng.mers]
min
random number distribution requirement, [rand.req.dist]
uniform random bit generator requirement, [rand.req.urng]
modifiable, [basic.lval]
modification order, [intro.races]
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
MoveInsertable into X, [container.requirements.general]
multi-pass guarantee, [forward.iterators]
multibyte character, see character, 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, [lex.name], [basic], [expr.prim.id]
address of cv-qualified, [expr.unary.op]
elaborated
length of, [lex.name]
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], [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
namespaces, [basic.namespace]
narrowing conversion, [dcl.init.list]
needed
exception specification, [except.spec]
negative_­binomial_­distribution
discrete probability function, [rand.dist.bern.negbin]
nested class, [class.nest]
local class, [class.local]
scope of, [class.nest]
nested within, [intro.object]
<new>, [new.syn]
new, [basic.stc.dynamic], [expr.new]
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
scoping and, [expr.new]
storage allocation, [expr.new]
type of, [class.free]
unspecified constructor and, [expr.new]
unspecified order of evaluation, [expr.new]
new-extended alignment, [basic.align]
no linkage, [basic.link]
non-initialization odr-use, see odr-use, non-initialization
non-static data member, [class.mem]
non-static member, [class.mem]
non-static member function, [class.mem]
non-throwing exception specification, [except.spec]
normal distributions, [rand.dist.norm]
normal_­distribution
probability density function, [rand.dist.norm.normal]
standard deviation, [rand.dist.norm.normal]
normative references, see references, normative
notation
syntax, [syntax]
null character, see character, null
null pointer value, see value, null pointer
null statement, [stmt.expr]
null wide character, see wide-character, null
numeric_­limits, [limits.syn]
specializations for arithmetic types, [basic.fundamental]
object, see also object model, [intro.object], [basic]
byte copying and, [basic.types]
complete, [intro.object]
const volatile, [basic.type.qualifier]
definition, [basic.def]
destructor and placement of, [class.dtor]
destructor static, [basic.start.term]
linkage specification, [dcl.link]
local static, [basic.stc.static]
nested within, [intro.object]
providing storage for, [intro.object]
unnamed, [class.ctor]
object class, see also class object
object expression, [expr.ref], [expr.mptr.oper]
object lifetime, [basic.life]
object model, [intro.object]
object pointer type, [basic.compound]
object representation, [basic.types]
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-use
non-initialization, [basic.start.dynamic]
odr-used, [basic.def.odr]
one-definition rule, [basic.def]
operation
operator, [lex.operators], [over.oper]
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]
function call, [expr.call], [over.oper]
greater than, [expr.rel]
greater than or equal to, [expr.rel]
indirection, [expr.unary]
inequality, [expr.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], [over.oper]
pointer to member, [expr.mptr.oper]
precedence of, [intro.execution]
relational, [expr.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]
subscripting, [expr.sub], [over.oper]
subtraction, [expr.add]
operator delete, see also delete, [expr.new], [expr.delete], [class.free]
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]
uniform random bit generator requirement, [rand.req.urng]
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]
optimization of temporary, see temporary, elimination of
<optional>, [optional.syn]
optional object, [optional.general]
order of evaluation in expression, see expression, order of evaluation of
order of execution
base class constructor, [class.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.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>, [ostream.syn]
over-aligned type, see type, over-aligned
overflow, [expr]
undefined, [expr]
overloaded function, see overloading
overloaded operator, see overloading, operator
inheritance of, [over.oper]
overloading, [dcl.fct], [class.name], [over], [over], [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]
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]
contexts, [over.match]
function call syntax, [over.match.call]
function template, [temp.over]
implicit conversions and, [over.best.ics]
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]
overloads
floating-point, [cmplx.over]
overrider
(Legendre polynomials), [sf.cmath.legendre]
(associated Legendre polynomials), [sf.cmath.assoc_legendre]
pack expansion, [temp.variadic]
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 declaration, [basic.def]
parameter list
parameter pack, [temp.variadic]
unexpanded, [temp.variadic]
parameter-type-list, [dcl.fct]
parameterized type, see template
parameters
path equality, [fs.path.nonmember]
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]
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 syntax
plain lock-free atomic operation, [support.signal]
POD class, [class]
POD struct, [class]
POD union, [class]
point of declaration, [basic.scope.pdecl]
pointer, see also void*
composite pointer type, [expr]
integer representation of safely-derived, [basic.stc.dynamic.safety]
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]
poisson_­distribution
discrete probability function, [rand.dist.pois.poisson]
pool resource classes, [mem.res.pool.overview]
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 evaluated, [basic.def.odr]
potentially-throwing
exception specification, [except.spec]
expression, [except.spec]
precedence of operator, see operator, precedence of
prefix ++, [expr.pre.incr]
prefix ++ and --
overloading, [over.inc]
prefix --, [expr.pre.incr]
preprocessing directive, [cpp]
conditional inclusion, [cpp.cond]
preprocessing directives, [cpp]
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]
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.execution]
abstract machine, [intro.execution]
as-if rule, see as-if rule
promoted arithmetic type, [over.built]
promoted integral type, [over.built]
promotion
bool to int, [conv.prom]
default argument promotion, [expr.call]
floating-point, [conv.fpprom]
integral, [conv.prom]
provides storage, [intro.object]
prvalue, [basic.lval]
pseudo-destructor-name, [expr.pseudo]
ptrdiff_­t, [expr.add]
implementation-defined type of, [expr.add]
punctuator, [lex.operators]
qualification
<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, [rand.dist.uni.int]
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
random_­device
implementation leeway, [rand.device]
<ratio>, [ratio.syn]
raw string literal, [lex.string]
redefinition
typedef, [dcl.typedef]
reference, [basic.compound]
assignment to, [expr.ass]
call by, [expr.call]
forwarding, [temp.deduct.call]
null, [dcl.ref]
reference collapsing, [dcl.ref]
reference-compatible, [dcl.init.ref]
references
normative, [intro.refs]
regex_­iterator
end-of-sequence, [re.regiter]
regex_­token_­iterator
end-of-sequence, [re.tokiter]
regex_­traits
specializations, [re.traits]
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]
reinterpret_­cast, see cast, reinterpret
relaxed pointer safety, [basic.stc.dynamic.safety]
release sequence, [intro.races]
remainder operator, see operator, remainder
replacement
representation
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]
CopyConstructible, [utility.arg.requirements]
DefaultConstructible, [utility.arg.requirements]
EqualityComparable, [utility.arg.requirements]
LessThanComparable, [utility.arg.requirements]
MoveConstructible, [utility.arg.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]
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.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, [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]
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]
uniform random bit generator requirement, [rand.req.urng]
return, [stmt.jump], [stmt.return]
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]
right shift
implementation-defined, [expr.shift]
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, [basic.compound], [dcl.ref]
safely-derived pointer, [basic.stc.dynamic.safety]
integer representation, [basic.stc.dynamic.safety]
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 prototype, [basic.scope.proto]
global namespace, [basic.scope.namespace]
iteration-statement, [stmt.iter]
macro definition, see macro, scope of definition
name lookup and, [basic.lookup]
overloading and, [over.dcl]
selection-statement, [stmt.select]
template parameter, [basic.scope.temp]
scope name hiding and, [basic.scope.hiding]
scope resolution operator, see operator, scope resolution
<scoped_­allocator>, [allocator.adaptor.syn]
seed
random number engine requirement, [rand.req.eng]
seed sequence, [rand.req.seedseq]
requirements, [rand.req.seedseq]
semantics
class member, [expr.ref]
separate compilation, see compilation, separate
separate translation, see compilation, separate
sequence
ambiguous conversion, [over.best.ics]
implicit conversion, [over.best.ics]
partitioned with respect to, [alg.sorting]
standard conversion, [conv]
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
short
typedef and, [dcl.spec]
shuffle_­order_­engine
generation algorithm, [rand.adapt.shuf]
textual representation, [rand.adapt.shuf]
transition algorithm, [rand.adapt.shuf]
signal-safe
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
typedef and, [dcl.spec]
signed integer type, [basic.fundamental]
significand, [lex.fcon]
similar types, [conv.qual]
simple call wrapper, [func.require]
size
seed sequence requirement, [rand.req.seedseq]
size_­t, [expr.sizeof]
smart pointers, [unique.ptr.special]
source file character, see character, source file
space
special member function, see constructor, see destructor, see assignment operator
specialization
class template, [temp.names]
class template partial, [temp.class.spec], [temp.class.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]
specifier, [dcl.spec]
cv-qualifier, [dcl.type.cv]
declaration, [dcl.spec]
explicit, [dcl.fct.spec]
function, [dcl.fct.spec]
inline, [dcl.inline]
static, [dcl.stc]
storage class, [dcl.stc]
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]
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, [class]
standard-layout struct, [class]
standard-layout types, [basic.types]
standard-layout union, [class]
start
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]
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, [stmt.select]
static, [dcl.stc], [gram.dcl]
destruction of local, [stmt.dcl]
linkage of, [basic.link], [dcl.stc]
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, [basic.stc.static]
static type, see type, static
static_assert, [dcl.dcl]
not macro, [cassert.syn]
static_­cast, see cast, static
<stdarg.h>, [cstdarg.syn]
<stdio.h>, [cstdio.syn]
<stdlib.h>, [depr.c.headers]
storage class, [basic]
storage management, see new, delete
stream
arbitrary-positional, [defns.arbitrary.stream]
<streambuf>, [streambuf.syn]
strict pointer safety, [basic.stc.dynamic.safety]
<string>, [string.syn]
string
distinct, [lex.string]
null-terminated byte, [byte.strings]
null-terminated character type, [defns.ntcts]
null-terminated multibyte, [multibyte.strings]
sizeof, [lex.string]
type of, [lex.string]
string literal, see literal, string
<string.h>, [cstring.syn]
<string_­view>, [string.view.synop]
stringize, see # operator
strongly happens before, [intro.races]
struct
class versus, [class]
standard-layout, [class]
structure tag, see class name
structured binding, [dcl.struct.bind]
structured binding declaration, [dcl.dcl], [dcl.struct.bind]
student_­t_­distribution
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]
subtract_­with_­carry_­engine
generation algorithm, [rand.eng.sub]
textual representation, [rand.eng.sub]
transition algorithm, [rand.eng.sub]
subtraction
implementation-defined pointer, [expr.add]
subtraction operator, see operator, subtraction
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]
syntax, [gram]
swappable with, [swappable.requirements]
switch
and handler, [except]
and try block, [except]
synchronize with, [intro.races]
synonym, [namespace.alias]
type name as, [dcl.typedef]
syntax
class member, [expr.ref]
<system_­error>, [system_error.syn]
target object, [func.def]
template, [temp], [temp]
definition of, [temp]
function, [temp.fct.spec]
equivalent, [temp.over.link]
functionally equivalent, [temp.over.link]
partial ordering, [temp.func.order]
member function, [temp.mem.func]
static data member, [temp]
variable, [temp]
template instantiation, [temp.spec]
template name
linkage of, [temp]
template parameter, [basic.def]
template parameter pack, [temp.variadic]
template parameter scope, [basic.scope.temp]
template-argument
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]
terminology
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, [basic.stc.thread]
thread_­local, [dcl.stc], [gram.dcl]
threads
<time.h>, [ctime.syn]
token, [lex.token]
alternative, [lex.digraph]
preprocessing, [lex.pptoken]
transfer ownership, [unique.ptr]
transform
regular expression traits, [re.req], [re.grammar]
transform_­primary
regular expression traits, [re.req], [re.grammar]
TransformationTrait, [meta.rqmts]
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]
trigraph sequence, [diff.cpp14.lex]
trivial class, [class]
trivial class type, [expr.new]
trivial type, [expr.new]
trivial types, [basic.types]
trivially copyable class, [class]
trivially copyable types, [basic.types]
truncation, [conv.fpint]
<tuple>, [tuple.syn]
tuple
and pair, [pairs.general]
type, [basic], [basic.types]
allocated, [expr.new]
arithmetic, [basic.fundamental]
promoted, [over.built]
character container, [defns.character.container]
class and, [class]
const, [dcl.type]
cv-combined, [expr]
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]
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, [expr.call]
type conversion, explicit, see casting
type generator, see template
type_­info, [expr.typeid]
typedef
function, [dcl.fct]
overloading and, [over.load]
typeid, [expr.typeid]
construction and, [class.cdtor]
destruction and, [class.cdtor]
<typeinfo>, [typeinfo.syn]
typename, [dcl.type.elab]
types
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]
UnaryTypeTrait, [meta.rqmts]
undefined behavior, see behavior, undefined
underlying type, see type, underlying
unevaluated operand, [expr]
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, [basic.compound], [class.union]
class versus, [class]
global anonymous, [class.union.anon]
standard-layout, [class]
union-like class, [class.union.anon]
unique pointer, [unique.ptr]
unit
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>, [unord.map.syn]
unordered_­map
element access, [unord.map.elem]
unordered_­multimap
equivalent keys, [unord.multimap.overview]
unordered_­multiset
equivalent keys, [unord.multiset.overview]
<unordered_­set>, [unord.set.syn]
unordered_­set
unsequenced, [intro.execution]
unsigned
typedef and, [dcl.spec]
unsigned integer type, [basic.fundamental]
unspecified behavior, see behavior, unspecified
unwinding
upstream allocator, [mem.res.pool.overview]
user-defined literal, see literal, user-defined
overloaded, [over.literal]
user-provided, [dcl.fct.def.default]
uses-allocator construction, [allocator.uses.construction]
using-declaration, [namespace.udecl]
using-directive, [namespace.udir]
usual arithmetic conversions, see conversion, usual arithmetic
usual deallocation function, [basic.stc.dynamic.deallocation]
UTF-8 character literal, [lex.ccon]
UTF-8 string literal, [lex.string]
<utility>, [utility]
<valarray>, [valarray.syn]
valid but unspecified state, [defns.valid]
value, [basic.types]
call by, [expr.call]
denormalized, see number, subnormal
indeterminate, [dcl.init]
null member pointer, [conv.mem]
undefined unrepresentable integral, [conv.fpint]
value category, [basic.lval]
value representation, [basic.types]
value-initialization, [dcl.init]
variable, [basic]
indeterminate uninitialized, [dcl.init]
variable template
definition of, [temp]
<variant>, [variant.syn]
variant member, [class.union.anon]
<vector>, [vector.syn]
vectorization-unsafe, [algorithms.parallel.exec]
virtual base class, see base class, virtual
virtual function call, [class.virtual]
constructor and, [class.cdtor]
destructor and, [class.cdtor]
undefined pure, [class.abstract]
void&, [dcl.ref]
void*
volatile, [basic.type.qualifier]
constructor and, [class.this], [class.ctor]
destructor and, [class.this], [class.dtor]
implementation-defined, [dcl.type.cv]
overloading and, [over.load]
volatile-qualified, [basic.type.qualifier]
waiting function, [futures.state]
<wchar.h>, [cwchar.syn]
wchar_­t, see type, wchar_­t
<wctype.h>, [cwctype.syn]
weak result type, [depr.weak.result_type]
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
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]
xvalue, [basic.lval]
(spherical associated Legendre functions), [sf.cmath.sph_legendre]
zero
division by undefined, [expr]
remainder undefined, [expr]
undefined division by, [expr.mul]
zero-initialization, [dcl.init]
zeta functions ζ, [sf.cmath.riemann_zeta]