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]

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]

conditions

rules for, [stmt.stmt]

<condition_variable>, [condition_variable.syn]

conditional-expression

throw-expression in, [expr.cond]

conditionally-supported behavior, see behavior, conditionally-supported

conflict, [intro.races]

conformance requirements, [intro.compliance], [intro.execution]

class templates, [intro.compliance]

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]

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]

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

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]

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_{n}^{m}

(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_{n}^{m}

, [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]

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]

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]