Index

!, see operator, logical negation
!=, see inequality operator
"...", see preprocessing directives, source-file inclusion
# 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 remainder operator
&, see operator, address-of, see bitwise AND operator, see declarator, reference
&&, see logical AND operator
(), see operator, function call, see declarator, function
*, see operator, indirection, see multiplication operator, see declarator, pointer
+, see operator, unary plus, see addition operator
++, see operator, increment
,, see comma operator
-, see operator, unary minus, see subtraction operator
--, see operator, decrement
->, see operator, class member access
->*, see pointer to member operator
., see operator, class member access
.*, see pointer to member operator
..., see ellipsis
/, see division operator
:
field declaration, [class.bit]
label specifier, [stmt.label]
::, see scope resolution operator
::*, see declarator, pointer to member
<, see less than operator
template and, [temp.param], [temp.names]
<...>, see preprocessing directive, header
<<, see left shift operator
<=, see less than or equal to operator
=, see assignment operator
==, see equality operator
>, see greater than operator
>=, see greater than or equal operator
>>, see right shift operator
?:, see conditional expression operator
[], see operator, subscripting, see declarator, array
\, see backslash
^, see bitwise exclusive OR operator
_, see character, underscore
__ cplusplus, [cpp.predefined]
__DATE__, [cpp.predefined]
__FILE__, [cpp.predefined]
__LINE__, [cpp.predefined]
__STDC__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDC_HOSTED__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDC_ISO_10646__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDC_MB_MIGHT_NEQ_WC__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDC_VERSION__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDCPP_STRICT_POINTER_SAFETY__, [cpp.predefined]
implementation-defined, [cpp.predefined]
__STDCPP_THREADS__, [cpp.predefined]
implementation-defined, [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 bitwise inclusive OR operator
||, see logical OR operator
~, see operator, one's complement, see destructor
0, see also zero, null
null character, [lex.string]
string terminator, [lex.string]
abort, [basic.start.term], [stmt.jump]
access control, [class.access]
base class member, [class.derived]
class member, [expr.ref]
default argument, [class.access]
friend function, [class.friend]
member name, [class.access]
multiple access, [class.paths]
nested class, [class.access.nest]
overloading and, [over.dcl]
union default member, [class]
using-declaration and, [namespace.udecl]
virtual function, [class.access.virt]
access control
anonymous union, [class.union]
member function and, [special]
overloading resolution and, [class.member.lookup]
access specifier, [class.access.spec], [class.access.base]
addition operator, [expr.add]
address, [basic.compound], [expr.eq]
address of member function
unspecified, [member.functions]
aggregate, [dcl.init.aggr]
aggregate initialization, [dcl.init.aggr]
algorithm
alias
alias template, [temp.alias]
alignment
extended, [basic.align]
fundamental, [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]
allowing an exception, see exception handling, allowing an exception
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]
appertain, [dcl.attr.grammar]
argc, [basic.start.main]
argument, [intro.defs], [defns.argument], [defns.argument.macro], [defns.argument.throw], [res.on.arguments], [res.on.macro.definitions], [member.functions], [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, [intro.defs]
function-like macro, [defns.argument]
overloaded operator and default, [over.oper]
reference, [expr.call]
scope of default, [dcl.fct.default]
template, [temp.arg]
template instantiation, [defns.argument.throw]
throw expression, [defns.argument.macro]
type checking of default, [dcl.fct.default]
argument and name hiding
argument and virtual function
argument list
empty, [dcl.fct]
variable, [dcl.fct]
argument passing, [expr.call]
reference and, [dcl.init.ref]
argument substitution, see macro, argument substitution
argument type
unknown, [dcl.fct]
arguments
implementation-defined order of evaluation of function, [dcl.fct.default]
argv, [basic.start.main]
arithmetic
pointer, [expr.add]
array, [dcl.fct]
multidimensional, [dcl.array]
overloading and pointer versus, [over.load]
storage of, [dcl.array]
array
as aggregate, [array.overview]
contiguous storage, [array.overview]
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]
assignment
and lvalue, [expr.ass]
conversion by, [expr.ass]
reference, [dcl.init.ref]
assignment operator
copy, [special], [class.copy]
hidden, [class.copy]
implicitly declared, [class.copy]
implicitly defined, [class.copy]
inaccessible, [class.copy]
trivial, [class.copy]
virtual bases and, [class.copy]
move, [special], [class.copy]
hidden, [class.copy]
implicitly declared, [class.copy]
implicitly defined, [class.copy]
inaccessible, [class.copy]
trivial, [class.copy]
virtual bases and, [class.copy]
overloaded, [over.ass]
associative containers
exception safety, [associative.reqmts]
requirements, [associative.reqmts]
asynchronous provider, [futures.state]
asynchronous return object, [futures.state]
atexit, [basic.start.term]
atomic operations, see operation, atomic
attribute, [dcl.attr]
alignment, [dcl.align]
carries dependency, [dcl.attr.depend]
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_exception, [except.unexpected]
bad_typeid, [expr.typeid]
bad_typeid::what
implementation-defined, [bad.typeid]
base class
overloading and, [over.dcl]
base class subobject, [intro.object]
base class, [class.derived], [class.mi]
indirect, [class.derived]
base class virtual, see virtual base class
BaseCharacteristic, [meta.rqmts]
basic_ios::failure argument
implementation-defined, [iostate.flags]
begin
unordered associative containers, [unord.req]
behavior
conditionally-supported, [defns.argument.templ], [intro.compliance]
implementation-defined, [defns.ill.formed], [intro.execution]
locale-specific, [defns.impl.limits]
on receipt of signal, [intro.execution]
Ben, [over.dcl]
Bernoulli distributions, [rand.dist.bern]
bernoulli_distribution
discrete probability function, [rand.dist.bern.bernoulli]
binary function, [refwrap]
binary operator
overloaded, [over.binary]
binary operator
interpretation of, [over.binary]
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 sign of, [class.bit]
implementation defined alignment of, [class.bit]
type of, [class.bit]
unnamed, [class.bit]
zero width of, [class.bit]
block, [defns.block]
initialization in, [stmt.dcl]
block scope, [basic.scope.local]
block statement, see statement, compound
block structure, [stmt.dcl]
body
Boolean, [class.bit]
boolean literal, see literal, boolean, [lex.bool]
Boolean type, [basic.fundamental]
bound arguments, [func.bind.bind]
bound, of array, [dcl.array]
bucket
unordered associative containers, [unord.req]
bucket_count
unordered associative containers, [unord.req]
bucket_size
unordered associative containers, [unord.req]
buckets, [unord.req]
byte, [intro.memory], [expr.sizeof]
C
linkage to, [dcl.link]
standard, [intro.scope]
standard library, [intro.refs]
Unicode TR, [intro.refs]
call
operator function, [over.oper]
pseudo destructor, [expr.pseudo]
call signature, [func.def]
call wrapper, [func.def], [func.require]
forwarding, [func.require]
Callable, [func.wrap.func]
callable object, [func.def], [func.wrap.func]
callable type, [func.def]
captured, [expr.prim.lambda]
by reference, [expr.prim.lambda]
carries a dependency, [intro.multithread]
carry
subtract_with_carry_engine, [rand.eng.sub]
<cassert>, [using.headers]
cast
base class, [expr.static.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]
pointer-to-function, [expr.reinterpret.cast]
pointer to integer, [expr.reinterpret.cast]
undefined pointer-to-function, [expr.reinterpret.cast]
casting, [expr.type.conv]
catch, [except]
cauchy_distribution
probability density function, [rand.dist.norm.cauchy]
cbegin
unordered associative containers, [unord.req]
cend
unordered associative containers, [unord.req]
<cerrno>, [extern.names]
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, [lex.ccon]
char16_t character, [lex.ccon]
char32_t, [lex.ccon]
char32_t character, [lex.ccon]
character, [defns.character]
decimal-point, [character.seq]
source file, [lex.phases]
underscore, [global.names]
in identifier, [lex.name]
character literal, see literal, character
character set, [lex.charset]
basic execution, [intro.memory]
character string literal, [cpp.stringize]
character string, [lex.string]
checking
point of error, [temp.res]
syntax, [temp.res]
chi_squared_distribution
probability density function, [rand.dist.norm.chisq]
class, [basic.compound], [class]
cast to incomplete, [expr.cast]
constructor and abstract, [class.abstract]
definition, [basic.def]
derived, [derivation]
linkage of, [basic.link]
linkage specification, [dcl.link]
member function, see member function, class
pointer to abstract, [class.abstract]
polymorphic, [class.virtual]
scope of enumerator, [dcl.enum]
standard-layout, [class]
trivial, [class]
unnamed, [dcl.typedef]
class local, see local class
class name, [dcl.decl]
point of declaration, [class.name]
scope of, [class.name]
class nested, see nested class
class object
assignment to, [expr.ass]
member, [class.mem]
class object copy, see copy constructor
class object initialization, see constructor
clear
unordered associative containers, [unord.req]
<clocale>, [character.seq]
closure object, [expr.prim.lambda]
closure type, [expr.prim.lambda]
collating element, [re.def]
comment, [lex.pptoken], [lex.comment]
comparison
pointer to function, [expr.rel], [expr.eq]
undefined pointer, [expr.add], [expr.rel]
unspecified pointer, [expr.rel]
void* pointer, [expr.rel]
compatible, see exception specification, compatible
compilation
separate, [lex.separate]
compiler control line, see preprocessing directives
complete object, [intro.object]
complete object of, [intro.object]
completely defined, [class.mem]
component, [defns.component]
concatenation
macro argument, see ##
string, [lex.string]
conditions
rules for, [stmt.select]
conditional-expression
throw-expression in, [expr.cond]
conditionally-supported behavior
seebehavior, conditionally-supported, [intro]
conflict, [intro.multithread]
conformance requirements, [intro.compliance], [intro.execution]
class templates, [intro.compliance]
method of description, [intro.compliance]
consistency
linkage, [dcl.stc]
linkage specification, [dcl.link]
type declaration, [basic.link]
const, [basic.type.qualifier]
constructor and, [class.this], [class.ctor]
destructor and, [class.this], [class.dtor]
linkage of, [basic.link], [dcl.stc]
overloading and, [over.load]
const_cast, see cast, const
const_local_iterator, [unord.req]
unordered associative containers, [unord.req]
const-object
undefined change to, [dcl.type.cv]
constant, [lex.literal.kinds], [expr.prim.general]
enumeration, [dcl.enum]
null pointer, [conv.ptr], [conv.mem]
constant iterator, [iterator.requirements.general]
constexpr function, [dcl.constexpr]
construction, [class.cdtor]
dynamic cast and, [class.cdtor]
member access, [class.cdtor]
pointer to member or base, [class.cdtor]
typeid operator, [class.cdtor]
virtual function call, [class.cdtor]
constructor, [class.ctor]
address of, [class.ctor]
array of class objects and, [class.expl.init]
converting, [class.conv.ctor]
explicit call, [class.ctor]
implicitly called, [class.ctor]
implicitly defined, [class.ctor]
inheritance of, [class.ctor]
inheriting, [class.inhctor]
move, [special], [class.ctor], [class.copy]
elision, [class.copy]
implicitly declared, [class.copy]
implicitly defined, [class.copy]
inaccessible, [class.copy]
trivial, [class.copy]
non-trivial, [class.ctor]
random number distribution requirement, [rand.req.dist]
random number engine requirement, [rand.req.eng]
type of, [class.ctor]
unspecified argument to, [expr.new]
constructor, conversion by, see conversion, user-defined
constructor, default, see default constructor
context
non-deduced, [temp.deduct.type]
contextually converted to bool, see conversion, contextual
continue
and handler, [except]
and try block, [except]
control line, see preprocessing directives
conventions, [conventions]
conversion
argument, [dcl.fct]
array-to-pointer, [conv.array]
boolean, [conv.bool]
contextual, [conv]
derived-to-base, [over.best.ics]
floating point, [conv.double]
floating to integral, [conv.fpint]
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 pointer, [over.over]
overload resolution and, [over.match.best]
pointer, [conv.ptr]
pointer to member, [conv.mem]
void*, [conv.mem]
qualification, [conv.qual]
return type, [stmt.return]
standard, [conv]
static user-defined, [class.conv.fct]
to signed, [conv.integral]
to unsigned, [conv.integral]
usual arithmetic, [expr]
virtual user-defined, [class.conv.fct]
conversion operator, see conversion, user defined
conversion rank, [over.ics.scs]
conversion explicit type, see casting
conversion function, see conversion, user-defined
copy
copy constructor
random number engine requirement, [rand.req.eng]
copy elision, see constructor, copy, elision; constructor, move, elision
copy-initialization, [dcl.init]
CopyInsertable into X, [container.requirements.general]
count
unordered associative containers, [unord.req]
<cstdarg>, [dcl.fct]
<cstddef>, [expr.sizeof], [expr.add]
<cstdint>, [cstdint.syn]
<cstdlib>, [basic.start.term], [compliance]
<cstring>, [byte.strings]
<cuchar>, [extern.names]
cv-qualifier, [basic.type.qualifier]
<cwchar>, [extern.names]
<cwctype>, [extern.names]
DAG
multiple inheritance, [class.mi]
non-virtual base class, [class.mi]
virtual base class, [class.mi]
data race, [intro.multithread]
data member, see member
deadlock, [defns.deadlock]
deallocation, see delete
deallocation functions, [basic.stc.dynamic]
decay, see conversion, array to pointer; conversion, function to pointer
DECAY_COPY, [thread.decaycopy]
declaration, [basic], [basic.def], [dcl.dcl]
bit-field, [class.bit]
class name, [basic.def]
constant pointer, [dcl.ptr]
default argument, [dcl.fct.default]
definition versus, [basic.def]
ellipsis in function, [expr.call], [dcl.fct]
enumerator point of, [basic.scope.pdecl]
extern, [basic.def]
extern reference, [dcl.init.ref]
forward, [dcl.stc]
forward class, [class.name]
local class, [class.local]
member, [class.mem]
multiple, [basic.link]
opaque enum, [basic.def]
overloaded, [over]
overloaded name and friend, [class.friend]
pointer, [dcl.ptr]
reference, [dcl.ref]
register, [dcl.stc]
static member, [basic.def]
storage class, [dcl.stc]
typedef, [basic.def]
typedef as type, [dcl.typedef]
declaration hiding, see name hiding
declarative region, [basic.scope.declarative]
declarator, [basic.def], [dcl.dcl], [dcl.decl]
function, [dcl.fct]
meaning of, [dcl.meaning]
multidimensional array, [dcl.array]
pointer, [dcl.ptr]
pointer to member, [dcl.mptr]
reference, [dcl.ref]
decrement operator
default access control, see access control, default
default constructor
random number distribution requirement, [rand.req.dist]
seed sequence requirement, [rand.req.seedseq]
default-initialization, [dcl.init]
default argument
overload resolution and, [over.match.viable]
default initializers
overloading and, [over.load]
defaulted, [dcl.fct.def.default]
deferred function, [futures.async]
definition, [basic.def], [basic.def]
class name as type, [class.name]
declaration as, [dcl.dcl]
function, [dcl.fct.def]
explicitly-defaulted, [dcl.fct.def.default]
local class, [class.local]
member function, [class.mfct]
namespace, [namespace.def]
nested class, [class.nest]
pure virtual function, [class.abstract]
scope of class, [class.name]
static member, [class.static.data]
virtual function, [class.virtual]
definitions, [intro.defs]
delete, [basic.stc.dynamic], [expr.delete], [class.free]
destructor and, [expr.delete], [class.dtor]
type of, [class.free]
undefined, [expr.delete]
deleter, [unique.ptr]
dependency-ordered before, [intro.multithread]
deprecated features, [expr.post.incr], [expr.pre.incr]
dereferencing, see also indirection
derivation, see inheritance
derived class
derived object
derived class, [class.derived]
destruction, [class.cdtor]
dynamic cast and, [class.cdtor]
member access, [class.cdtor]
pointer to member or base, [class.cdtor]
typeid operator, [class.cdtor]
virtual function call, [class.cdtor]
destructor, [class.dtor], [functions.within.classes]
default, [class.dtor]
explicit call, [class.dtor]
implicit call, [class.dtor]
implicitly defined, [class.dtor]
non-trivial, [class.dtor]
program termination and, [class.dtor]
pure virtual, [class.dtor]
virtual, [class.dtor]
diagnosable rules, [intro.compliance]
diagnostic message, see message, diagnostic
digraph, see token, alternative, [lex.digraph]
directed acyclic graph, see DAG
directive, preprocessing, see preprocessing directives
discard
random number engine requirement, [rand.req.eng]
discard_block_engine
generation algorithm, [rand.adapt.disc]
textual representation, [rand.adapt.disc]
transition algorithm, [rand.adapt.disc]
discarded-value expression, [expr]
discrete probability function
bernoulli_distribution, [rand.dist.bern.bernoulli]
binomial_distribution, [rand.dist.bern.bin]
discrete_distribution, [rand.dist.samp.discrete]
geometric_distribution, [rand.dist.bern.geo]
negative_binomial_distribution, [rand.dist.bern.negbin]
poisson_distribution, [rand.dist.pois.poisson]
uniform_int_distribution, [rand.dist.uni.int]
discrete_distribution
discrete probability function, [rand.dist.samp.discrete]
distribution, see random number distribution
dominance
virtual base class, [class.member.lookup]
dot operator, see operator, class member access
dynamic binding, see virtual function
dynamic initialization, [basic.start.init]
dynamic type, see type, dynamic
dynamic_cast, see cast, dynamic
ECMA-262, [intro.refs]
ECMAScript, [re.synopt], [re.grammar]
egrep, [re.synopt]
elaborated type specifier, see class name, elaborated
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]
EmplaceConstructible into X from args, [container.requirements.general]
empty future object, [futures.unique_future]
empty shared_future object, [futures.shared_future]
encoding
multibyte, [lex.string]
end
unordered associative containers, [unord.req]
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], [basic]
enum, [basic.compound]
overloading and, [over.load]
type of, [dcl.enum]
underlying type, [dcl.enum]
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
epoch, [time.clock.req]
equal_range
unordered associative containers, [unord.req]
equivalence
template type, [temp.type]
equivalent-key group, [unord.req]
equivalent parameter declarations, [over.load]
overloading and, [over.load]
erase
unordered associative containers, [unord.req]
escape character, see backslash
escape sequence
undefined, [lex.ccon]
evaluation, [intro.execution]
order of argument, [expr.call]
unspecified order of, [intro.execution], [basic.start.init]
unspecified order of argument, [expr.call]
unspecified order of function call, [expr.call]
example
class definition, [class.mem]
const, [dcl.ptr]
constant pointer, [dcl.ptr]
constructor, [class.ctor]
constructor and initialization, [class.expl.init]
declaration, [basic.def], [dcl.fct]
declarator, [dcl.name]
definition, [basic.def]
delete, [class.free]
derived class, [class.derived]
destructor and delete, [class.free]
ellipsis, [dcl.fct]
enumeration, [dcl.enum]
explicit destructor call, [class.dtor]
explicit qualification, [class.member.lookup]
friend, [class.name]
friend function, [class.friend]
function declaration, [dcl.fct]
function definition, [dcl.fct.def.general]
linkage consistency, [dcl.stc]
local class, [class.local]
nested type name, [class.nested.type]
nested class, [class.nest]
nested class definition, [class.nest], [class.access.nest]
nested class forward declaration, [class.nest]
pointer to member, [dcl.mptr]
pure virtual function, [class.abstract]
scope of delete, [class.free]
scope resolution operator, [class.member.lookup]
static member, [class.static.data]
subscripting, [dcl.array]
type name, [dcl.name]
typedef, [dcl.typedef]
unnamed parameter, [dcl.fct.def.general]
variable parameter list, [dcl.fct]
virtual function, [class.virtual]
exception
arithmetic, [expr]
undefined arithmetic, [expr]
<exception>, [support.exception]
exception handling, [except]
allowing an exception, [except.spec]
constructors and destructors, [except.ctor]
exception object, [except.throw]
constructor, [except.throw]
destructor, [except.throw]
function try block, [except]
goto, [except]
handler, [except], [except.throw], [except.handle], [res.on.exception.handling]
array in, [except.handle]
incomplete type in, [except.handle]
pointer to function in, [except.handle]
rvalue reference in, [except.handle]
nearest handler, [except.throw]
rethrowing, [except.throw]
switch, [except]
terminate() called, [except.throw], [except.spec]
throwing, [except.throw]
try block, [except]
unexpected() called, [except.spec]
exception object, see exception handling, exception object
exception specification, [except.spec]
compatible, [except.spec]
incomplete type and, [except.spec]
noexcept
constant expression and, [except.spec]
virtual function and, [except.spec]
exception::what message
implementation-defined, [exception]
execution agent, [thread.req.lockable.general]
exit, [basic.start.main], [basic.start.term], [stmt.jump]
explicit-specialization, [temp.expl.spec]
explicit type conversion, see casting
explicitly captured, [expr.prim.lambda]
exponential_distribution
probability density function, [rand.dist.pois.exp]
expression, [expr]
additive operators, [expr.add]
assignment and compound assignment, [expr.ass]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
conditional operator, [expr.cond]
const cast, [expr.const.cast]
constant, [expr.const]
dynamic cast, [expr.dynamic.cast]
equality operators, [expr.eq]
function call, [expr.call]
left-shift-operator, [expr.shift]
logical AND, [expr.log.and]
logical OR, [expr.log.or]
multiplicative operators, [expr.mul]
order of evaluation of, [intro.execution]
parenthesized, [expr.prim.general]
pointer-to-member, [expr.mptr.oper]
pointer to member constant, [expr.unary.op]
postfix, [expr.post]
primary, [expr.prim]
pseudo-destructor call, [expr.pseudo]
reference, [expr]
reinterpret cast, [expr.reinterpret.cast]
relational operators, [expr.rel]
right-shift-operator, [expr.shift]
rvalue reference, [expr]
static cast, [expr.static.cast]
type identification, [expr.typeid]
unary operator, [expr.unary.op]
extended alignment, [basic.align]
extended integer type, [basic.fundamental]
extended signed integer type, [basic.fundamental]
extended unsigned integer type, [basic.fundamental]
extern, [dcl.stc]
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]
file, source, see source file
final overrider, [class.virtual]
find
unordered associative containers, [unord.req]
finite state machine, [defns.regex.collating.element]
fisher_f_distribution
probability density function, [rand.dist.norm.f]
floating literal, see literal, floating
floating-point literal, see literal, floating
floating point type, [basic.fundamental]
implementation-defined, [basic.fundamental]
for
scope of declaration in, [stmt.for]
formal argument, see parameter
format specifier, [defns.regex.finite.state.machine]
forwarding call wrapper, [func.require]
free store, [class.free]
free store, see also new, delete
freestanding implementation, [intro.compliance]
friend
access specifier and, [class.friend]
class access and, [class.friend]
inheritance and, [class.friend]
local class and, [class.friend]
template and, [temp.friend]
virtual and, [class.virtual]
friend function
access and, [class.friend]
linkage of, [class.friend]
member function and, [class.friend]
friend function
nested class, [class.nest]
full-expression, [intro.execution], [intro.execution]
function, see also friend function; member function; inline function; virtual function, [dcl.fct]
comparison, [defns.comparison]
conversion, [class.conv.fct]
definition, [basic.def]
linkage specification overloaded, [dcl.link]
operator, [over.oper]
overload resolution and, [over.match.funcs]
pointer to member, [expr.mptr.oper]
replacement, [defns.replacement]
viable, [over.match]
function invocation substitution, [dcl.constexpr]
function object, [function.objects]
binders, [func.bind]
mem_fn, [func.memfn]
reference_wrapper, [refwrap]
wrapper, [func.wrap]
function pointer type, [basic.compound]
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
function argument, see argument
function call, [expr.call]
recursive, [expr.call]
function call operator
overloaded, [over.call]
function parameter, see parameter
function prototype, [basic.scope.proto]
function return, see return
function return type, see return type
functions
fundamental alignment, [basic.align]
fundamental type
destructor and, [class.dtor]
fundamental type conversion, see conversion, user-defined
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]
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]
handler, see exception handling, handler
happens before, [intro.multithread]
hash
instantiation restrictions, [unord.hash]
hash code, [unord.req]
hash function, [unord.req]
hash tables, see unordered associative containers
hash_function
unordered associative containers, [unord.req]
hasher
unordered associative containers, [unord.req]
hiding, see name hiding
high-order bit, [intro.memory]
hosted implementation, [intro.compliance]
id
id-expression, [expr.prim.general]
identifier, [lex.name], [expr.prim.general], [dcl.dcl]
ill-formed program, see program, ill-formed
immolation
implementation
freestanding, [compliance]
hosted, [compliance]
implementation limits, see limits, implementation
implementation-defined, [alt.headers], [support.types], [support.start.term], [bad.alloc], [bad.cast], [bad.typeid], [exception], [bad.exception], [locale.members], [ios.members.static], [stringbuf.virtuals], [diff.null]
implementation-defined behavior, see behavior, implementation-defined
implementation-dependent, [istream::sentry]
implementation-generated, [basic.def]
implicit object parameter, [over.match.funcs]
implicit conversion, see conversion, implicit
implicitly captured, [expr.prim.lambda]
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
incomplete, [expr.add]
increment
increment operator
independent_bits_engine
generation algorithm, [rand.adapt.ibits]
textual representation, [rand.adapt.ibits]
transition algorithm, [rand.adapt.ibits]
indeterminately sequenced, [intro.execution]
indirection, [expr.unary.op]
inheritance, [class.derived]
initialization, [basic.start.init], [dcl.init]
aggregate, [dcl.init.aggr]
array of class objects, [dcl.init.aggr], [class.expl.init]
automatic, [stmt.dcl]
automatic object, [dcl.init]
base class, [class.base.init]
character array, [dcl.init.string]
character array, [dcl.init.string]
class member, [dcl.init]
class object, see also constructor, [dcl.init.aggr], [class.init]
const member, [class.base.init]
default, [dcl.init]
default constructor and, [class.init]
definition and, [dcl.dcl]
direct, [dcl.init]
jump past, [stmt.dcl]
list-initialization, [dcl.init.list]
local static, [stmt.dcl]
member function call during, [class.base.init]
member object, [class.base.init]
order of base class, [class.base.init]
order of member, [class.base.init]
order of virtual base class, [class.base.init]
overloaded assignment and, [class.expl.init]
parameter, [expr.call]
reference member, [class.base.init]
static and thread, [basic.start.init]
static member, [class.static.data]
virtual base class, [class.copy]
initializer
pack expansion, [class.base.init]
scope of member, [class.base.init]
temporary and declarator, [class.temporary]
initializer-list constructor
seed sequence requirement, [rand.req.seedseq]
<initializer_list>, [support.initlist]
injected-class-name, [class]
inline, [res.on.macro.definitions]
inline
linkage of, [basic.link]
inline function, [dcl.fct.spec]
insert
unordered associative containers, [unord.req]
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]
sizeof, [basic.fundamental]
inter-thread happens before, [intro.multithread]
internal linkage, [basic.link]
interval boundaries
piecewise_constant_distribution, [rand.dist.samp.pconst]
piecewise_linear_distribution, [rand.dist.samp.plinear]
invocation
isctype
regular expression traits, [re.req]
iteration-statement, [stmt.break], [stmt.cont]
Jessie, [class.conv.ctor]
key_eq
unordered associative containers, [unord.req]
key_equal
unordered associative containers, [unord.req]
key_type
unordered associative containers, [unord.req]
keyword, [lex.key], [gram.key]
label, [stmt.goto]
lambda-introducer, [dcl.type.simple]
lattice, see DAG, subobject
layout
bit-field, [class.bit]
class object, [class.mem], [class.mi]
layout-compatible type, [dcl.enum]
layout-compatible type, [basic.types]
left shift
undefined, [expr.shift]
left shift operator, [expr.shift]
lexical conventions, see conventions, lexical
library
library clauses, [intro.structure]
lifetime, [basic.life]
limits
implementation, [defns.impl.defined]
<limits>, [limits.numeric]
line splicing, [lex.phases]
linear_congruential_engine
generation algorithm, [rand.eng.lcong]
textual representation, [rand.eng.lcong]
transition algorithm, [rand.eng.lcong]
linkage, [basic], [basic.link], [basic.link]
const and, [basic.link]
implementation-defined object, [dcl.link]
inline and, [basic.link]
internal, [basic.link]
static and, [basic.link]
linkage specification, see specification, linkage
linkage-specification, [dcl.link]
literal, [lex.literal], [expr.prim.general]
base of integer, [lex.icon]
boolean, [lex.bool]
char16_t, [lex.ccon]
char32_t, [lex.ccon]
character, [lex.ccon]
decimal, [lex.icon]
double, [lex.fcon]
float, [lex.fcon]
floating, [lex.fcon]
hexadecimal, [lex.icon]
integer, [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]
implementation-defined, [lex.string]
narrow, [lex.string]
type of, [lex.string]
undefined change to, [lex.string]
type of character, [lex.ccon]
type of floating point, [lex.fcon]
type of integer, [lex.icon]
unsigned, [lex.icon]
user defined, [lex.ext]
literal type, [basic.types]
load_factor
unordered associative containers, [unord.req]
local lambda expression, [expr.prim.lambda]
local variable, [basic.scope.local]
local_iterator, [unord.req]
unordered associative containers, [unord.req]
local class
member function in, [class.mfct]
scope of, [class.local]
local scope, see block scope
local variable
destruction of, [stmt.jump], [stmt.dcl]
locale, [re.def], [defns.regex.matched], [re.req], [re.synopt]
locale-specific behavior, see behavior, locale-specific
lognormal_distribution
probability density function, [rand.dist.norm.lognormal]
long
typedef and, [dcl.spec]
lookup
argument-dependent, [basic.lookup.argdep]
class member, [class.qual]
elaborated type specifier, [basic.lookup.elab]
namespace aliases and, [basic.lookup.udir]
namespace member, [namespace.qual]
qualified name, [basic.lookup.qual]
template name, [temp.res]
unqualified name, [basic.lookup.unqual]
using-directives and, [basic.lookup.udir]
lookup_classname
regular expression traits, [re.req], [re.grammar]
lookup_collatename
regular expression traits, [re.req]
low-order bit, [intro.memory]
lowercase, [character.seq]
lvalue, [basic.lval], [diff.expr]
lvalue reference, [basic.compound], [dcl.ref]
macro
argument substitution, [cpp.subst]
function-like, [cpp.replace]
arguments, [cpp.replace]
object-like, [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(), [basic.start.main]
implementation-defined linkage of, [basic.start.main]
implementation-defined parameters to, [basic.start.main]
parameters to, [basic.start.main]
match_results
as sequence, [re.results]
matched, [defns.regex.format.specifier]
max
random number distribution requirement, [rand.req.dist]
uniform random number generator requirement, [rand.req.urng]
max_bucket_count
unordered associative containers, [unord.req]
max_load_factor
unordered associative containers, [unord.req]
mean
normal_distribution, [rand.dist.norm.normal]
poisson_distribution, [rand.dist.pois.poisson]
member
class static, [basic.stc.static]
enumerator, [dcl.enum]
template and static, [temp.static]
member access operator
overloaded, [over.ref]
member function
call undefined, [class.mfct.non-static]
constructor and, [class.ctor]
destructor and, [class.dtor]
inline, [class.mfct]
local class, [class.local]
nested class, [class.access.nest]
overload resolution and, [over.match.funcs]
volatile, [class.this]
member names, [basic.scope.namespace]
member subobject, [intro.object]
member data
member pointer to, see pointer to member
members, [basic.scope.namespace]
memory location, [intro.memory]
memory model, [intro.memory]
memory management, see also new, delete
mersenne_twister_engine
generation algorithm, [rand.eng.mers]
textual representation, [rand.eng.mers]
transition algorithm, [rand.eng.mers]
message
min
random number distribution requirement, [rand.req.dist]
uniform random number generator requirement, [rand.req.urng]
modification order, [intro.multithread]
most derived class, [intro.object]
most derived object, [intro.object]
bit-field, [intro.object]
zero size subobject, [intro.object]
move
MoveInsertable into X, [container.requirements.general]
multi-pass guarantee, [forward.iterators]
multibyte character, see character, multibyte
multicharacter literal, see literal, multicharacter
multiple threads, see threads, multiple
multiple inheritance, [class.derived], [class.mi]
virtual and, [class.virtual]
mutable, [dcl.stc]
mutable iterator, [iterator.requirements.general]
mutex types, [thread.mutex.requirements.mutex]
name, [lex.name], [basic], [basic], [expr.prim.general]
address of cv-qualified, [expr.unary.op]
elaborated
length of, [lex.name]
macro, see macro, name
point of declaration, [basic.scope.pdecl]
predefined macro, see macro, predefined
name hiding
function, [over.dcl]
overloading versus, [over.dcl]
using-declaration and, [namespace.udecl]
name class, see class name
name hiding, [basic.scope.pdecl], [basic.scope.hiding], [expr.prim.general], [stmt.dcl]
class definition, [class.name]
user-defined conversion and, [class.conv]
name space
namespace, [contents], [depr.c.headers]
definition, [namespace.def]
member definition, [namespace.memdef]
namespaces, [basic.namespace]
narrowing conversion, [dcl.init.list]
NDEBUG, [using.headers]
negative_binomial_distribution
discrete probability function, [rand.dist.bern.negbin]
nested class
local class, [class.local]
scope of, [class.nest]
<new>, [support.dynamic]
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]
scoping and, [expr.new]
storage allocation, [expr.new]
type of, [class.free]
unspecified constructor and, [expr.new]
unspecified order of evaluation, [expr.new]
new_handler, [basic.stc.dynamic.allocation]
no linkage, [basic.link]
non-throwing, [except.spec]
normal distributions, [rand.dist.norm]
normal_distribution
probability density function, [rand.dist.norm.normal]
standard deviation, [rand.dist.norm.normal]
normative references, see references, normative
notation
syntax, [syntax]
notify_all_at_thread_exit, [thread.condition]
NTBS, [byte.strings], [multibyte.strings], [filebuf.members], [depr.istrstream.cons], [depr.ostrstream.cons]
NTCTS, [defns.ntcts]
NTMBS, [multibyte.strings]
number
octal, [lex.ccon]
preprocessing, [lex.ppnumber]
numeric_limits, [basic.fundamental], [limits.numeric]
object, see also object model, [intro.object], [intro.object], [basic]
byte copying and, [basic.types]
complete, [intro.object]
definition, [basic.def]
destructor static, [basic.start.term]
destructor and placement of, [class.dtor]
linkage specification, [dcl.link]
local static, [basic.stc.static]
unnamed, [class.ctor]
object expression, [expr.ref]
object model, [intro.object]
object pointer type, [basic.compound]
object representation, [basic.types]
object type, [intro.object], [basic.types]
object, exception, see exception handling, exception object
object-like macro, see macro, object-like
object class, see also class object
object lifetime, [basic.life]
object temporary, see temporary
object type, [basic.types]
observable behavior, see behavior, observable
odr-used, [basic.def.odr]
one-definition rule, [basic.def]
operation
operator, [lex.operators], [over.oper]
additive, [expr.add]
address-of, [expr.unary]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
conditional expression, [expr.cond]
copy assignment, see assignment, copy
division, [expr.mul]
equality, [expr.eq]
function call, [expr.call], [over.oper]
greater than, [expr.rel]
greater than or equal to, [expr.rel]
indirection, [expr.unary]
inequality, [expr.eq]
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, move
multiplication, [expr.mul]
multiplicative, [expr.mul]
one's complement, [expr.unary], [expr.unary.op]
overloaded, [expr], [over.oper]
pointer to member, [expr.mptr.oper]
precedence of, [intro.execution]
relational, [expr.rel]
remainder, [expr.mul]
side effects and comma, [expr.comma]
side effects and logical AND, [expr.log.and]
side effects and logical OR, [expr.log.or]
subscripting, [expr.sub], [over.oper]
operator delete, see also delete, [expr.new], [expr.delete], [class.free]
operator new, see also new, [expr.new]
operator overloading, see overloading, operator
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 number 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]
operator , see delete
operator left shift, see left shift operator
operator right shift, see right shift operator
operator use
scope resolution, [class.static.data]
optimization of temporary, see elimination of temporary
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, [temp.func.order]
over-aligned type, [basic.align]
overflow, [expr]
undefined, [expr]
overloaded function, see overloading
overloaded operator, see overloading, operator
overloaded function
address of, [expr.unary.op]
overloaded operator
inheritance of, [over.oper]
overloadedfunction
address of, [over.over]
overloading, [dcl.fct], [class.name], [over], [temp.over.link]
access control and, [over.dcl]
address of overloaded function, [over.over]
argument lists, [over.match.funcs]
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]
member access operator, [over.ref]
operator, [over.oper]
prohibited, [over.load]
resolution, [over.match]
best viable function, [over.match.best]
contexts, [over.match]
function call syntax, [over.match.call]
function template, [temp.over]
implicit conversions and, [over.best.ics]
scoping ambiguity, [class.member.lookup]
template name, [temp.res]
viable functions, [over.match.viable]
subscripting operator, [over.sub]
unary operator, [over.unary]
user-defined literal, [over.literal]
using directive and, [namespace.udir]
using-declaration and, [namespace.udecl]
overloads
floating point, [cmplx.over]
overrider
own, [unique.ptr]
pair
tuple interface to, [pairs.general]
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.multibyte], [defns.parameter], [defns.parameter.macro]
catch clause, [defns.multibyte]
function-like macro, [defns.parameter]
reference, [dcl.ref]
void, [dcl.fct]
parameter declaration, [basic.def]
parameter list
parameterized type, see template
parameters
period, [character.seq]
phases of translation, see translation, phases
piecewise construction, [pairs.pair]
piecewise_constant_distribution
interval boundaries, [rand.dist.samp.pconst]
probability density function, [rand.dist.samp.pconst]
piecewise_linear_distribution
interval boundaries, [rand.dist.samp.plinear]
probability density function, [rand.dist.samp.plinear]
weights at boundaries, [rand.dist.samp.plinear]
placement syntax
POD class, [class]
POD struct, [class]
POD union, [class]
POF, [support.runtime]
point of declaration, [basic.scope.pdecl]
pointer, see also void*
to traceable object, [res.on.pointer.storage]
to traceable object, [basic.stc.dynamic.safety]
pointer literal, see literal, pointer
pointer, integer representation of safely-derived, [basic.stc.dynamic.safety]
pointer to member, [basic.compound], [expr.mptr.oper]
Poisson distributions, [rand.dist.pois]
poisson_distribution
discrete probability function, [rand.dist.pois.poisson]
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 scope, [basic.scope.declarative]
potentially evaluated, [basic.def.odr]
precedence of operator, see operator, precedence of
prefix
prefix ++, [expr.pre.incr]
prefix ++ and --
overloading, [over.inc]
prefix --, [expr.pre.incr]
preprocessing directive, [cpp]
conditional inclusion, [cpp.cond]
preprocessing directives, [cpp]
header inclusion, [cpp.include]
line control, [cpp.line]
macro replacement, see macro, replacement
pragma, [cpp.pragma]
source-file inclusion, [cpp.include]
primary 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]
termination, [basic.start.term]
program execution, [intro.execution]
abstract machine, [intro.execution]
as-if rule, see as-if rule
promotion
bool to int, [conv.prom]
floating point, [conv.fpprom]
integral, [conv.prom]
protected, see access control, protected
protection, see access control, [protection.within.classes]
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
random number distribution
bernoulli_distribution, [rand.dist.bern.bernoulli]
binomial_distribution, [rand.dist.bern.bin]
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]
random number distributions
Bernoulli, [rand.dist.bern]
random number engine
linear_congruential_engine, [rand.eng.lcong]
mersenne_twister_engine, [rand.eng.mers]
requirements, [rand.req.eng]
subtract_with_carry_engine, [rand.eng.sub]
with predefined parameters, [rand.predef]
random number engine adaptor
discard_block_engine, [rand.adapt.disc]
independent_bits_engine, [rand.adapt.ibits]
shuffle_order_engine, [rand.adapt.shuf]
with predefined parameters, [rand.predef]
random number generation, [rand]
distributions, [rand.dist]
engines, [rand.eng]
predefined engines and adaptors, [rand.predef]
requirements, [rand.req]
synopsis, [rand.synopsis]
utilities, [rand.util]
random number generator, see uniform random number generator
random_device
implementation leeway, [rand.device]
raw string literal, [lex.string]
reaching scope, [expr.prim.lambda]
ready, [re.results], [futures.state]
redefinition
typedef, [dcl.typedef]
reference, [basic.compound]
assignment to, [expr.ass]
call by, [expr.call]
null, [dcl.ref]
reference collapsing, [dcl.ref]
reference-compatible, [dcl.init.ref]
references
normative, [intro.refs]
regex_iterator
end-of-sequence, [re.regiter]
regex_token_iterator
end-of-sequence, [re.tokiter]
regex_traits
specializations, [re.traits]
region
register, [dcl.stc]
regular expression, [re]
grammar, [re.grammar]
requirements, [re.req]
regular expression traits, [re.grammar]
char_class_type, [re.req]
isctype, [re.req]
lookup_classname, [re.req], [re.grammar]
lookup_collatename, [re.req]
requirements, [re.req], [re.traits]
transform_primary, [re.req], [re.grammar]
translate_nocase, [re.req], [re.grammar]
rehash
unordered associative containers, [unord.req]
reinterpret_cast, see cast, reinterpret
relaxed pointer safety, [basic.stc.dynamic.safety]
release sequence, [intro.multithread]
remainder operator, see remainder operator
replacement
representation
requirements, [structure.requirements]
container, [container.requirements], [unord.req], [array.overview], [array.cons], [re.results]
not required for unordered associated containers, [unord.req]
CopyConstructible, [utility.arg.requirements]
DefaultConstructible, [utility.arg.requirements]
EqualityComparable, [utility.arg.requirements]
LessThanComparable, [utility.arg.requirements]
MoveConstructible, [utility.arg.requirements]
random number distribution, [rand.req.dist]
random number engine, [rand.req.eng]
regular expression traits, [re.req], [re.traits]
seed sequence, [rand.req.seedseq]
sequence, [re.results]
uniform random number generator, [rand.req.urng]
unordered associative container, [unord.req]
reraise, see exception handling, rethrow
rescanning and replacement, see macro, rescanning and replacement
reserved identifier, [lex.name]
reset, [unique.ptr]
reset
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]
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]
register, [dcl.stc]
static, [dcl.stc]
static member local class, [class.static.data]
result_type
entity characterization based on, [rand]
random number distribution requirement, [rand.req.dist]
seed sequence requirement, [rand.req.seedseq]
uniform random number 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]
overloading and, [over.load]
right shift
implementation defined, [expr.shift]
right shift operator, [expr.shift]
rounding, [conv.fpint]
rvalue, [basic.lval]
lvalue conversion to, see conversion, lvalue to rvalue
lvalue conversion to, [diff.expr]
rvalue reference, [basic.compound], [dcl.ref]
safely-derived pointer, [basic.stc.dynamic.safety]
integer representation, [basic.stc.dynamic.safety]
sampling distributions, [rand.dist.samp]
scalar type, [basic.types]
scope, [intro.scope], [basic], [basic.scope], [basic.scope.declarative], [dcl.dcl]
anonymous union at namespace, [class.union]
declarations and, [basic.scope.declarative]
destructor and exit from, [stmt.jump]
enumeration, [basic.scope.enum]
exception declaration, [basic.scope.local]
function prototype, [basic.scope.proto]
global namespace, [basic.scope.namespace]
iteration-statement, [stmt.iter]
macro definition, see macro, scope of definition
name lookup and, [basic.lookup]
overloading and, [over.dcl]
selection-statement, [stmt.select]
template parameter, [basic.scope.temp]
scope name hiding and, [basic.scope.hiding]
scope resolution operator, [basic.lookup.qual]
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]
standard conversion, [conv]
sequence constructor
seed sequence requirement, [rand.req.seedseq]
Sequenced before, [intro.execution]
sequencing operator, see comma operator
setlocale, [character.seq]
shared state, see future, shared state
shift operator, see left shift operator, right shift operator
short
typedef and, [dcl.spec]
shuffle_order_engine
generation algorithm, [rand.adapt.shuf]
textual representation, [rand.adapt.shuf]
transition algorithm, [rand.adapt.shuf]
side effects, [intro.execution], [intro.multithread], [intro.execution], [expr.log.and], [expr.log.or], [stmt.expr], [class.temporary], [class.base.init], [class.copy], [cpp.scope], [res.on.data.races]
visible sequence of, [intro.multithread]
signal, [intro.execution]
signature, [defns.parameter.templ], [defns.signature], [defns.signature.templ], [defns.signature.spec], [defns.signature.member], [defns.signature.member.templ]
signed
typedef and, [dcl.spec]
signed integer type, [basic.fundamental]
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], [lex.phases], [using.headers], [alt.headers]
source file character, see character, source file
space
special member function, see constructor, destructor, inline function, user-defined conversion, virtual function
specialization
class template, [temp.names]
class template partial, [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]
implementation-defined exception, [res.on.exception.handling]
specifier, [dcl.spec]
cv-qualifier, [dcl.type.cv]
declaration, [dcl.spec]
explicit, [dcl.fct.spec]
friend, [dcl.friend]
function, [dcl.fct.spec]
missing storage class, [dcl.stc]
static, [dcl.stc]
storage class, [dcl.stc]
type, see type specifier
typedef, [dcl.typedef]
specifier access, see access specifier
stable algorithm, [defns.stable], [algorithm.stable]
stack unwinding
see exception handling, constructors and destructors, [except.ctor]
standard
structure of, [intro.structure]
standard deviation
normal_distribution, [rand.dist.norm.normal]
standard-layout types, [basic.types]
standard-layout class, [class]
standard-layout struct, [class]
standard-layout union, [class]
standard integer type, [basic.fundamental]
standard signed integer type, [basic.fundamental]
standard unsigned integer type, [basic.fundamental]
start
startup
state
discard_block_engine, [rand.adapt.disc]
independent_bits_engine, [rand.adapt.ibits]
linear_congruential_engine, [rand.eng.lcong]
mersenne_twister_engine, [rand.eng.mers]
shuffle_order_engine, [rand.adapt.shuf]
subtract_with_carry_engine, [rand.eng.sub]
statement, [stmt.stmt]
compound, [stmt.block]
continue in for, [stmt.for]
declaration, [stmt.dcl]
declaration in if, [stmt.select]
declaration in switch, [stmt.select]
declaration in for, [stmt.for]
declaration in switch, [stmt.switch]
declaration in while, [stmt.while]
expression, [stmt.expr]
iteration, [stmt.iter]
labeled, [stmt.label]
selection, [stmt.select]
static, [dcl.stc]
destruction of local, [stmt.dcl]
linkage of, [basic.link], [dcl.stc]
overloading and, [over.load]
static initialization, [basic.start.init]
static storage duration, [basic.stc.static]
static type, see type, static
static_assert, [dcl.dcl]
static_cast, see cast, static
<stddef.h>, [lex.ccon], [lex.string]
<stdexcept>, [std.exceptions]
storage class, [basic]
storage duration, [basic.stc]
class member, [basic.stc.inherit]
local object, [basic.stc.auto]
storage management, see new, delete
stream
arbitrary-positional, [defns.arbitrary.stream]
streambuf
implementation-defined, [iostreams.limits.pos]
strict pointer safety, [basic.stc.dynamic.safety]
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
stringize, see #
struct
standard-layout, [class]
struct
class versus, [class]
structure, [class]
structure tag, see class name
student_t_distribution
probability density function, [rand.dist.norm.t]
sub-expression, [defns.regex.regular.expression]
subobject, see also object model, [intro.object], [intro.object]
subscripting operator
overloaded, [over.sub]
subsequence rule
overloading, [over.ics.rank]
subtract_with_carry_engine
generation algorithm, [rand.eng.sub]
textual representation, [rand.eng.sub]
transition algorithm, [rand.eng.sub]
subtraction
implementation defined pointer, [expr.add]
subtraction operator, [expr.add]
suffix
summary
compatibility with ISO C, [diff.iso]
compatibility with ISO C++ 2003, [diff.cpp03]
syntax, [gram]
swappable, [swappable.requirements]
swappable with, [swappable.requirements]
switch
and handler, [except]
and try block, [except]
synchronize with, [intro.multithread]
synonym, [namespace.alias]
type name as, [dcl.typedef]
syntax
class member, [expr.ref]
target object, [func.def], [func.require]
template, [temp]
definition of, [temp]
function, [temp.fct.spec]
member function, [temp.mem.func]
template, [temp]
template parameter, [basic.def]
template name
linkage of, [temp]
template parameter scope, [basic.scope.temp]
temporary, [class.temporary]
constructor for, [class.temporary]
destruction of, [class.temporary]
destructor for, [class.temporary]
implementation-defined generation of, [class.temporary]
order of destruction of, [class.temporary]
terminate(), [except.terminate]
termination
terminology
textual representation
discard_block_engine, [rand.adapt.disc]
independent_bits_engine, [rand.adapt.ibits]
shuffle_order_engine, [rand.adapt.shuf]
subtract_with_carry_engine, [rand.eng.sub]
this, [expr.prim.general], [class.this]
type of, [class.this]
this pointer, see this
thread, [intro.multithread]
thread of execution, [intro.multithread]
thread storage duration, [basic.stc.thread]
thread, blocked, [defns.blocked]
thread_local, [dcl.stc]
threads
throw, [except]
throwing, see exception handling, throwing
timed mutex types, [thread.timedmutex.requirements]
token, [lex.token]
alternative, [lex.digraph]
preprocessing, [lex.pptoken]
token, [lex.token]
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.grammar]
transform_primaryl
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]
translation units, [basic.link]
translation unit, [basic.link]
name and, [basic]
trigraph sequence, [lex.phases], [lex.trigraph]
trivial types, [basic.types]
trivial class, [class]
trivial class type, [expr.new]
trivial type, [expr.new]
trivially copyable class, [class]
trivially copyable types, [basic.types]
truncation, [conv.fpint]
try, [except]
try block, see exception handling, try block
tuple
and pair, [pairs.general]
type, [basic], [basic.types]
character container, [defns.character.container]
class and, [class]
const, [dcl.type]
destination, [dcl.init]
enumeration underlying, [dcl.enum]
example of incomplete, [basic.types]
extended integer, [basic.fundamental]
extended signed integer, [basic.fundamental]
extended unsigned integer, [basic.fundamental]
floating point, [basic.fundamental]
fundamental, [basic.fundamental]
sizeof, [basic.fundamental]
long double, [basic.fundamental]
multi-level mixed pointer and pointer to member, [conv.qual]
multi-level pointer to member, [conv.qual]
over-aligned, [basic.align]
polymorphic, [class.virtual]
signed char, [basic.fundamental]
signed integer, [basic.fundamental]
standard integer, [basic.fundamental]
standard signed integer, [basic.fundamental]
standard unsigned integer, [basic.fundamental]
trivially copyable, [basic.types]
underlying wchar_t, [basic.fundamental]
unsigned char, [basic.fundamental]
unsigned int, [basic.fundamental]
unsigned long, [basic.fundamental]
unsigned long long, [basic.fundamental]
unsigned short, [basic.fundamental]
unsigned integer, [basic.fundamental]
volatile, [dcl.type]
type generator, see template
type specifier
elaborated, [dcl.type.elab]
volatile, [dcl.type.cv]
type-name, [dcl.type.simple]
type-specifier
type_info, [expr.typeid]
type checking
argument, [expr.call]
type conversion, explicit, see casting
type name, [dcl.name]
type pun, [expr.reinterpret.cast]
type specifier
volatile, [dcl.type.cv]
typedef
function, [dcl.fct]
typedef
overloading and, [over.load]
typeid, [expr.typeid]
construction and, [class.cdtor]
destruction and, [class.cdtor]
<typeinfo>, [support.rtti]
typename, [dcl.type.elab]
types
implementation-defined, [type.descriptions.general]
implementation-defined exception, [res.on.exception.handling]
unary function, [refwrap]
unary operator
overloaded, [over.unary]
unary operator
interpretation of, [over.unary]
UnaryTypeTrait, [meta.rqmts]
unblock, [defns.unblock]
uncaught_exception(), [except.uncaught]
undefined, [defns.required.behavior], [defns.reserved.function], [reserved.names], [alt.headers], [res.on.arguments], [valarray.cons], [valarray.access], [valarray.cassign], [valarray.members], [valarray.binary], [valarray.comparison], [class.gslice.overview], [indirect.array.assign], [indirect.array.comp.assign], [fpos.operations]
undefined behavior, see behavior, undefined, [istreambuf.iterator]
underlying type, [basic.fundamental]
unevaluated operand, [expr]
unexpected(), [except.spec], [except.unexpected]
Unicode required set, [cpp.predefined]
uniform distributions, [rand.dist.uni]
uniform random number 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
standard-layout, [class]
union, [basic.compound], [class.union]
anonymous, [class.union]
class versus, [class]
global anonymous, [class.union]
unique pointer, [unique.ptr]
unit
universal character name, [lex.phases]
unordered associative containers, [associative.reqmts.except], [unord.req]
bucket, [unord.req]
bucket_count, [unord.req]
bucket_size, [unord.req]
cbegin, [unord.req]
complexity, [unord.req]
const_local_iterator, [unord.req]
equal_range, [unord.req]
equality function, [unord.req]
exception safety, [unord.req.except]
hash function, [unord.req]
hash_function, [unord.req]
hasher, [unord.req]
insert, [unord.req]
iterator invalidation, [unord.req]
iterators, [unord.req]
key_eq, [unord.req]
key_equal, [unord.req]
key_type, [unord.req]
lack of comparison operators, [unord.req]
load_factor, [unord.req]
local_iterator, [unord.req]
max_bucket_count, [unord.req]
max_load_factor, [unord.req]
rehash, [unord.req]
unordered_map
element access, [unord.map.elem]
unordered_multimap
equivalent keys, [unord.multimap.overview]
unordered_multiset
equivalent keys, [unord.multiset.overview]
unordered_set
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, [valarray.members]
unwinding
uppercase, [character.seq], [global.names]
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
valid, [basic.scope.declarative]
valid but unspecified state, [defns.valid]
value, [basic.types]
call by, [expr.call]
null member pointer, [conv.mem]
null pointer, [conv.ptr]
undefined unrepresentable integral, [conv.fpint]
value category, [basic.lval]
value computation, [intro.execution], [intro.multithread], [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]
ValueSwappable, [swappable.requirements]
variable, [basic]
indeterminate uninitialized, [dcl.init]
virtual base class, [class.mi]
virtual function, [class.virtual]
virtual function call, [class.virtual]
constructor and, [class.cdtor]
destructor and, [class.cdtor]
undefined pure, [class.abstract]
visibility, [basic.scope.hiding]
visible, [basic.scope.hiding]
void&, [dcl.ref]
void*
volatile, [basic.type.qualifier]
constructor and, [class.this], [class.ctor]
destructor and, [class.this], [class.dtor]
implementation-defined, [dcl.type.cv]
overloading and, [over.load]
waiting function, [futures.state]
wchar_t, [lex.ccon], [lex.string], [c.strings]
implementation-defined, [basic.fundamental]
weak result type, [func.require]
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-character, [lex.ccon]
X(X&), see copy constructor
xvalue, [basic.lval]
zero
division by undefined, [expr]
remainder undefined, [expr]
undefined division by, [expr.mul]
zero-initialization, [dcl.init]