Index
!
,
see
operator, logical negation
!=
,
see
operator, inequality
#
operator,
[cpp.replace]
,
[cpp.stringize]
##
operator,
[cpp.concat]
#define
,
[cpp.replace]
#elif
,
[cpp.cond]
#else
,
[cpp.cond]
#endif
,
[cpp.cond]
#error
,
see
preprocessing directives, error
#if
,
[cpp.cond]
,
[res.on.macro.definitions]
#ifdef
,
[cpp.cond]
#ifndef
,
[cpp.cond]
#include
,
[cpp.include]
,
[using.headers]
#line
,
see
preprocessing directives, line control
#pragma
,
see
preprocessing directives, pragma
#undef
,
[cpp.scope]
,
[macro.names]
%
,
see
operator, remainder
&
,
see
operator, address-of
,
see
operator, bitwise AND
,
see
declarator, reference
&&
,
see
operator, logical AND
()
,
see
operator, function call
,
see
declarator, function
*
,
see
operator, indirection
,
see
operator, multiplication
,
see
declarator, pointer
+
,
see
operator, unary plus
,
see
operator, addition
++
,
see
operator, increment
,
,
see
operator, comma
-
,
see
operator, unary minus
,
see
operator, subtraction
--
,
see
operator, decrement
->
,
see
operator, class member access
->*
,
see
operator, pointer to member
.
,
see
operator, class member access
.*
,
see
operator, pointer to member
...
,
see
ellipsis
/
,
see
operator, division
:
bit-field declaration,
[class.bit]
label specifier,
[stmt.label]
::
,
see
operator, scope resolution
::*
,
see
declarator, pointer to member
<
,
see
operator, less than
template and,
[temp.param]
,
[temp.names]
<<
,
see
operator, left shift
<=
,
see
operator, less than or equal to
=
,
see
assignment operator
==
,
see
operator, equality
>
,
see
operator, greater than
>=
,
see
operator, greater than or equal to
>>
,
see
operator, right shift
?:
,
see
operator, conditional expression
[]
,
see
operator, subscripting
,
see
declarator, array
\
,
see
backslash character
^
,
see
operator, bitwise exclusive OR
_
,
see
character, underscore
__cplusplus
,
[cpp.predefined]
__DATE__
,
[cpp.predefined]
__FILE__
,
[cpp.predefined]
__func__
,
[dcl.fct.def.general]
__has_include
,
[cpp.cond]
__LINE__
,
[cpp.predefined]
__STDC__
,
[cpp.predefined]
__STDC_HOSTED__
,
[cpp.predefined]
__STDC_ISO_10646__
,
[cpp.predefined]
__STDC_MB_MIGHT_NEQ_WC__
,
[cpp.predefined]
__STDC_VERSION__
,
[cpp.predefined]
__STDCPP_DEFAULT_NEW_ALIGNMENT__
,
[cpp.predefined]
__STDCPP_STRICT_POINTER_SAFETY__
,
[cpp.predefined]
__STDCPP_THREADS__
,
[cpp.predefined]
__TIME__
,
[cpp.predefined]
__VA_ARGS__
,
[cpp.replace]
{}
block statement,
[stmt.block]
class declaration,
[class]
class definition,
[class]
enum
declaration,
[dcl.enum]
initializer list,
[dcl.init.aggr]
|
,
see
operator, bitwise inclusive OR
||
,
see
operator, logical OR
~
,
see
operator, ones' complement
,
see
destructor
0
,
see also
zero, null
null character,
see
character, null
string terminator,
[lex.string]
abort
,
[basic.start.term]
,
[stmt.jump]
access,
[defns.access]
access control,
[class.access]
anonymous
union
,
[class.union.anon]
base class,
[class.access.base]
base class member,
[class.derived]
class member,
[expr.ref]
default,
[class.access]
default argument,
[class.access]
friend function,
[class.friend]
member function and,
[special]
member name,
[class.access]
multiple access,
[class.paths]
nested class,
[class.access.nest]
overload resolution and,
[class.member.lookup]
overloading and,
[over.dcl]
private
,
[class.access]
protected
,
[class.access]
,
[class.protected]
public
,
[class.access]
union
default member,
[class]
using-declaration and,
[namespace.udecl]
virtual function,
[class.access.virt]
access specifier,
[class.access.spec]
,
[class.access.base]
active
union member,
[class.union]
addition operator,
see
operator, addition
address,
[basic.compound]
,
[expr.eq]
aggregate,
[dcl.init.aggr]
,
[dcl.init.aggr]
elements,
[dcl.init.aggr]
aggregate initialization,
[dcl.init.aggr]
<algorithm>
,
[algorithm.syn]
algorithm
stable,
[defns.stable]
,
[algorithm.stable]
alias
namespace,
[namespace.alias]
alias template,
[temp.alias]
alignment,
[basic.align]
extended,
[basic.align]
fundamental,
[basic.align]
new-extended,
[basic.align]
stricter,
[basic.align]
stronger,
[basic.align]
weaker,
[basic.align]
alignment requirement
implementation-defined,
[basic.align]
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]
<any>
,
[any.synop]
appertain,
[dcl.attr.grammar]
argc
,
[basic.start.main]
argument,
[defns.argument]
,
[defns.argument.macro]
,
[defns.argument.throw]
,
[defns.argument.templ]
,
[res.on.arguments]
,
[res.on.macro.definitions]
,
[out.of.range]
access checking and default,
[class.access]
binding of default,
[dcl.fct.default]
evaluation of default,
[dcl.fct.default]
example of default,
[dcl.fct.default]
function call expression,
[defns.argument]
function-like macro,
[defns.argument.macro]
overloaded operator and default,
[over.oper]
reference,
[expr.call]
scope of default,
[dcl.fct.default]
template,
[temp.arg]
template instantiation,
[defns.argument.templ]
throw expression,
[defns.argument.throw]
type checking of default,
[dcl.fct.default]
argument and name hiding
default,
[dcl.fct.default]
argument and virtual function
default,
[dcl.fct.default]
argument list
empty,
[dcl.fct]
variable,
[dcl.fct]
argument passing,
[expr.call]
reference and,
[dcl.init.ref]
argument substitution,
see
macro, argument substitution
argument type
unknown,
[dcl.fct]
argv
,
[basic.start.main]
arithmetic
pointer,
[expr.add]
unsigned
,
[basic.fundamental]
<array>
,
[array.syn]
array
as aggregate,
[array.overview]
bound,
[dcl.array]
const
,
[basic.type.qualifier]
contiguous storage,
[array.overview]
delete
,
[expr.delete]
handler of type,
[except.handle]
initialization,
[array.overview]
,
[array.cons]
multidimensional,
[dcl.array]
new
,
[expr.new]
overloading and pointer versus,
[over.load]
parameter of type,
[dcl.fct]
sizeof
,
[expr.sizeof]
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]
<assert.h>
,
[using.headers]
,
[cassert.syn]
assignment
and lvalue,
[expr.ass]
conversion by,
[expr.ass]
copy,
see
assignment operator, copy
move,
see
assignment operator, move
,
[defns.move.assign]
reference,
[dcl.init.ref]
assignment operator
copy,
[special]
,
[class.copy.assign]
,
[class.copy.assign]
hidden,
[class.copy.assign]
implicitly declared,
[class.copy.assign]
implicitly defined,
[class.copy.assign]
inaccessible,
[class.copy]
non-trivial,
[class.copy.assign]
trivial,
[class.copy.assign]
virtual bases and,
[class.copy.assign]
move,
[special]
,
[class.copy.assign]
,
[class.copy.assign]
hidden,
[class.copy.assign]
implicitly declared,
[class.copy.assign]
implicitly defined,
[class.copy.assign]
inaccessible,
[class.copy]
non-trivial,
[class.copy.assign]
trivial,
[class.copy.assign]
overloaded,
[over.ass]
associative containers
exception safety,
[associative.reqmts]
requirements,
[associative.reqmts]
unordered,
see
unordered associative containers
asynchronous provider,
[futures.state]
asynchronous return object,
[futures.state]
at least as specialized as,
see
more specialized
atexit
,
[basic.start.term]
<atomic>
,
[atomics.syn]
atomic operations,
see
operation, atomic
attribute,
[dcl.attr]
alignment,
[dcl.align]
carries dependency,
[dcl.attr.depend]
deprecated,
[dcl.attr.deprecated]
fallthrough,
[dcl.attr.fallthrough]
maybe unused,
[dcl.attr.unused]
nodiscard,
[dcl.attr.nodiscard]
noreturn,
[dcl.attr.noreturn]
syntax and semantics,
[dcl.attr.grammar]
automatic storage duration,
[basic.stc.auto]
awk
,
[re.synopt]
backslash character,
[lex.ccon]
bad_alloc
,
[expr.new]
bad_cast
,
[expr.dynamic.cast]
bad_typeid
,
[expr.typeid]
base characteristic,
[meta.rqmts]
base class,
[class.derived]
,
[class.mi]
dependent,
[temp.dep.type]
direct,
[class.derived]
indirect,
[class.derived]
non-virtual,
[class.mi]
overloading and,
[over.dcl]
private
,
[class.access.base]
protected
,
[class.access.base]
public
,
[class.access.base]
virtual,
[class.mi]
base class subobject,
[intro.object]
behavior
conditionally-supported,
[defns.cond.supp]
,
[intro.compliance]
default,
[defns.default.behavior.impl]
,
[defns.default.behavior.func]
,
[structure.specifications]
implementation-defined,
[defns.impl.defined]
,
[intro.execution]
locale-specific,
[defns.locale.specific]
observable,
[intro.execution]
,
[intro.execution]
on receipt of signal,
[intro.execution]
required,
[defns.required.behavior]
,
[structure.specifications]
undefined,
[defns.undefined]
,
[intro.compliance]
,
[intro.execution]
,
[istreambuf.iterator]
unspecified,
[defns.unspecified]
,
[intro.execution]
Ben,
[over.dcl]
Bernoulli distributions,
[rand.dist.bern]
bernoulli_distribution
discrete probability function,
[rand.dist.bern.bernoulli]
Bessel functions
I
ν
,
[sf.cmath.cyl_bessel_i]
j
n
,
[sf.cmath.sph_bessel]
J
ν
,
[sf.cmath.cyl_bessel_j]
K
ν
,
[sf.cmath.cyl_bessel_k]
n
n
,
[sf.cmath.sph_neumann]
N
ν
,
[sf.cmath.cyl_neumann]
beta functions
B
,
[sf.cmath.beta]
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
empty,
[bitmask.types]
<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
function,
[dcl.fct.def.general]
Bond
James Bond,
[expr.prim.lambda.capture]
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]
byte,
[intro.memory]
,
[expr.sizeof]
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]
simple,
[func.require]
type,
[func.def]
callable object,
[func.def]
callable type,
[func.wrap.func]
,
[func.def]
capture
implicit,
[expr.prim.lambda.capture]
captured,
[expr.prim.lambda.capture]
by copy,
[expr.prim.lambda.capture]
by reference,
[expr.prim.lambda.capture]
carries a dependency,
[intro.races]
carry
subtract_with_carry_engine
,
[rand.eng.sub]
<cassert>
,
[using.headers]
,
[cassert.syn]
,
[clocale.syn]
cast
base class,
[expr.static.cast]
const,
[expr.const.cast]
,
[expr.cast]
derived class,
[expr.static.cast]
dynamic,
[expr.dynamic.cast]
,
[bad.cast]
construction and,
[class.cdtor]
destruction and,
[class.cdtor]
integer to pointer,
[expr.reinterpret.cast]
lvalue,
[expr.static.cast]
,
[expr.reinterpret.cast]
pointer to integer,
[expr.reinterpret.cast]
pointer-to-function,
[expr.reinterpret.cast]
pointer-to-member,
[expr.static.cast]
,
[expr.reinterpret.cast]
reference,
[expr.static.cast]
,
[expr.reinterpret.cast]
reinterpret,
[expr.reinterpret.cast]
,
[expr.cast]
integer to pointer,
[expr.reinterpret.cast]
lvalue,
[expr.reinterpret.cast]
pointer to integer,
[expr.reinterpret.cast]
pointer-to-function,
[expr.reinterpret.cast]
pointer-to-member,
[expr.reinterpret.cast]
reference,
[expr.reinterpret.cast]
static,
[expr.static.cast]
,
[expr.cast]
lvalue,
[expr.static.cast]
reference,
[expr.static.cast]
undefined pointer-to-function,
[expr.reinterpret.cast]
casting,
[expr.type.conv]
casting away constness,
[expr.const.cast]
catch
,
[except]
cats
interfering with canines,
[hardware.interference]
cauchy_distribution
probability density function,
[rand.dist.norm.cauchy]
<ccomplex>
,
[diff.mods.to.headers]
<cctype>
,
[cctype.syn]
<cerrno>
,
[extern.names]
,
[cerrno.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]
multibyte,
[defns.multibyte]
null,
[lex.charset]
signed
,
[basic.fundamental]
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]
basic source,
[lex.phases]
,
[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]
chunks,
[mem.res.pool.overview]
<cinttypes>
,
[cinttypes.syn]
class,
[basic.compound]
,
[class]
abstract,
[class.abstract]
associated,
[basic.lookup.argdep]
base,
[derived.classes]
,
[derivation]
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
elaborated,
[dcl.type.elab]
,
[class.name]
point of declaration,
[class.name]
scope of,
[class.name]
typedef
,
[dcl.typedef]
,
[class.name]
class object
assignment to,
[expr.ass]
member,
[class.mem]
sizeof
,
[expr.sizeof]
class object copy,
see
constructor, copy
class object initialization,
see
constructor
<climits>
,
[depr.strstreambuf.cons]
<clocale>
,
[character.seq]
closure object,
[expr.prim.lambda]
closure type,
[expr.prim.lambda.closure]
<cmath>
,
[cmath.syn]
,
[c.math.abs]
<codecvt>
,
[depr.locale.stdcvt]
collating element,
[re.def]
comma operator,
see
operator, comma
comment,
[lex.pptoken]
,
[lex.comment]
/*
*/
,
[lex.comment]
//
,
[lex.comment]
common initial sequence,
[class.mem]
comparison
pointer,
[expr.eq]
pointer to function,
[expr.eq]
undefined pointer,
[expr.add]
compatible with
shared_ptr
,
[util.smartptr.shared]
compilation
separate,
[lex.separate]
compiler control line,
see
preprocessing directives
complete object,
[intro.object]
complete object of,
[intro.object]
completely defined,
[class.mem]
<complex>
,
[complex.numbers]
,
[complex.syn]
<complex.h>
,
[diff.mods.to.headers]
component,
[defns.component]
composite pointer type,
[expr]
concatenation
macro argument,
see
##
operator
string,
[lex.string]
concurrent forward progress guarantees,
[intro.progress]
condition
s
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]
classes,
[intro.compliance]
general,
[intro.compliance]
library,
[intro.compliance]
method of description,
[intro.compliance]
consistency
linkage,
[dcl.stc]
linkage specification,
[dcl.link]
type declaration,
[basic.link]
const
,
[basic.type.qualifier]
cast away,
[expr.const.cast]
constructor and,
[class.this]
,
[class.ctor]
destructor and,
[class.this]
,
[class.dtor]
linkage of,
[basic.link]
overloading and,
[over.load]
const
-object
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,
[lex.literal.kinds]
,
[expr.prim.literal]
enumeration,
[dcl.enum]
null pointer,
[conv.ptr]
,
[conv.mem]
constant expression,
[expr.const]
permitted result of,
[expr.const]
constant initialization,
[basic.start.static]
constant initializer,
[basic.start.static]
constant iterator,
[iterator.requirements.general]
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]
move,
[defns.move.constr]
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]
copy,
[special]
,
[class.temporary]
,
[class.copy.ctor]
,
[class.copy.ctor]
,
[functions.within.classes]
elision,
[class.copy.elision]
implicitly declared,
[class.copy.ctor]
implicitly defined,
[class.copy.ctor]
inaccessible,
[class.copy]
nontrivial,
[class.copy.ctor]
trivial,
[class.copy.ctor]
default,
[special]
,
[class.ctor]
non-trivial,
[class.ctor]
trivial,
[class.ctor]
exception handling,
see
exception handling, constructors and destructors
explicit call,
[class.ctor]
implicitly called,
[class.ctor]
implicitly defined,
[class.ctor]
inheritance of,
[class.ctor]
move,
[special]
,
[class.copy.ctor]
,
[class.copy.ctor]
elision,
[class.copy.elision]
implicitly declared,
[class.copy.ctor]
implicitly defined,
[class.copy.ctor]
inaccessible,
[class.copy]
non-trivial,
[class.copy.ctor]
trivial,
[class.copy.ctor]
non-trivial,
[class.ctor]
random number distribution requirement,
[rand.req.dist]
random number engine requirement,
[rand.req.eng]
union
,
[class.union]
constructor, conversion by,
see
conversion, user-defined
contained value
any
,
[any.class]
optional
,
[optional.optional]
variant
,
[variant.variant]
container
contiguous,
[container.requirements.general]
contains a value
optional
,
[optional.optional]
context
non-deduced,
[temp.deduct.type]
contextually converted constant expression of type
bool
,
see
conversion, contextual
contextually converted to bool,
see
conversion, contextual
contextually implicitly converted,
[conv]
contiguous container,
[container.requirements.general]
contiguous iterators,
[iterator.requirements.general]
continue
and handler,
[except]
and try block,
[except]
control line,
see
preprocessing directives
conventions
lexical,
[lex.separate]
conversion
argument,
[dcl.fct]
array-to-pointer,
[conv.array]
bool
,
[conv.integral]
boolean,
[conv.bool]
class,
[class.conv]
contextual,
[conv]
contextual to
bool
,
[conv]
contextual to constant expression of type
bool
,
[expr.const]
deduced return type of user-defined,
[class.conv.fct]
derived-to-base,
[over.best.ics]
floating to integral,
[conv.fpint]
floating-point,
[conv.double]
function pointer,
[conv.fctptr]
function-to-pointer,
[conv.func]
implementation-defined pointer integer,
[expr.reinterpret.cast]
implicit,
[conv]
,
[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]
type of,
[class.conv.fct]
user-defined,
[class.conv.ctor]
,
[class.conv.fct]
,
[class.conv]
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
class object,
see
constructor, copy
,
see
assignment operator, copy
copy constructor
random number engine requirement,
[rand.req.eng]
copy deduction candidate,
[over.match.class.deduct]
copy elision,
see
constructor, copy, elision
copy-initialization,
[dcl.init]
copy-list-initialization,
[dcl.init.list]
CopyInsertable
into
X
,
[container.requirements.general]
<csetjmp>
,
[extern.names]
,
[support.runtime]
,
[csetjmp.syn]
<csignal>
,
[support.runtime]
,
[csignal.syn]
<cstdarg>
,
[dcl.fct]
,
[extern.names]
,
[support.runtime]
,
[cstdarg.syn]
<cstdbool>
,
[support.runtime]
<cstddef>
,
[expr.sizeof]
,
[expr.add]
<cstdint>
,
[cstdint.syn]
<cstdio>
,
[iostream.objects.overview]
,
[narrow.stream.objects]
,
[wide.stream.objects]
,
[filebuf.members]
,
[cstdio.syn]
<cstdlib>
,
[basic.start.term]
,
[compliance]
,
[cstdlib.syn]
,
[support.start.term]
,
[support.runtime]
,
[c.malloc]
,
[c.mb.wcs]
,
[alg.c.library]
,
[c.math.rand]
,
[c.math.abs]
,
[depr.c.headers]
<cstring>
,
[byte.strings]
,
[cstring.syn]
,
[depr.strstreambuf.cons]
,
[depr.ostrstream.cons]
<ctgmath>
,
[diff.mods.to.headers]
<ctime>
,
[support.runtime]
,
[ctime.syn]
,
[locale.syn]
<ctype.h>
,
[cctype.syn]
<cuchar>
,
[extern.names]
,
[cuchar.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]
cv-qualifier,
[basic.type.qualifier]
top-level,
[basic.type.qualifier]
<cwchar>
,
[extern.names]
,
[cwchar.syn]
,
[c.mb.wcs]
<cwctype>
,
[extern.names]
,
[cwctype.syn]
DAG
multiple inheritance,
[class.mi]
non-virtual base class,
[class.mi]
virtual base class,
[class.mi]
data member,
see
member
,
[class.mem]
static,
[class.mem]
data race,
[intro.races]
deadlock,
[defns.deadlock]
deallocation function
usual,
[basic.stc.dynamic.deallocation]
deallocation functions,
[basic.stc.dynamic]
decay
array,
see
conversion, array to pointer
function,
see
conversion, function to pointer
DECAY_COPY
,
[thread.decaycopy]
declaration,
[basic.def]
,
[basic]
,
[dcl.dcl]
array,
[dcl.array]
asm
,
[dcl.asm]
bit-field,
[class.bit]
class name,
[basic.def]
constant pointer,
[dcl.ptr]
default argument,
[dcl.fct.default]
definition versus,
[basic.def]
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]
function,
[basic.def]
,
[dcl.fct]
local class,
[class.local]
member,
[class.mem]
multiple,
[basic.link]
name,
[basic.def]
opaque enum,
[basic.def]
overloaded,
[over]
overloaded name and
friend
,
[class.friend]
parameter,
[basic.def]
,
[dcl.fct]
parentheses in,
[dcl.ambig.res]
,
[dcl.meaning]
pointer,
[dcl.ptr]
reference,
[dcl.ref]
static
member,
[basic.def]
storage class,
[dcl.stc]
structured binding,
see
structured binding declaration
type,
[dcl.meaning]
typedef
,
[basic.def]
typedef
as type,
[dcl.typedef]
declaration hiding,
see
name hiding
declarative region,
[basic.scope.declarative]
declarator,
[basic.def]
,
[dcl.dcl]
,
[dcl.decl]
array,
[dcl.array]
function,
[dcl.fct]
meaning of,
[dcl.meaning]
multidimensional array,
[dcl.array]
pointer,
[dcl.ptr]
pointer to member,
[dcl.mptr]
reference,
[dcl.ref]
decrement operator
overloaded,
see
overloading, decrement operator
deduction
class template argument,
[temp.deduct.guide]
class template arguments,
[expr.type.conv]
,
[dcl.type.simple]
,
[dcl.type.class.deduct]
,
[over.match.class.deduct]
placeholder type,
[dcl.type.auto.deduct]
default access control,
see
access control, default
default argument
overload resolution and,
[over.match.viable]
default argument instantiation,
[temp.inst]
default constructor,
see
constructor, default
random number distribution requirement,
[rand.req.dist]
seed sequence requirement,
[rand.req.seedseq]
default initializers
overloading and,
[over.load]
default member initializer,
[class.mem]
default memory resource pointer,
[mem.res.global]
default-initialization,
[dcl.init]
default-inserted,
[container.requirements.general]
defaulted,
[dcl.fct.def.default]
DefaultInsertable
into
X
,
[container.requirements.general]
deferred function,
[futures.async]
defined
,
[cpp.cond]
definition,
[basic.def]
,
[basic.def]
alternate,
[replacement.functions]
class,
[class]
,
[class.mem]
class name as type,
[class.name]
constructor,
[dcl.fct.def.general]
declaration as,
[dcl.dcl]
function,
[dcl.fct.def]
deleted,
[dcl.fct.def.delete]
explicitly-defaulted,
[dcl.fct.def.default]
local class,
[class.local]
member function,
[class.mfct]
namespace,
[namespace.def]
nested class,
[class.nest]
pure virtual function,
[class.abstract]
scope of class,
[class.name]
static member,
[class.static.data]
virtual function,
[class.virtual]
definitions,
[intro.defs]
delete
,
[basic.stc.dynamic]
,
[expr.delete]
,
[class.free]
array,
[expr.delete]
destructor and,
[expr.delete]
,
[class.dtor]
object,
[expr.delete]
operator
replaceable,
[replacement.functions]
overloading and,
[basic.stc.dynamic.deallocation]
type of,
[class.free]
undefined,
[expr.delete]
deleter,
[unique.ptr]
denormalized value,
see
number, subnormal
dependency-ordered before,
[intro.races]
dependent base class,
see
base class, dependent
dependent member of the current instantiation,
see
current instantiation, dependent member of the
dependent name,
see
name, dependent
<deque>
,
[deque.syn]
dereferencing,
see also
indirection
derivation,
see
inheritance
derived class,
[class.derived]
most,
see
most derived class
derived object
most,
see
most 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]
exception handling,
see
exception handling, constructors and destructors
explicit call,
[class.dtor]
implicit call,
[class.dtor]
implicitly defined,
[class.dtor]
non-trivial,
[class.dtor]
program termination and,
[class.dtor]
pure virtual,
[class.dtor]
union
,
[class.union]
virtual,
[class.dtor]
diagnosable rules,
[intro.compliance]
diagnostic message,
see
message, diagnostic
digraph,
see
token, alternative
,
[lex.digraph]
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]
state,
[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]
weights,
[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]
dot operator,
see
operator, class member access
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]
ECMAScript,
[re.synopt]
,
[re.grammar]
egrep
,
[re.synopt]
Ei
(exponential integrals),
[sf.cmath.expint]
elaborated type specifier,
see
class name, elaborated
element access functions,
[algorithms.parallel.defns]
elision
copy,
see
constructor, copy, elision
copy constructor,
see
constructor, copy, elision
move constructor,
see
constructor, move, elision
ellipsis
conversion sequence,
[expr.call]
,
[over.ics.ellipsis]
overload resolution and,
[over.match.viable]
elliptic integrals
complete
E
,
[sf.cmath.comp_ellint_2]
complete
K
,
[sf.cmath.comp_ellint_1]
complete
Π
,
[sf.cmath.comp_ellint_3]
incomplete
E
,
[sf.cmath.ellint_2]
incomplete
F
,
[sf.cmath.ellint_1]
incomplete
Π
,
[sf.cmath.ellint_3]
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,
see
random number engine
engine adaptor,
see
random number engine adaptor
engines with predefined parameters
default_random_engine
,
[rand.predef]
knuth_b
,
[rand.predef]
minstd_rand
,
[rand.predef]
minstd_rand0
,
[rand.predef]
mt19937
,
[rand.predef]
mt19937_64
,
[rand.predef]
ranlux24
,
[rand.predef]
ranlux24_base
,
[rand.predef]
ranlux48
,
[rand.predef]
ranlux48_base
,
[rand.predef]
entity,
[basic]
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 scope,
[basic.scope.enum]
,
[basic.scope.enum]
enumeration type
conversion to,
[expr.static.cast]
static_cast
conversion to,
[expr.static.cast]
enumerator
definition,
[basic.def]
value of,
[dcl.enum]
environment
program,
[basic.start.main]
epoch,
[time.clock.req]
equivalence
template type,
[temp.type]
type,
[dcl.typedef]
,
[class.name]
equivalent
expression,
see
expression, equivalent
function template,
see
template, function, equivalent
functionally
expression,
see
expression, functionally equivalent
function template,
see
template, function, functionally equivalent
equivalent parameter declarations,
[over.load]
overloading and,
[over.load]
equivalent-key group,
[unord.req]
equivalently-valued,
[allocator.requirements]
Erasable
from
X
,
[container.requirements.general]
<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,
[intro.execution]
,
[basic.start.dynamic]
unspecified order of argument,
[expr.call]
unspecified order of function call,
[expr.call]
example
array,
[dcl.array]
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]
member function,
[class.mfct.non-static]
,
[class.friend]
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>
,
[exception.syn]
,
[depr.uncaught]
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]
active,
[except.handle]
array in,
[except.handle]
incomplete type in,
[except.handle]
match,
[except.handle]
pointer to function in,
[except.handle]
rvalue reference in,
[except.handle]
memory,
[except.throw]
nearest handler,
[except.throw]
rethrow,
[expr.throw]
,
[except.throw]
rethrowing,
[except.throw]
switch
,
[except]
terminate
called,
[expr.throw]
,
[except.throw]
,
[except.spec]
throwing,
[expr.throw]
,
[except.throw]
try block,
[except]
exception object,
see
exception handling, exception object
exception specification,
[except.spec]
,
[except.spec]
noexcept
constant expression and,
[except.spec]
non-throwing,
[except.spec]
potentially-throwing,
[except.spec]
virtual function and,
[except.spec]
<execution>
,
[execution.syn]
execution agent,
[thread.req.lockable.general]
execution policy,
[execpol.general]
execution step,
[intro.progress]
exit
,
[basic.start.main]
,
[basic.start.term]
,
[stmt.jump]
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]
alignof
,
[expr.alignof]
assignment and compound assignment,
[expr.ass]
bitwise AND,
[expr.bit.and]
bitwise exclusive OR,
[expr.xor]
bitwise inclusive OR,
[expr.or]
cast,
[expr.type.conv]
,
[expr.cast]
class member access,
[expr.ref]
comma,
[expr.comma]
conditional operator,
[expr.cond]
const cast,
[expr.const.cast]
constant,
[expr.const]
,
[expr.const]
converted constant,
[expr.const]
core constant,
[expr.const]
decrement,
[expr.post.incr]
,
[expr.pre.incr]
delete
,
[expr.delete]
dynamic cast,
[expr.dynamic.cast]
equality operators,
[expr.eq]
equivalent,
[temp.over.link]
fold,
[expr.prim.fold]
function call,
[expr.call]
functionally equivalent,
[temp.over.link]
increment,
[expr.post.incr]
,
[expr.pre.incr]
integral constant,
[expr.const]
lambda,
[expr.prim.lambda]
left-shift-operator,
[expr.shift]
logical AND,
[expr.log.and]
logical OR,
[expr.log.or]
multiplicative operators,
[expr.mul]
new
,
[expr.new]
noexcept
,
[expr.unary.noexcept]
order of evaluation of,
[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]
sizeof
,
[expr.sizeof]
static cast,
[expr.static.cast]
throw
,
[expr.throw]
type identification,
[expr.typeid]
type-dependent,
[temp.dep]
unary,
[expr.unary]
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]
extern "C"
,
[using.linkage]
,
[extern.names]
extern "C++"
,
[using.linkage]
,
[extern.names]
external linkage,
[basic.link]
extreme_value_distribution
probability density function,
[rand.dist.pois.extreme]
F
(incomplete elliptic integrals),
[sf.cmath.ellint_1]
facet,
[locale.facet]
file attributes,
[fs.class.directory_entry]
cached,
[fs.class.directory_entry]
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]
fold
binary,
[expr.prim.fold]
unary,
[expr.prim.fold]
for
scope of declaration in,
[stmt.for]
format specifier,
[defns.regex.finite.state.machine]
forward progress guarantees
concurrent,
[intro.progress]
delegation of,
[intro.progress]
parallel,
[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]
inline,
[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
allocation,
[basic.stc.dynamic.allocation]
,
[expr.new]
comparison,
[defns.comparison]
conversion,
[class.conv.fct]
deallocation,
[basic.stc.dynamic.deallocation]
,
[class.free]
definition,
[basic.def]
global,
[extern.names]
,
[res.on.macro.definitions]
handler,
[defns.handler]
handler of type,
[except.handle]
linkage specification overloaded,
[dcl.link]
modifier,
[defns.modifier]
observer,
[defns.observer]
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]
reserved,
[defns.reserved.function]
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]
undefined,
[expr.reinterpret.cast]
function call operator
overloaded,
[over.call]
function object,
[function.objects]
binders,
[func.bind]
mem_fn
,
[func.memfn]
reference_wrapper
,
[refwrap]
type,
[function.objects]
wrapper,
[func.wrap]
function parameter,
see
parameter
function parameter pack,
[temp.variadic]
function pointer type,
[basic.compound]
function prototype,
[basic.scope.proto]
function return,
see
return
function return type,
see
return type
function try block,
see
exception handling, function try block
function, overloaded,
see
overloading
function, virtual,
see
virtual function
function-definition
,
[dcl.fct.def.general]
function-like macro,
see
macro, function-like
<functional>
,
[functional.syn]
,
[depr.negators]
functionally equivalent
expression,
see
expression, functionally equivalent
function template,
see
template, function, functionally equivalent
functions
candidate,
[temp.dep.candidate]
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,
[basic.scope.namespace]
global namespace,
[basic.scope.namespace]
global namespace scope,
[basic.scope.namespace]
global 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]
grep
,
[re.synopt]
H
n
(Hermite polynomials),
[sf.cmath.hermite]
handler,
see
exception handling, handler
happens after,
[intro.races]
happens before,
[intro.races]
hash
instantiation restrictions,
[unord.hash]
hash code,
[unord.req]
hash function,
[unord.req]
hash tables,
see
unordered associative containers
header
C,
[extern.names]
,
[res.on.macro.definitions]
,
[depr.c.headers]
C library,
[using.linkage]
C++ library,
[headers]
name,
[lex.header]
headers
C library,
[depr.c.headers]
Hermite polynomials
H
n
,
[sf.cmath.hermite]
hiding,
see
name hiding
high-order bit,
[intro.memory]
hosted implementation,
[intro.compliance]
I
ν
(Bessell functions),
[sf.cmath.cyl_bessel_i]
id
qualified,
[expr.prim.id.qual]
id-expression,
[expr.prim.id]
identifier,
[lex.name]
,
[expr.prim.id.unqual]
,
[dcl.dcl]
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
definition of,
[expr.prim.lambda.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]
inclusion
conditional,
see
preprocessing directive, conditional inclusion
source file,
see
preprocessing directives, source-file inclusion
incomplete,
[expr.add]
increment operator
overloaded,
see
overloading, increment operator
independent_bits_engine
generation algorithm,
[rand.adapt.ibits]
state,
[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,
[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
,
[dcl.type.cv]
,
[dcl.init]
const member,
[class.base.init]
constant,
[basic.start.static]
constructor and,
[class.init]
,
[class.expl.init]
copy,
[dcl.init]
default,
[dcl.init]
default constructor and,
[class.init]
definition and,
[dcl.dcl]
direct,
[dcl.init]
dynamic,
[basic.start.static]
dynamic block-scope,
[stmt.dcl]
dynamic non-local,
[basic.start.dynamic]
explicit,
[class.expl.init]
jump past,
[stmt.dcl]
list-initialization,
[dcl.init.list]
local
static
,
[stmt.dcl]
local
thread_local
,
[stmt.dcl]
member,
[class.base.init]
member function call during,
[class.base.init]
member object,
[class.base.init]
non-vacuous,
[basic.life]
order of,
[basic.start.dynamic]
,
[class.mi]
order of base class,
[class.base.init]
order of member,
[class.base.init]
order of virtual base class,
[class.base.init]
overloaded assignment and,
[class.expl.init]
parameter,
[expr.call]
reference,
[dcl.ref]
,
[dcl.init.ref]
reference member,
[class.base.init]
runtime,
[basic.start.static]
static and thread,
[basic.start.static]
static member,
[class.static.data]
static
object,
[basic.start.static]
,
[dcl.init]
union
,
[dcl.init.aggr]
,
[class.union.anon]
virtual base class,
[class.copy.ctor]
zero-initialization,
[dcl.init]
initializer
base class,
[dcl.fct.def.general]
member,
[dcl.fct.def.general]
pack expansion,
[class.base.init]
scope of member,
[class.base.init]
temporary and declarator,
[class.temporary]
initializer-list constructor,
[dcl.init.list]
seed sequence requirement,
[rand.req.seedseq]
<initializer_list>
,
[support.initlist]
initializing declaration,
[dcl.init]
injected-class-name
,
[class]
,
[class]
inline
,
[res.on.macro.definitions]
linkage of,
[basic.link]
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
macro,
[cpp.replace]
<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]
<iterator>
,
[iterator.synopsis]
,
[depr.iterator.basic]
j
n
(spherical Bessel functions),
[sf.cmath.sph_bessel]
J
ν
(Bessell functions),
[sf.cmath.cyl_bessel_j]
Jessie,
[class.conv.ctor]
K
(complete elliptic integrals),
[sf.cmath.comp_ellint_1]
K
ν
(Bessell functions),
[sf.cmath.cyl_bessel_k]
keyword,
[lex.key]
,
[gram.key]
L
n
(Laguerre polynomials),
[sf.cmath.laguerre]
L
m
n
(associated Laguerre polynomials),
[sf.cmath.assoc_laguerre]
label,
[stmt.goto]
case
,
[stmt.label]
,
[stmt.switch]
default
,
[stmt.label]
,
[stmt.switch]
scope of,
[basic.funscope]
,
[stmt.label]
Laguerre polynomials
L
n
,
[sf.cmath.laguerre]
L
m
n
,
[sf.cmath.assoc_laguerre]
lambda-introducer
,
[dcl.type.simple]
lattice,
see
DAG, subobject
layout
bit-field,
[class.bit]
class object,
[class.mem]
,
[class.mi]
layout-compatible,
[basic.types]
class,
[class.mem]
enumeration,
[dcl.enum]
layout-compatible type,
[basic.types]
left shift
undefined,
[expr.shift]
left shift operator,
see
operator, left shift
Legendre functions
Y
m
ℓ
,
[sf.cmath.sph_legendre]
Legendre polynomials
P
ℓ
,
[sf.cmath.legendre]
P
m
ℓ
,
[sf.cmath.assoc_legendre]
lexical conventions,
see
conventions, lexical
LIA-1,
[intro.refs]
library
C standard,
[library.c]
,
[character.seq]
,
[headers]
,
[using.linkage]
,
[diff.library]
,
[diff.mods.to.headers]
,
[depr.c.headers]
C++ standard,
[library.general]
,
[derived.classes]
,
[replacement.functions]
,
[res.on.arguments]
,
[derivation]
,
[res.on.exception.handling]
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]
modulus,
[rand.eng.lcong]
state,
[rand.eng.lcong]
textual representation,
[rand.eng.lcong]
transition algorithm,
[rand.eng.lcong]
linkage,
[basic]
,
[basic.link]
,
[basic.link]
const
and,
[basic.link]
external,
[basic.link]
,
[using.linkage]
,
[extern.names]
implementation-defined object,
[dcl.link]
inline
and,
[basic.link]
internal,
[basic.link]
no,
[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]
wide,
[lex.ccon]
constant,
[lex.literal.kinds]
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]
integer,
[lex.icon]
,
[lex.icon]
long
,
[lex.icon]
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]
raw,
[lex.pptoken]
,
[lex.string]
type of,
[lex.string]
undefined change to,
[lex.string]
UTF-8,
[lex.string]
wide,
[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
name of,
[zombie.names]
local class,
[class.local]
friend,
[class.friend]
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>
,
[locale.syn]
,
[locale]
locale,
[re.def]
,
[defns.regex.matched]
,
[re.req]
,
[re.synopt]
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]
class member,
[class.qual]
,
[basic.lookup.classref]
elaborated type specifier,
[basic.lookup.elab]
member name,
[class.member.lookup]
name,
[basic.lookup]
,
[basic]
namespace aliases and,
[basic.lookup.udir]
namespace member,
[namespace.qual]
qualified name,
[basic.lookup.qual]
template name,
[temp.res]
unqualified name,
[basic.lookup.unqual]
using-directives and,
[basic.lookup.udir]
lookup_classname
regular expression traits,
[re.req]
,
[re.grammar]
lookup_collatename
regular expression traits,
[re.req]
low-order bit,
[intro.memory]
lowercase,
[character.seq]
lvalue,
[basic.lval]
,
[diff.expr]
lvalue reference,
[basic.compound]
,
[dcl.ref]
Lvalue-Callable,
[func.wrap.func]
macro
argument substitution,
[cpp.subst]
function-like,
[cpp.replace]
,
[cpp.replace]
arguments,
[cpp.replace]
masking,
[res.on.macro.definitions]
name,
[cpp.replace]
object-like,
[cpp.replace]
,
[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]
return from,
[basic.start.main]
,
[basic.start.term]
make progress
thread,
[intro.progress]
<map>
,
[associative.map.syn]
match_results
as sequence,
[re.results]
matched,
[defns.regex.format.specifier]
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]
static,
[class.mem]
,
[class.static]
template and
static
,
[temp.static]
member access operator
overloaded,
[over.ref]
member data
static,
[class.static.data]
member function,
[class.mem]
call undefined,
[class.mfct.non-static]
class,
[class.mfct]
const
,
[class.this]
constructor and,
[class.ctor]
destructor and,
[class.dtor]
friend,
[class.friend]
inline,
[class.mfct]
local class,
[class.local]
nested class,
[class.access.nest]
non-static,
[class.mfct.non-static]
overload resolution and,
[over.match.funcs]
static,
[class.mem]
,
[class.static.mfct]
this
,
[class.this]
union
,
[class.union]
volatile
,
[class.this]
member names,
[basic.scope.namespace]
member of an unknown specialization,
[temp.dep.type]
member of the current instantiation,
see
current instantiation, member of the
member pointer to,
see
pointer to member
member subobject,
[intro.object]
members,
[basic.scope.namespace]
<memory>
,
[memory.syn]
,
[depr.storage.iterator]
,
[depr.temporary.buffer]
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]
state,
[rand.eng.mers]
textual representation,
[rand.eng.mers]
transition algorithm,
[rand.eng.mers]
message
diagnostic,
[defns.diagnostic]
,
[intro.compliance]
min
random number distribution requirement,
[rand.req.dist]
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
class object,
see
constructor, move
,
see
assignment operator, 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
mutable
,
[dcl.stc]
,
[gram.dcl]
mutable iterator,
[iterator.requirements.general]
<mutex>
,
[mutex.syn]
mutex types,
[thread.mutex.requirements.mutex]
n
n
(spherical Neumann functions),
[sf.cmath.sph_neumann]
N
ν
(Neumann functions),
[sf.cmath.cyl_neumann]
name,
[lex.name]
,
[basic]
,
[expr.prim.id]
address of cv-qualified,
[expr.unary.op]
dependent,
[temp.dep.res]
,
[temp.dep]
elaborated
enum
,
[dcl.type.elab]
global,
[basic.scope.namespace]
length of,
[lex.name]
macro,
see
macro, name
point of declaration,
[basic.scope.pdecl]
predefined macro,
see
macro, predefined
qualified,
[basic.lookup.qual]
reserved,
[reserved.names]
same,
[basic]
scope of,
[basic.scope.declarative]
unqualified,
[basic.lookup.unqual]
zombie,
[zombie.names]
name class,
see
class name
name hiding,
[basic.scope.pdecl]
,
[basic.scope.hiding]
,
[expr.prim.id.qual]
,
[stmt.dcl]
class definition,
[class.name]
function,
[over.dcl]
overloading versus,
[over.dcl]
user-defined conversion and,
[class.conv]
using-declaration and,
[namespace.udecl]
name space
label,
[stmt.label]
namespace,
[contents]
,
[depr.c.headers]
alias,
[namespace.alias]
associated,
[basic.lookup.argdep]
definition,
[namespace.def]
extend,
[namespace.def]
global,
[lex.name]
member definition,
[namespace.memdef]
unnamed,
[namespace.unnamed]
namespaces,
[basic.namespace]
NaN,
[sf.cmath]
narrowing conversion,
[dcl.init.list]
NDEBUG
,
[using.headers]
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]
Neumann functions
n
n
,
[sf.cmath.sph_neumann]
N
ν
,
[sf.cmath.cyl_neumann]
<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
replaceable,
[replacement.functions]
scoping and,
[expr.new]
storage allocation,
[expr.new]
type of,
[class.free]
unspecified constructor and,
[expr.new]
unspecified order of evaluation,
[expr.new]
new-expression
placement,
[expr.new]
new-extended alignment,
[basic.align]
new_handler
,
[basic.stc.dynamic.allocation]
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
mean,
[rand.dist.norm.normal]
probability density function,
[rand.dist.norm.normal]
standard deviation,
[rand.dist.norm.normal]
normative references,
see
references, normative
notation
syntax,
[syntax]
NTBS,
[byte.strings]
,
[multibyte.strings]
,
[filebuf.members]
,
[depr.istrstream.cons]
,
[depr.ostrstream.cons]
static,
[byte.strings]
NTCTS,
[defns.ntcts]
NTMBS,
[multibyte.strings]
static,
[multibyte.strings]
null character,
see
character, null
null pointer value,
see
value, null pointer
null statement,
[stmt.expr]
null wide character,
see
wide-character, null
number
hex,
[lex.ccon]
octal,
[lex.ccon]
preprocessing,
[lex.ppnumber]
subnormal,
[denorm.style]
,
[numeric.limits.members]
<numeric>
,
[numeric.ops.overview]
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,
[basic.type.qualifier]
const volatile,
[basic.type.qualifier]
definition,
[basic.def]
delete,
[expr.delete]
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]
volatile,
[basic.type.qualifier]
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, exception,
see
exception handling, exception object
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
atomic,
[intro.multithread]
operator,
[lex.operators]
,
[over.oper]
%=
,
[expr.ass]
&=
,
[expr.ass]
*=
,
[expr.ass]
+=
,
[expr.pre.incr]
,
[expr.ass]
-=
,
[expr.ass]
/=
,
[expr.ass]
<<=
,
[expr.ass]
>>=
,
[expr.ass]
^=
,
[expr.ass]
|=
,
[expr.ass]
addition,
[expr.add]
additive,
[expr.add]
address-of,
[expr.unary]
assignment,
[expr.ass]
,
[functions.within.classes]
bitwise,
[expr.bit.and]
bitwise AND,
[expr.bit.and]
bitwise exclusive OR,
[expr.xor]
bitwise inclusive OR,
[expr.or]
cast,
[expr.unary]
,
[dcl.name]
class member access,
[expr.ref]
comma,
[expr.comma]
conditional expression,
[expr.cond]
copy assignment,
see
assignment operator, copy
decrement,
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
division,
[expr.mul]
equality,
[expr.eq]
function call,
[expr.call]
,
[over.oper]
greater than,
[expr.rel]
greater than or equal to,
[expr.rel]
increment,
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
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]
pragma,
see
macro, pragma operator
precedence of,
[intro.execution]
relational,
[expr.rel]
remainder,
[expr.mul]
right shift,
[expr.shift]
scope resolution,
[basic.lookup.qual]
,
[expr.prim.id.qual]
,
[expr.new]
,
[class.mfct]
,
[class.derived]
,
[class.virtual]
side effects and comma,
[expr.comma]
side effects and logical AND,
[expr.log.and]
side effects and logical OR,
[expr.log.or]
sizeof
,
[expr.unary]
,
[expr.sizeof]
subscripting,
[expr.sub]
,
[over.oper]
subtraction,
[expr.add]
unary,
[expr.unary]
,
[expr.unary.op]
unary minus,
[expr.unary]
,
[expr.unary.op]
unary plus,
[expr.unary]
,
[expr.unary.op]
operator delete
,
see also
delete
,
[expr.new]
,
[expr.delete]
,
[class.free]
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
address of,
[expr.unary.op]
,
[over.over]
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]
initialization,
[over.match.ctor]
,
[over.match.copy]
,
[over.match.conv]
,
[over.match.ref]
,
[over.match.list]
operators,
[over.match.oper]
scoping ambiguity,
[class.member.lookup]
template,
[temp.func.order]
template name,
[temp.res]
viable functions,
[over.match.viable]
subscripting operator,
[over.sub]
unary operator,
[over.unary]
user-defined literal,
[over.literal]
using directive and,
[namespace.udir]
using-declaration and,
[namespace.udecl]
overloads
floating-point,
[cmplx.over]
overrider
final,
[class.virtual]
own,
[unique.ptr]
P
ℓ
(Legendre polynomials),
[sf.cmath.legendre]
P
m
ℓ
(associated Legendre polynomials),
[sf.cmath.assoc_legendre]
pack expansion,
[temp.variadic]
pattern,
[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,
[defns.parameter]
,
[defns.parameter.macro]
,
[defns.parameter.templ]
catch clause,
[defns.parameter]
function,
[defns.parameter]
function-like macro,
[defns.parameter.macro]
reference,
[dcl.ref]
scope of,
[basic.scope.block]
template,
[defns.parameter.templ]
,
[basic.def]
void
,
[dcl.fct]
parameter declaration,
[basic.def]
parameter list
variable,
[expr.call]
,
[dcl.fct]
parameter pack,
[temp.variadic]
unexpanded,
[temp.variadic]
parameter-type-list,
[dcl.fct]
parameterized type,
see
template
parameters
macro,
[cpp.replace]
path equality,
[fs.path.nonmember]
pattern,
see
pack expansion, pattern
period,
[character.seq]
phases of translation,
see
translation, phases
Π
(complete elliptic integrals),
[sf.cmath.comp_ellint_3]
Π
(incomplete elliptic integrals),
[sf.cmath.ellint_3]
piecewise construction,
[pairs.pair]
piecewise_constant_distribution
interval boundaries,
[rand.dist.samp.pconst]
probability density function,
[rand.dist.samp.pconst]
weights,
[rand.dist.samp.pconst]
piecewise_linear_distribution
interval boundaries,
[rand.dist.samp.plinear]
probability density function,
[rand.dist.samp.plinear]
weights at boundaries,
[rand.dist.samp.plinear]
placeholder type deduction,
[dcl.type.auto.deduct]
placement
new-expression
,
[expr.new]
placement syntax
new
,
[expr.new]
plain lock-free atomic operation,
[support.signal]
POD class,
[class]
POD struct,
[class]
POD union,
[class]
point,
[basic.compound]
point of declaration,
[basic.scope.pdecl]
pointer,
see also
void*
composite pointer type,
[expr]
integer representation of safely-derived,
[basic.stc.dynamic.safety]
safely-derived,
[basic.stc.dynamic.safety]
to traceable object,
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
zero,
[conv.ptr]
pointer literal,
see
literal, pointer
pointer past the end of,
[basic.compound]
pointer to,
[basic.compound]
pointer to member,
[basic.compound]
,
[expr.mptr.oper]
pointer-interconvertible,
[basic.compound]
Poisson distributions,
[rand.dist.pois]
poisson_distribution
discrete probability function,
[rand.dist.pois.poisson]
mean,
[rand.dist.pois.poisson]
pool resource classes,
[mem.res.pool.overview]
pools,
[mem.res.pool.overview]
population,
[alg.random.sample]
POSIX,
[intro.refs]
extended regular expressions,
[re.synopt]
regular expressions,
[re.synopt]
postfix
++
,
[expr.post.incr]
postfix
++
and
--
overloading,
[over.inc]
postfix
--
,
[expr.post.incr]
potential results,
[basic.def.odr]
potential scope,
[basic.scope.declarative]
potentially concurrent,
[intro.races]
potentially evaluated,
[basic.def.odr]
potentially-throwing
exception specification,
[except.spec]
expression,
[except.spec]
precedence of operator,
see
operator, precedence of
prefix
L
,
[lex.ccon]
,
[lex.string]
R
,
[lex.string]
u
,
[lex.ccon]
,
[lex.ccon]
,
[lex.string]
,
[lex.string]
u8
,
[lex.ccon]
,
[lex.string]
prefix
++
,
[expr.pre.incr]
prefix
++
and
--
overloading,
[over.inc]
prefix
--
,
[expr.pre.incr]
preprocessing directive,
[cpp]
conditional inclusion,
[cpp.cond]
preprocessing directives,
[cpp]
error,
[cpp.error]
header inclusion,
[cpp.include]
line control,
[cpp.line]
macro replacement,
see
macro, replacement
null,
[cpp.null]
pragma,
[cpp.pragma]
source-file inclusion,
[cpp.include]
primary class template,
see
template, primary
primary equivalence class,
[defns.regex.matched]
private
,
see
access control,
private
probability density function
cauchy_distribution
,
[rand.dist.norm.cauchy]
chi_squared_distribution
,
[rand.dist.norm.chisq]
exponential_distribution
,
[rand.dist.pois.exp]
extreme_value_distribution
,
[rand.dist.pois.extreme]
fisher_f_distribution
,
[rand.dist.norm.f]
gamma_distribution
,
[rand.dist.pois.gamma]
lognormal_distribution
,
[rand.dist.norm.lognormal]
normal_distribution
,
[rand.dist.norm.normal]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
student_t_distribution
,
[rand.dist.norm.t]
uniform_real_distribution
,
[rand.dist.uni.real]
weibull_distribution
,
[rand.dist.pois.weibull]
program,
[basic.link]
,
[basic.link]
ill-formed,
[defns.ill.formed]
start,
[basic.start.main]
termination,
[basic.start.term]
well-formed,
[defns.well.formed]
,
[intro.execution]
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]
protected
,
see
access control,
protected
protection,
see
access control
,
[protection.within.classes]
provides storage,
[intro.object]
prvalue,
[basic.lval]
pseudo-destructor-name,
[expr.pseudo]
ptrdiff_t
,
[expr.add]
implementation-defined type of,
[expr.add]
public
,
see
access control,
public
punctuator,
[lex.operators]
qualification
explicit,
[basic.lookup.qual]
<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]
normal,
[rand.dist.norm]
Poisson,
[rand.dist.pois]
sampling,
[rand.dist.samp]
uniform,
[rand.dist.uni]
random number engine
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
requirements,
[rand.req.eng]
subtract_with_carry_engine
,
[rand.eng.sub]
with predefined parameters,
[rand.predef]
random number engine adaptor
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
with predefined parameters,
[rand.predef]
random number generation,
[rand]
distributions,
[rand.dist]
engines,
[rand.eng]
predefined engines and adaptors,
[rand.predef]
requirements,
[rand.req]
synopsis,
[rand.synopsis]
utilities,
[rand.util]
random number generator,
see
uniform random bit generator
random_device
implementation leeway,
[rand.device]
<ratio>
,
[ratio.syn]
raw string literal,
[lex.string]
reaching scope,
[expr.prim.lambda.capture]
ready,
[re.results]
,
[futures.state]
redefinition
typedef
,
[dcl.typedef]
reference,
[basic.compound]
assignment to,
[expr.ass]
call by,
[expr.call]
forwarding,
[temp.deduct.call]
lvalue,
[basic.compound]
null,
[dcl.ref]
rvalue,
[basic.compound]
sizeof
,
[expr.sizeof]
reference collapsing,
[dcl.ref]
reference-compatible,
[dcl.init.ref]
reference-related,
[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]
region
declarative,
[basic]
,
[basic.scope.declarative]
register
storage class,
[diff.cpp14.dcl.dcl]
regular expression,
[re]
grammar,
[re.grammar]
matched,
[defns.regex.format.specifier]
requirements,
[re.req]
regular expression traits,
[re.grammar]
char_class_type
,
[re.req]
isctype
,
[re.req]
lookup_classname
,
[re.req]
,
[re.grammar]
lookup_collatename
,
[re.req]
requirements,
[re.req]
,
[re.traits]
transform
,
[re.req]
,
[re.grammar]
transform_primary
,
[re.req]
,
[re.grammar]
translate
,
[re.req]
,
[re.grammar]
translate_nocase
,
[re.req]
,
[re.grammar]
reinterpret_cast
,
see
cast, reinterpret
relaxed pointer safety,
[basic.stc.dynamic.safety]
release sequence,
[intro.races]
remainder operator,
see
operator, remainder
replacement
macro,
see
macro, replacement
representation
object,
[basic.types]
value,
[basic.types]
represents the address,
[basic.compound]
requirements,
[structure.requirements]
Allocator
,
[allocator.requirements]
container,
[container.requirements]
,
[unord.req]
,
[array.overview]
,
[array.cons]
,
[re.results]
not required for unordered associated containers,
[unord.req]
CopyAssignable
,
[utility.arg.requirements]
CopyConstructible
,
[utility.arg.requirements]
DefaultConstructible
,
[utility.arg.requirements]
Destructible
,
[utility.arg.requirements]
EqualityComparable
,
[utility.arg.requirements]
Hash
,
[hash.requirements]
iterator,
[iterator.requirements.general]
LessThanComparable
,
[utility.arg.requirements]
MoveAssignable
,
[utility.arg.requirements]
MoveConstructible
,
[utility.arg.requirements]
NullablePointer
,
[nullablepointer.requirements]
numeric type,
[numeric.requirements]
random number distribution,
[rand.req.dist]
random number engine,
[rand.req.eng]
regular expression traits,
[re.req]
,
[re.traits]
seed sequence,
[rand.req.seedseq]
sequence,
[re.results]
uniform random bit generator,
[rand.req.urng]
unordered associative container,
[unord.req]
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]
union
,
[class.union]
result
glvalue,
[basic.lval]
prvalue,
[basic.lval]
result object,
[basic.lval]
result_type
entity characterization based on,
[rand]
random number distribution requirement,
[rand.req.dist]
seed sequence requirement,
[rand.req.seedseq]
uniform random bit generator requirement,
[rand.req.urng]
rethrow,
see
exception handling, rethrow
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]
sample,
[alg.random.sample]
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]
block,
[basic.scope.block]
class,
[basic.scope.class]
declarations and,
[basic.scope.declarative]
destructor and exit from,
[stmt.jump]
enumeration,
[basic.scope.enum]
exception declaration,
[basic.scope.block]
function,
[basic.funscope]
function prototype,
[basic.scope.proto]
global,
[basic.scope.namespace]
global namespace,
[basic.scope.namespace]
iteration-statement
,
[stmt.iter]
macro definition,
see
macro, scope of definition
name lookup and,
[basic.lookup]
namespace,
[basic.scope.namespace]
overloading and,
[over.dcl]
potential,
[basic.scope.declarative]
selection-statement
,
[stmt.select]
template parameter,
[basic.scope.temp]
scope name hiding and,
[basic.scope.hiding]
scope resolution operator,
see
operator, scope resolution
<scoped_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
<set>
,
[associative.set.syn]
<setjmp.h>
,
[csetjmp.syn]
setlocale
,
[character.seq]
shared lock,
[thread.sharedmutex.requirements]
shared mutex types,
[thread.sharedmutex.requirements]
shared state,
see
future, shared state
shared timed mutex type,
[thread.sharedtimedmutex.requirements]
<shared_mutex>
,
[shared_mutex.syn]
shift operator
left,
see
operator, left shift
right,
see
operator, right shift
short
typedef
and,
[dcl.spec]
shuffle_order_engine
generation algorithm,
[rand.adapt.shuf]
state,
[rand.adapt.shuf]
textual representation,
[rand.adapt.shuf]
transition algorithm,
[rand.adapt.shuf]
side effects,
[intro.execution]
,
[intro.races]
,
[intro.execution]
,
[expr.log.and]
,
[expr.log.or]
,
[stmt.expr]
,
[class.temporary]
,
[class.base.init]
,
[class.copy.elision]
,
[cpp.scope]
,
[res.on.data.races]
visible,
[intro.races]
,
[intro.races]
signal,
[intro.execution]
signal-safe
_Exit
,
[support.start.term]
abort
,
[support.start.term]
evaluation,
see
evaluation, signal-safe
forward
,
[forward]
initializer_list
functions,
[support.initlist]
memcpy
,
[cstring.syn]
memmove
,
[cstring.syn]
move
,
[forward]
move_if_noexcept
,
[forward]
numeric_limits
members,
[numeric.limits.members]
quick_exit
,
[support.start.term]
signal
,
[support.signal]
type traits,
[meta]
<signal.h>
,
[csignal.syn]
signature,
[defns.signature]
,
[defns.signature.templ]
,
[defns.signature.spec]
,
[defns.signature.member]
,
[defns.signature.member.templ]
,
[defns.signature.member.spec]
signed
typedef
and,
[dcl.spec]
signed integer representation
ones' complement,
[basic.fundamental]
,
[expr.unary.op]
,
[dcl.enum]
signed magnitude,
[basic.fundamental]
,
[dcl.enum]
two's complement,
[basic.fundamental]
,
[conv.integral]
,
[dcl.enum]
,
[ratio.ratio]
,
[atomics.types.int]
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,
[lex.separate]
,
[using.headers]
,
[alt.headers]
source file character,
see
character, source file
space
white,
[lex.pptoken]
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]
C++,
[res.on.exception.handling]
specifier,
[dcl.spec]
constexpr
,
[dcl.constexpr]
constructor,
[dcl.constexpr]
,
[dcl.constexpr]
function,
[dcl.constexpr]
,
[dcl.constexpr]
cv-qualifier,
[dcl.type.cv]
declaration,
[dcl.spec]
explicit
,
[dcl.fct.spec]
friend
,
[dcl.friend]
,
[protection.within.classes]
function,
[dcl.fct.spec]
inline
,
[dcl.inline]
static
,
[dcl.stc]
storage class,
[dcl.stc]
type,
see
type specifier
typedef
,
[dcl.typedef]
virtual
,
[dcl.fct.spec]
specifier access,
see
access specifier
spherical harmonics
Y
m
ℓ
,
[sf.cmath.sph_legendre]
<sstream>
,
[sstream.syn]
stable algorithm,
[defns.stable]
,
[algorithm.stable]
<stack>
,
[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
program,
[basic.start.dynamic]
startup
program,
[using.linkage]
,
[replacement.functions]
state,
[any.class]
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
statement,
[stmt.stmt]
break
,
[stmt.jump]
,
[stmt.break]
compound,
[stmt.block]
continue
,
[stmt.jump]
,
[stmt.cont]
continue
in
for
,
[stmt.for]
declaration,
[stmt.dcl]
declaration in
for
,
[stmt.for]
declaration in
if
,
[stmt.stmt]
declaration in
switch
,
[stmt.stmt]
,
[stmt.switch]
declaration in
while
,
[stmt.while]
do
,
[stmt.iter]
,
[stmt.do]
empty,
[stmt.expr]
expression,
[stmt.expr]
fallthrough,
[dcl.attr.fallthrough]
for
,
[stmt.iter]
,
[stmt.for]
goto
,
[stmt.label]
,
[stmt.jump]
,
[stmt.goto]
if
,
[stmt.select]
,
[stmt.if]
iteration,
[stmt.iter]
jump,
[stmt.jump]
labeled,
[stmt.label]
null,
[stmt.expr]
range based
for
,
[stmt.ranged]
selection,
[stmt.select]
switch
,
[stmt.select]
,
[stmt.switch]
,
[stmt.break]
while
,
[stmt.iter]
,
[stmt.while]
static
,
[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]
<stdatomic.h>
,
[headers]
,
[diff.mods.to.headers]
<stddef.h>
,
[lex.ccon]
,
[lex.string]
<stdexcept>
,
[std.exceptions]
,
[stdexcept.syn]
<stdio.h>
,
[cstdio.syn]
<stdlib.h>
,
[depr.c.headers]
<stdnoreturn.h>
,
[headers]
,
[diff.mods.to.headers]
storage class,
[basic]
storage duration,
[basic.stc]
,
[basic.stc]
automatic,
[basic.stc]
,
[basic.stc.auto]
class member,
[basic.stc.inherit]
dynamic,
[basic.stc]
,
[basic.stc.dynamic]
,
[expr.new]
local object,
[basic.stc.auto]
static,
[basic.stc]
,
[basic.stc.static]
thread,
[basic.stc]
,
[basic.stc.thread]
storage management,
see
new
,
delete
stream
arbitrary-positional,
[defns.arbitrary.stream]
repositional,
[defns.repositional.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]
<strstream>
,
[depr.str.strstreams]
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]
sub-expression,
[defns.regex.regular.expression]
subexpression,
[intro.execution]
subnormal number,
see
number, subnormal
subobject,
see also
object model
,
[intro.object]
,
[intro.object]
subscripting operator
overloaded,
[over.sub]
subsequence rule
overloading,
[over.ics.rank]
subtract_with_carry_engine
carry,
[rand.eng.sub]
generation algorithm,
[rand.eng.sub]
state,
[rand.eng.sub]
textual representation,
[rand.eng.sub]
transition algorithm,
[rand.eng.sub]
subtraction
implementation-defined pointer,
[expr.add]
subtraction operator,
see
operator, subtraction
suffix
e
,
[lex.fcon]
,
[lex.fcon]
F
,
[lex.fcon]
,
[lex.fcon]
L
,
[lex.icon]
,
[lex.icon]
,
[lex.fcon]
,
[lex.fcon]
p
,
[lex.fcon]
,
[lex.fcon]
U
,
[lex.icon]
,
[lex.icon]
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,
[swappable.requirements]
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]
class,
[temp.class]
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]
primary,
[temp.class.spec]
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]
elimination of,
[class.temporary]
,
[class.copy.elision]
implementation-defined generation of,
[class.temporary]
order of destruction of,
[class.temporary]
terminate
,
[except.terminate]
called,
[expr.throw]
,
[except.throw]
,
[except.spec]
,
[except.terminate]
termination
program,
[basic.start.main]
,
[basic.start.term]
terminology
pointer,
[basic.compound]
textual representation
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
<tgmath.h>
,
[diff.mods.to.headers]
this
,
[expr.prim.this]
,
[class.this]
type of,
[class.this]
this
pointer,
see
this
<thread>
,
[thread.syn]
thread,
[intro.multithread]
thread of execution,
[intro.multithread]
thread storage duration,
[basic.stc.thread]
thread_local
,
[dcl.stc]
,
[gram.dcl]
threads
multiple,
[intro.multithread]
<threads.h>
,
[headers]
,
[diff.mods.to.headers]
throw
,
[expr.throw]
throwing,
see
exception handling, throwing
<time.h>
,
[ctime.syn]
timed mutex types,
[thread.timedmutex.requirements]
token,
[lex.token]
alternative,
[lex.digraph]
preprocessing,
[lex.pptoken]
traceable pointer object,
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
traits,
[defns.traits]
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]
try
,
[except]
try block,
see
exception handling, try block
<tuple>
,
[tuple.syn]
tuple
and
pair
,
[pairs.general]
type,
[basic]
,
[basic.types]
allocated,
[expr.new]
arithmetic,
[basic.fundamental]
promoted,
[over.built]
array,
[basic.compound]
bitmask,
[bitmask.types]
,
[bitmask.types]
Boolean,
[basic.fundamental]
char
,
[basic.fundamental]
char16_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
char32_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
character,
[basic.fundamental]
character container,
[defns.character.container]
class and,
[class]
compound,
[basic.compound]
const
,
[dcl.type]
cv-combined,
[expr]
cv-unqualified,
[basic.type.qualifier]
destination,
[dcl.init]
double
,
[basic.fundamental]
dynamic,
[defns.dynamic.type]
,
[defns.dynamic.type.prvalue]
enumerated,
[basic.compound]
,
[enumerated.types]
,
[bitmask.types]
example of incomplete,
[basic.types]
extended integer,
[basic.fundamental]
extended signed integer,
[basic.fundamental]
extended unsigned integer,
[basic.fundamental]
float
,
[basic.fundamental]
floating-point,
[basic.fundamental]
function,
[basic.compound]
,
[dcl.fct]
fundamental,
[basic.fundamental]
implementation-defined
sizeof
,
[basic.fundamental]
incomplete,
[basic.def]
,
[basic.def.odr]
,
[basic.scope.pdecl]
,
[basic.types]
,
[conv.lval]
,
[expr.sub]
,
[expr.call]
,
[expr.type.conv]
,
[expr.ref]
,
[expr.dynamic.cast]
,
[expr.unary.op]
,
[expr.sizeof]
,
[expr.new]
,
[expr.delete]
,
[expr.ass]
,
[class.derived]
incompletely-defined object,
[basic.types]
int
,
[basic.fundamental]
integral,
[basic.fundamental]
promoted,
[over.built]
long
,
[basic.fundamental]
long double
,
[basic.fundamental]
long long
,
[basic.fundamental]
narrow character,
[basic.fundamental]
over-aligned,
[basic.align]
POD,
[basic.types]
pointer,
[basic.compound]
polymorphic,
[class.virtual]
referenceable,
[defns.referenceable]
short
,
[basic.fundamental]
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]
static,
[defns.static.type]
trivially copyable,
[basic.types]
underlying
char16_t
,
[basic.fundamental]
,
[conv.prom]
char32_t
,
[basic.fundamental]
,
[conv.prom]
enumeration,
[conv.prom]
,
[dcl.enum]
fixed,
[dcl.enum]
wchar_t
,
[basic.fundamental]
,
[conv.prom]
unsigned
,
[basic.fundamental]
unsigned char
,
[basic.fundamental]
unsigned int
,
[basic.fundamental]
unsigned integer,
[basic.fundamental]
unsigned long
,
[basic.fundamental]
unsigned long long
,
[basic.fundamental]
unsigned short
,
[basic.fundamental]
void
,
[basic.fundamental]
volatile
,
[dcl.type]
wchar_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
type checking
argument,
[expr.call]
type conversion, explicit,
see
casting
type generator,
see
template
type name,
[dcl.name]
nested,
[class.nested.type]
scope of,
[class.nested.type]
type pun,
[expr.reinterpret.cast]
type specifier
auto
,
[dcl.type.simple]
,
[dcl.spec.auto]
bool
,
[dcl.type.simple]
char
,
[dcl.type.simple]
char16_t
,
[dcl.type.simple]
char32_t
,
[dcl.type.simple]
const
,
[dcl.type.cv]
decltype
,
[dcl.type.simple]
double
,
[dcl.type.simple]
elaborated,
[basic.lookup.elab]
,
[dcl.type.elab]
enum
,
[dcl.type.elab]
float
,
[dcl.type.simple]
int
,
[dcl.type.simple]
long
,
[dcl.type.simple]
short
,
[dcl.type.simple]
signed
,
[dcl.type.simple]
simple,
[dcl.type.simple]
unsigned
,
[dcl.type.simple]
void
,
[dcl.type.simple]
volatile
,
[dcl.type.cv]
wchar_t
,
[dcl.type.simple]
type-name
,
[dcl.type.simple]
type_info
,
[expr.typeid]
<type_traits>
,
[meta.type.synop]
,
[depr.meta.types]
typedef
function,
[dcl.fct]
overloading and,
[over.load]
typeid
,
[expr.typeid]
construction and,
[class.cdtor]
destruction and,
[class.cdtor]
<typeindex>
,
[type.index.synopsis]
<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]
unblock,
[defns.unblock]
undefined,
[defns.required.behavior]
,
[defns.reserved.function]
,
[reserved.names]
,
[alt.headers]
,
[res.on.arguments]
,
[valarray.comparison]
,
[class.gslice.overview]
,
[indirect.array.assign]
,
[indirect.array.comp.assign]
,
[fpos.operations]
undefined behavior,
see
behavior, undefined
underlying type,
see
type, underlying
unevaluated operand,
[expr]
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]
anonymous,
[class.union.anon]
class
versus,
[class]
global anonymous,
[class.union.anon]
standard-layout,
[class]
union-like class,
[class.union.anon]
unique pointer,
[unique.ptr]
unit
translation,
[using.headers]
,
[macro.names]
universal character name,
[lex.phases]
unnamed bit-field,
[class.bit]
unordered associative containers,
[unord.req]
complexity,
[unord.req]
equality function,
[unord.req]
equivalent keys,
[unord.req]
,
[unord.multimap.overview]
,
[unord.multiset.overview]
exception safety,
[unord.req.except]
hash function,
[unord.req]
iterator invalidation,
[unord.req]
iterators,
[unord.req]
lack of comparison functions,
[unord.req]
requirements,
[unord.req]
,
[unord.req.except]
unique keys,
[unord.req]
,
[unord.map.overview]
,
[unord.set.overview]
<unordered_map>
,
[unord.map.syn]
unordered_map
element access,
[unord.map.elem]
unique keys,
[unord.map.overview]
unordered_multimap
equivalent keys,
[unord.multimap.overview]
unordered_multiset
equivalent keys,
[unord.multiset.overview]
<unordered_set>
,
[unord.set.syn]
unordered_set
unique keys,
[unord.set.overview]
unsequenced,
[intro.execution]
unsigned
typedef
and,
[dcl.spec]
unsigned integer type,
[basic.fundamental]
unspecified,
[new.delete.single]
,
[type.info]
,
[partial.sort]
,
[stringbuf.virtuals]
,
[depr.strstreambuf.cons]
,
[depr.strstreambuf.virtuals]
unspecified behavior,
see
behavior, unspecified
unwinding
stack,
[except.ctor]
uppercase,
[lex.name]
,
[character.seq]
upstream,
[mem.res.monotonic.buffer]
upstream allocator,
[mem.res.pool.overview]
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,
[basic.scope.declarative]
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]
null pointer,
[basic.compound]
,
[conv.ptr]
undefined unrepresentable integral,
[conv.fpint]
value category,
[basic.lval]
value computation,
[intro.execution]
,
[intro.races]
,
[expr.post.incr]
,
[expr.new]
,
[expr.log.and]
,
[expr.log.or]
,
[expr.cond]
,
[expr.ass]
,
[expr.comma]
,
[class.temporary]
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,
[class.virtual]
pure,
[class.abstract]
,
[class.abstract]
virtual function call,
[class.virtual]
constructor and,
[class.cdtor]
destructor and,
[class.cdtor]
undefined pure,
[class.abstract]
visibility,
[basic.scope.hiding]
visible,
[basic.scope.hiding]
void&
,
[dcl.ref]
void*
type,
[basic.compound]
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]
null,
[lex.charset]
wide-character literal,
[lex.ccon]
wide-character set
basic execution,
[lex.charset]
execution,
[lex.charset]
writable,
[iterator.requirements.general]
X(X&)
,
see
constructor, copy
xvalue,
[basic.lval]
Y
m
ℓ
(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]