Index

Symbols Numbers

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Symbols

!, see operator, logical negation
!=, see operator, inequality
# operator, [cpp.replace.general], [cpp.stringize]
## operator, [cpp.concat]
#define, [cpp.replace.general]
#elif, [cpp.cond]
#elifdef, [cpp.cond]
#elifndef, [cpp.cond]
#else, [cpp.cond]
#embed, [cpp.embed]
#endif, [cpp.cond]
#error, see preprocessing directive, error
#if, [cpp.cond], [res.on.macro.definitions]
#ifdef, [cpp.cond]
#ifndef, [cpp.cond]
#include, [cpp.include], [using.headers]
#line, see preprocessing directive, line control
#pragma, see preprocessing directive, 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, less than
template and, [temp.param], [temp.names]
_, see character, underscore
__cplusplus, [cpp.predefined]
__cpp_aggregate_bases, [cpp.predefined]
__cpp_aggregate_nsdmi, [cpp.predefined]
__cpp_aggregate_paren_init, [cpp.predefined]
__cpp_alias_templates, [cpp.predefined]
__cpp_aligned_new, [cpp.predefined]
__cpp_attributes, [cpp.predefined]
__cpp_auto_cast, [cpp.predefined]
__cpp_binary_literals, [cpp.predefined]
__cpp_capture_star_this, [cpp.predefined]
__cpp_char8_t, [cpp.predefined]
__cpp_concepts, [cpp.predefined]
__cpp_conditional_explicit, [cpp.predefined]
__cpp_consteval, [cpp.predefined]
__cpp_constexpr, [cpp.predefined]
__cpp_constexpr_dynamic_alloc, [cpp.predefined]
__cpp_constexpr_exceptions, [cpp.predefined]
__cpp_constexpr_in_decltype, [cpp.predefined]
__cpp_constexpr_virtual_inheritance, [cpp.predefined]
__cpp_constinit, [cpp.predefined]
__cpp_contracts, [cpp.predefined]
__cpp_decltype, [cpp.predefined]
__cpp_decltype_auto, [cpp.predefined]
__cpp_deduction_guides, [cpp.predefined]
__cpp_delegating_constructors, [cpp.predefined]
__cpp_deleted_function, [cpp.predefined]
__cpp_designated_initializers, [cpp.predefined]
__cpp_enumerator_attributes, [cpp.predefined]
__cpp_expansion_statements, [cpp.predefined]
__cpp_explicit_this_parameter, [cpp.predefined]
__cpp_fold_expressions, [cpp.predefined]
__cpp_generic_lambdas, [cpp.predefined]
__cpp_guaranteed_copy_elision, [cpp.predefined]
__cpp_hex_float, [cpp.predefined]
__cpp_if_consteval, [cpp.predefined]
__cpp_if_constexpr, [cpp.predefined]
__cpp_impl_coroutine, [cpp.predefined]
__cpp_impl_destroying_delete, [cpp.predefined]
__cpp_impl_reflection, [cpp.predefined]
__cpp_impl_three_way_comparison, [cpp.predefined]
__cpp_implicit_move, [cpp.predefined]
__cpp_inheriting_constructors, [cpp.predefined]
__cpp_init_captures, [cpp.predefined]
__cpp_initializer_lists, [cpp.predefined]
__cpp_inline_variables, [cpp.predefined]
__cpp_lambdas, [cpp.predefined]
__cpp_modules, [cpp.predefined]
__cpp_multidimensional_subscript, [cpp.predefined]
__cpp_named_character_escapes, [cpp.predefined]
__cpp_namespace_attributes, [cpp.predefined]
__cpp_noexcept_function_type, [cpp.predefined]
__cpp_nontype_template_args, [cpp.predefined]
__cpp_nontype_template_parameter_auto, [cpp.predefined]
__cpp_nsdmi, [cpp.predefined]
__cpp_pack_indexing, [cpp.predefined]
__cpp_placeholder_variables, [cpp.predefined]
__cpp_pp_embed, [cpp.predefined]
__cpp_range_based_for, [cpp.predefined]
__cpp_raw_strings, [cpp.predefined]
__cpp_ref_qualifiers, [cpp.predefined]
__cpp_return_type_deduction, [cpp.predefined]
__cpp_rvalue_references, [cpp.predefined]
__cpp_size_t_suffix, [cpp.predefined]
__cpp_sized_deallocation, [cpp.predefined]
__cpp_static_assert, [cpp.predefined]
__cpp_static_call_operator, [cpp.predefined]
__cpp_structured_bindings, [cpp.predefined]
__cpp_template_parameters, [cpp.predefined]
__cpp_template_args, [cpp.predefined]
__cpp_threadsafe_static_init, [cpp.predefined]
__cpp_trivial_union, [cpp.predefined]
__cpp_unicode_characters, [cpp.predefined]
__cpp_unicode_literals, [cpp.predefined]
__cpp_user_defined_literals, [cpp.predefined]
__cpp_using_enum, [cpp.predefined]
__cpp_variable_templates, [cpp.predefined]
__cpp_variadic_friend, [cpp.predefined]
__cpp_variadic_templates, [cpp.predefined]
__cpp_variadic_using, [cpp.predefined]
__DATE__, [cpp.predefined]
__FILE__, [cpp.predefined]
__func__, [dcl.fct.def.general]
__has_cpp_attribute, [cpp.cond]
__has_embed, [cpp.cond]
__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_BFLOAT16_T__, [cpp.predefined]
__STDCPP_DEFAULT_NEW_ALIGNMENT__, [cpp.predefined]
__STDCPP_FLOAT128_T__, [cpp.predefined]
__STDCPP_FLOAT16_T__, [cpp.predefined]
__STDCPP_FLOAT32_T__, [cpp.predefined]
__STDCPP_FLOAT64_T__, [cpp.predefined]
__STDCPP_THREADS__, [cpp.predefined]
__TIME__, [cpp.predefined]
__VA_ARGS__, [cpp.replace.general], [cpp.subst]
__VA_OPT__, [cpp.replace.general], [cpp.subst]
{}
block statement, [stmt.block]
class declaration, [class.pre]
class definition, [class.pre]
enum declaration, [dcl.enum]
initializer list, [dcl.init.aggr]

Numbers

0
null character, see character, null
string terminator, [lex.string]

A

abbreviated
template function, see template, function, abbreviated
absolute path, see path, absolute
abstract class, see class, abstract
abstract-declarator, [dcl.name], [gram.dcl]
abstract-pack-declarator, [dcl.name], [gram.dcl]
access control, [class.access.general]
anonymous union, [class.union.anon]
base class member, [class.derived.general]
class member, [expr.ref]
default argument, [class.access.general]
friend function, [class.friend]
member function and, [special]
multiple access, [class.paths]
nested class, [class.access.nest]
using-declaration and, [namespace.udecl]
virtual function, [class.access.virt]
accessible range, see range, accessible
accessor policy, [mdspan.accessor.general]
active, see variable, active
union member, [class.union.general]
active block, see block, active
active macro definition, see macro, active
addition operator, see operator, addition
additive-expression, [expr.add], [gram.expr]
addressable function, see function, addressable
aggregate, [dcl.init.aggr], [dcl.init.aggr]
elements, [dcl.init.aggr]
aggregate deduction candidate, see candidate, aggregate deduction
aggregate initialization, [dcl.init.aggr]
algorithm
algorithm function object, [alg.func.obj]
alias
alias template, see template, alias
alias-declaration, [dcl.pre], [gram.dcl]
alignment, [basic.align]
extended, [basic.align]
fundamental, [basic.align]
new-extended, [basic.align]
stricter, [basic.align]
stronger, [basic.align]
alignment requirement
implementation-defined, [basic.align]
alignment-specifier, [dcl.attr.grammar], [gram.dcl]
allocated type, see type, allocated
allocation
alignment storage, [expr.new]
implementation-defined bit-field, [class.bit]
allocation function, [basic.stc.dynamic.general]
class-specific, [class.free]
allocator-aware container, see container, allocator-aware
alternate form
format string, [format.string.std]
alternative token, see token, alternative
ambiguity
base class member, [class.member.lookup]
class conversion, [class.member.lookup]
declaration type, [dcl.spec.general]
declaration versus cast, [dcl.ambig.res]
declaration versus expression, [stmt.ambig]
function declaration, [dcl.init.general]
member access, [class.member.lookup]
overloaded function, [over.match.general]
parentheses and, [expr.new]
ambiguous conversion sequence, see conversion sequence, ambiguous
Amendment 1, [extern.names]
and-expression, [expr.bit.and], [gram.expr]
annotation-list, [dcl.attr.grammar], [gram.dcl]
anonymous union, [class.union.anon]
appearance-ordered, [basic.start.dynamic]
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.general]
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.general]
reference, [expr.call]
scope of default, [dcl.fct.default]
template instantiation, [defns.argument.templ]
throw expression, [defns.argument.throw]
type checking of default, [dcl.fct.default]
argument and name hiding
argument and virtual function
argument forwarding call wrapper, [func.require]
argument list
empty, [dcl.fct]
variable, [dcl.fct]
argument passing, [expr.call]
reference and, [dcl.init.ref]
argument substitution, see macro, argument substitution
argument type
unknown, [dcl.fct]
argument-dependent lookup, see lookup, argument-dependent
arithmetic
pointer, [expr.add]
array
element, [dcl.array]
first element, [dcl.array]
handler of type, [except.handle]
parameter of type, [dcl.fct]
template parameter of type, [temp.param]
array
as aggregate, [array.overview]
contiguous storage, [array.overview]
tuple interface to, [array.tuple]
zero sized, [array.zero]
array size
default, [dcl.array]
array type, [dcl.array]
arrow operator, see operator, class member access
as-if rule, [intro.abstract]
asm, [lex.key], [dcl.asm], [gram.dcl]
implementation-defined, [dcl.asm]
asm-declaration, [dcl.asm], [gram.dcl]
assembler, [dcl.asm]
assertion
postcondition, [dcl.contract.func]
precondition, [dcl.contract.func]
assertion-statement, [stmt.contract.assert], [gram.stmt]
assignment
and lvalue, [expr.assign]
conversion by, [expr.assign]
reference, [dcl.init.ref]
assignment operator
copy, [special], [class.copy.assign]
implicitly declared, [class.copy.assign]
non-trivial, [class.copy.assign]
virtual bases and, [class.copy.assign]
move, [special], [class.copy.assign]
implicitly declared, [class.copy.assign]
non-trivial, [class.copy.assign]
overloaded, [over.assign]
assignment-expression, [expr.assign], [gram.expr]
assignment-operator, [expr.assign], [gram.expr]
associated constraints, [temp.constr.decl]
associated scope, see scope, associated
associative container, see container, associative
associative containers
exception safety, [associative.reqmts.except]
assumption, [dcl.attr.assume]
async lifetime, [exec.async.ops]
async result, see result, async
asynchronous operation, see operation, asynchronous
asynchronous provider, [futures.state]
asynchronous return object, [futures.state]
at least as constrained, [temp.constr.order]
at least as specialized as, see more specialized
atomic
notifying operation, [atomics.wait]
smart pointers, [util.smartptr.atomic]
waiting operation, [atomics.wait]
eligible to be unblocked, [atomics.wait]
atomic constraint, see constraint, atomic
atomic modify-write operation, see modify-write operation, atomic
attached
declaration, [module.unit]
entity, [basic.link]
attribute, [dcl.attr], [exec.async.ops]
alignment, [dcl.align]
indeterminate, [dcl.attr.indet]
maybe unused, [dcl.attr.unused]
no unique address, [dcl.attr.nouniqueaddr]
syntax and semantics, [dcl.attr.grammar]
attribute-argument-clause, [dcl.attr.grammar], [gram.dcl]
attribute-declaration, [dcl.pre], [gram.dcl]
attribute-namespace, [dcl.attr.grammar], [gram.dcl]
attribute-scoped-token, [dcl.attr.grammar], [gram.dcl]
attribute-specifier, [dcl.attr.grammar], [gram.dcl]
attribute-specifier-seq, [dcl.attr.grammar], [gram.dcl]
attribute-token, [dcl.attr.grammar], [gram.dcl]
attribute-using-prefix, [dcl.attr.grammar], [gram.dcl]
attributed-identifier, [dcl.contract.res], [gram.dcl]
automatic storage duration, see storage duration, automatic
await expression
await-expression, [expr.await], [gram.expr]
awaitable, [exec.awaitable]

B

backing array, see array, backing
backslash character, [lex.ccon]
bad_alloc, [expr.new]
bad_typeid, [expr.typeid]
balanced-token-seq, [dcl.attr.grammar], [gram.dcl]
barrier
phase synchronization point, [thread.barrier.class]
barrier phase, [thread.barrier.class]
base characteristic, [meta.rqmts]
base class, [class.derived.general], [class.mi]
dependent, [temp.dep.type]
non-virtual, [class.mi]
base class subobject, [intro.object]
base prefix, [format.string.std]
base-2 representation, [basic.fundamental]
basic character set, see character set, basic
basic literal character set, see character set, basic literal
basic-c-char, [lex.ccon], [gram.lex]
basic-s-char, [lex.string], [gram.lex]
BasicFormatter, [formatter.requirements]
behavior
implementation-defined, [defns.impl.defined], [intro.abstract]
locale-specific, [defns.locale.specific]
on receipt of signal, [intro.execution]
runtime-undefined, [defns.undefined.runtime]
Bernoulli distributions, [rand.dist.bern]
Bessel functions
beta functions B, [sf.cmath.beta]
better conversion, see conversion, better
better conversion sequence, see conversion sequence, better
binary element-wise operation, see operation, binary element-wise
binary fold, [expr.prim.fold]
binary left fold, [expr.prim.fold]
binary operator
interpretation of, [over.binary.general]
binary operator function, see operator function, binary
binary right fold, [expr.prim.fold]
binary-digit, [lex.icon], [gram.lex]
binary-exponent-part, [lex.fcon], [gram.lex]
binary-literal, [lex.icon], [gram.lex]
bind directly, [dcl.init.ref]
binding
reference, [dcl.init.ref]
bit-field, [class.bit]
address of, [class.bit]
alignment of, [class.bit]
converted, [conv.prom]
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
value
block
reserved, [hive.overview]
block (execution), [defns.block], [thread.req.lockable.basic], [thread.thread.member], [thread.jthread.mem], [thread.thread.this], [thread.mutex.requirements.mutex.general], [thread.mutex.class], [thread.mutex.recursive], [thread.timedmutex.class], [thread.timedmutex.recursive], [thread.sharedmutex.requirements.general], [thread.condition.condvar], [thread.condvarany.wait], [thread.sema.cnt], [thread.latch.class], [thread.barrier.class], [futures.unique.future], [futures.shared.future]
with forward progress guarantee delegation, [intro.progress]
block (statement), [defns.block.stmt], see statement, compound
initialization in, [stmt.dcl]
structure, [stmt.dcl]
block scope, see scope, block
block variable, [basic.scope.block]
block-declaration, [dcl.pre], [gram.dcl]
body
Bond
Boolean literal, [lex.bool]
boolean literal, see literal, boolean
Boolean type, [basic.fundamental]
boolean-literal, [lex.bool], [gram.lex]
bound argument entity, [func.def]
bound arguments, [func.bind.bind]
bound, of array, [dcl.array]
brace-or-equal-initializer, [dcl.init.general], [gram.dcl]
braced-init-list, [dcl.init.general], [gram.dcl]
brains
names that want to eat your, [zombie.names]
built-in candidate, [over.match.oper]
built-in operators, see operators, built-in

C

C
linkage to, [dcl.link]
standard library, [defns.c.lib]
C++ library headers
importable, [headers]
C++ library modules, [std.modules]
c-char-sequence, [lex.ccon], [gram.lex]
call
operator function, [over.oper.general]
call pattern, [func.require]
call signature, [func.def]
call wrapper, [func.def], [func.require]
forwarding, [func.require]
perfect forwarding, [func.require]
call-compatible, [expr.call]
callable object, see object, callable
callable type, see type, callable
callback deregistration
candidate, [over.match.general]
aggregate deduction, [over.match.class.deduct]
candidate initializer, [temp.arg.nontype]
capture
captured, [expr.prim.lambda.capture]
cast
base class, [expr.static.cast]
derived class, [expr.static.cast]
dynamic, [expr.dynamic.cast], [bad.cast]
construction and, [class.cdtor]
destruction and, [class.cdtor]
integer to pointer, [expr.reinterpret.cast]
pointer to integer, [expr.reinterpret.cast]
pointer-to-function, [expr.reinterpret.cast]
reinterpret, [expr.reinterpret.cast], [expr.cast]
integer to pointer, [expr.reinterpret.cast]
pointer to integer, [expr.reinterpret.cast]
pointer-to-function, [expr.reinterpret.cast]
pointer-to-member, [expr.reinterpret.cast]
static, [expr.static.cast], [expr.cast]
undefined pointer-to-function, [expr.reinterpret.cast]
cast-expression, [expr.cast], [gram.expr]
casting away constness, [expr.const.cast]
category tag, [std.iterator.tags]
cats
interfering with canines, [hardware.interference]
<ccomplex>
char, [lex.key], [lex.ccon], [lex.string], [intro.object], [basic.types.general], [basic.fundamental], [basic.compound], [basic.type.qualifier], [conv.rank], [basic.start.main], [basic.lval], [expr.new], [dcl.pre], [dcl.type.simple], [dcl.init.string], [except.throw], [locale.category], [fs.path.fmtr.funcs], [gram.dcl], [diff.cpp20.dcl]
implementation-defined sign of, [basic.fundamental]
char-like object, [strings.general]
char-like type, [strings.general]
character, [defns.character]
formatted as escaped, [format.string.escaped]
source file, [lex.phases]
terminating null, [byte.strings]
underscore, [lex.name], [usrlit.suffix]
in identifier, [lex.name]
character literal, see literal, character
character sequence, [character.seq.general]
character set, [lex.charset]
translation, [lex.charset]
character string literal, [cpp.stringize]
character type, see type, character
character-literal, [lex.ccon], [gram.lex]
characteristic sequence, see sequence, characteristic
checking
point of error, [temp.res.general]
checking semantics|seecontract evaluation semanticschecking, [basic.contract.eval]
checkpoints
observable, [intro.abstract]
child operations, see operations, child
<ciso646>
class, [basic.compound], [class]
cast to incomplete, [expr.cast]
constructor and abstract, [class.abstract]
definition, [basic.def.odr]
derived, [derivation]
designating, [class.access.base]
implicit-lifetime, [class.prop]
linkage of, [basic.link]
linkage specification, [dcl.link]
member function, see member function, class
nested, [class.nest]
polymorphic, [class.virtual]
scope of enumerator, [dcl.enum]
templated, [temp.pre]
trivially copyable, [basic.types.general], [class.prop]
union-like, [class.union.anon]
variant member of, [class.union.anon]
class member access operator function, see operator function, class member access
class name
point of declaration, [class.name]
class object
class object copy, see constructor, copy
class object initialization, see constructor
class scope, see scope, class
class-head-name, [class.pre], [gram.class]
class-property-specifier, [class.pre], [gram.class]
class-property-specifier-seq, [class.pre], [gram.class]
class-specifier, [class.pre], [gram.class]
code unit, [lex.charset]
<codecvt>
coherence
read-read, [intro.races]
read-write, [intro.races]
write-read, [intro.races]
write-write, [intro.races]
coherence-ordered before, [atomics.order]
collapsing slice type, see slice type, collapsing
comma operator, see operator, comma
comment, [lex.comment], [lex.pptoken]
common comparison type, [class.spaceship]
common initial sequence, [class.mem.general]
compare-expression, [expr.spaceship], [gram.expr]
comparison
pointer, [expr.eq]
pointer to function, [expr.eq]
undefined pointer, [expr.add]
comparison category types, [cmp.categories.pre]
comparison operator function, see operator function, comparison
compatible
template template parameter and template argument, [temp.arg.template]
compatible for subsumption, see subsumption, compatible for
compatible with
compilation
separate, [lex.separate]
compiler control line, see preprocessing directive
complete object, [intro.object]
complete object of, [intro.object]
complete-class context, [class.mem.general]
completely defined, [class.mem.general]
completion
permissible, [exec.snd.concepts]
completion function, see function, completion
completion operation, see operation, completion
completion scheduler, [exec.async.ops]
completion signature, [exec.async.ops]
completion tag, see tag, completion
composite pointer type, [expr.type]
compound statement, see statement, compound
compound-requirement, [expr.prim.req.compound], [gram.expr]
compound-statement, [stmt.block], [gram.stmt]
computed-type-specifier, [dcl.type.simple], [gram.dcl]
concatenation
macro argument, see ## operator
concept, [temp.concept]
concept template parameter, see template parameter, concept
concept-definition, [temp.concept], [gram.temp]
concept-dependent constraint, see constraint, concept-dependent
concept-id, [temp.names]
concept-tt-parameter, [temp.param], [gram.temp]
concurrent forward progress guarantees, [intro.progress]
conditions
rules for, [stmt.pre]
conditional-escape-sequence, [lex.ccon], [gram.lex]
conditional-escape-sequence-char, [lex.ccon], [gram.lex]
conditional-expression
throw-expression in, [expr.cond]
conditional-expression, [expr.cond], [gram.expr]
conditionally-supported behavior|seebehavior, conditionally-supported, [intro.compliance]
conditionally-supported-directive, [cpp.pre], [gram.cpp]
conflict, [intro.races]
conformance requirements, [intro.compliance.general], [intro.abstract]
method of description, [intro.compliance.general]
conjunction, [temp.constr.op]
consistency
linkage, [dcl.stc]
linkage specification, [dcl.link]
type declaration, [basic.link]
const, [defns.observer], [lex.key], [lex.string], [basic.type.qualifier], [basic.contract.general], [basic.contract.handler], [basic.lval], [expr.type], [conv.qual], [expr.prim.this], [expr.prim.id.unqual], [expr.prim.id.qual], [expr.prim.lambda.closure], [expr.call], [expr.ref], [expr.typeid], [expr.delete], [expr.mptr.oper], [dcl.pre], [dcl.spec.general], [dcl.stc], [dcl.type.general], [dcl.type.cv], [dcl.decl.general], [dcl.ptr], [dcl.ref], [dcl.fct], [dcl.contract.func], [dcl.contract.res], [dcl.init.ref], [class.ctor.general], [class.copy.ctor], [class.copy.assign], [class.dtor], [class.static.mfct], [class.static.data], [class.bit], [over.match.funcs.general], [over.match.viable], [over.ics.ref], [temp.deduct.general], [except.throw], [character.seq.general], [nullablepointer.requirements], [ptr.launder], [exception], [concept.assignable], [concept.moveconstructible], [concept.copyconstructible], [meta.trans.cv], [container.rev.reqmts], [container.alloc.reqmts], [container.requirements.dataraces], [iterator.concept.writable], [format.parse.ctx], [rand.req.dist], [class.gslice.overview], [gram.dcl], [diff.cpp11.dcl.dcl], [diff.cpp03.strings], [diff.basic], [diff.class]
constructor and, [class.ctor.general]
destructor and, [class.dtor]
linkage of, [basic.link]
const object, see object, const
undefined change to, [dcl.type.cv]
const volatile object, see object, const volatile
const-default-constructible, [dcl.init.general]
const-qualified, [basic.type.qualifier]
const-volatile-qualified, [basic.type.qualifier]
constant, [lex.literal.kinds], [expr.prim.literal]
enumeration, [dcl.enum]
null pointer, [conv.ptr], [conv.mem]
constant destruction, see destruction, constant
constant evaluation, [defns.const.eval]
constant expression, see expression, constant
constant initialization, [basic.start.static]
constant subexpression, [defns.const.subexpr]
constant template parameter, see template parameter, constant
constant-expression, [expr.const], [gram.expr]
constant-initializable, [expr.const]
constant-initialized, [expr.const]
consteval if statement, see statement, consteval if
consteval-block-declaration, [dcl.pre], [gram.dcl]
consteval-only, [basic.types.general]
constexpr function, [dcl.constexpr]
constexpr if, [stmt.if]
constexpr iterator, see iterator, constexpr
constexpr-enabled, [format.formatter.spec]
constexpr-referenceable, [expr.const]
constexpr-representable, [expr.const]
constexpr-suitable, [dcl.constexpr]
constexpr-unknown, [expr.const]
constituent expression, [intro.execution]
constituent reference, [intro.object]
constituent value, [intro.object]
constraint, [temp.constr.general]
associated, see associated constraints
concept-dependent, [temp.constr.concept]
fold expanded, [temp.constr.fold]
immediately-declared, [temp.param]
normalization, [temp.constr.normal]
satisfaction
concept-dependent, [temp.constr.concept]
conjunction, [temp.constr.op]
disjunction, [temp.constr.op]
subsumption, [temp.constr.order]
constraint-expression, [temp.constr.decl], [gram.temp]
constraint-logical-and-expression, [temp.pre], [gram.temp]
constraint-logical-or-expression, [temp.pre], [gram.temp]
construction, [class.cdtor]
dynamic cast and, [class.cdtor]
member access, [class.cdtor]
pointer to member or base, [class.cdtor]
typeid operator, [class.cdtor]
virtual function call, [class.cdtor]
constructor, [class.ctor.general], [class.ctor.general]
array of class objects and, [class.expl.init]
copy, [class.temporary], [special], [class.copy.ctor], [functions.within.classes]
implicitly declared, [class.copy.ctor]
nontrivial, [class.copy.ctor]
default, [special], [class.default.ctor]
delegating, [class.base.init]
explicit call, [class.ctor.general]
implicitly invoked, [class.default.ctor]
inheritance of, [class.default.ctor]
move, [special], [class.copy.ctor]
implicitly declared, [class.copy.ctor]
non-trivial, [class.copy.ctor]
constructor, conversion by, see conversion, user-defined
contain a value
contained value
container, [container.reqmts]
allocator-aware, [container.alloc.reqmts]
contiguous, [container.reqmts]
unordered associative, [unord.req.general]
contains a value
context
non-deduced, [temp.deduct.type]
contextually converted constant expression of type bool, see conversion, contextual
contextually converted to bool, see conversion, contextual to bool
contextually implicitly converted, [conv.general]
contiguous container, see container, contiguous
continue, [lex.key], [stmt.for], [stmt.jump.general], [stmt.cont], [except.pre], [gram.stmt]
and handler, [except.pre]
and try block, [except.pre]
contract assertion, [basic.contract], [basic.contract.general]
postcondition|seeassertion, postcondition, [dcl.contract.func]
precondition|seeassertion, precondition, [dcl.contract.func]
statement|seeassertion, statement, [stmt.contract.assert]
contract evaluation semantics
contract violation, [basic.contract.eval]
contract-assertion predicate, see predicate, contract-assertion
contract-assertion scope, see scope, contract-assertion
contract-terminated, [basic.contract.eval]
contract-violation handler, [basic.contract.handler]
contract_assert, [lex.key], [diff.cpp23.lex]
control line, see preprocessing directive
control-flow-limited statement, see statement, control-flow-limited
control-line, [cpp.pre], [gram.cpp]
controlling expression, see expression, controlling
conventions, [conventions.general]
conversion
argument, [dcl.fct]
array-to-pointer, [conv.array]
boolean, [conv.bool]
contextual, [conv.general]
contextual to bool, [conv.general]
contextual to constant expression of type bool, [expr.const]
deduced return type of user-defined, [class.conv.fct]
derived-to-base, [over.best.ics.general]
floating to integral, [conv.fpint]
floating-point, [conv.double]
function pointer, [conv.fctptr]
function-to-pointer, [conv.func]
immediate-escalating, [expr.const]
implementation-defined pointer integer, [expr.reinterpret.cast]
implicit user-defined, [class.conv.general]
inheritance of user-defined, [class.conv.fct]
integer rank, [conv.rank]
integral, [conv.integral]
integral to floating, [conv.fpint]
lvalue-to-rvalue, [conv.lval], [diff.expr]
narrowing, [dcl.init.list]
null member pointer, [conv.mem]
null pointer, [conv.ptr]
overload resolution and, [over.match.best.general]
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.general]
temporary materialization, [conv.rval]
to signed, [conv.integral]
to unsigned, [conv.integral]
usual arithmetic, [expr.arith.conv]
virtual user-defined, [class.conv.fct]
conversion explicit type, see casting
conversion function, see conversion, user-defined, see function, conversion
conversion rank, [over.ics.scs]
floating-point, [conv.rank]
conversion sequence
indistinguishable, [over.ics.rank]
standard, [conv.general]
user-defined, [over.ics.user]
conversion-declarator, [class.conv.fct], [gram.class]
conversion-function-id, [class.conv.fct], [gram.class]
conversion-type-id, [class.conv.fct], [gram.class]
converted bit-field, see bit-field, converted
converted constant expression, see expression, converted constant
copy
copy deduction candidate, [over.match.class.deduct]
copy elision|seeconstructor, copy, elision, [class.copy.elision]
copy-initialization, [dcl.init.general]
copy-list-initialization, [dcl.init.list]
copyable_function​::​is-callable-from, [func.wrap.copy.ctor]
core constant expression, see expression, core constant
coroutine, [dcl.fct.def.coroutine]
await expression, [dcl.fct.def.coroutine]
suspend point, [expr.await]
coroutine return, see co_return
coroutine state, [dcl.fct.def.coroutine]
coroutine-return-statement, [stmt.return.coroutine], [gram.stmt]
corresponding direct subobject, see subobject, corresponding direct
corresponding object parameter, see object parameter, corresponding
corresponding overloads, [basic.scope.scope]
corresponding signature, see signature, corresponding
counted range, see range, counted
Cpp17BasicLockable, [thread.req.lockable.basic]
Cpp17BidirectionalIterator, [bidirectional.iterators]
Cpp17BinaryTypeTrait, [meta.rqmts]
Cpp17Clock, [time.clock.req]
Cpp17CopyAssignable, [utility.arg.requirements]
Cpp17CopyConstructible, [utility.arg.requirements]
Cpp17CopyInsertable into X, [container.alloc.reqmts]
Cpp17DefaultConstructible, [utility.arg.requirements]
Cpp17DefaultInsertable into X, [container.alloc.reqmts]
Cpp17Destructible, [utility.arg.requirements]
Cpp17EmplaceConstructible into X from args, [container.alloc.reqmts]
Cpp17EqualityComparable, [utility.arg.requirements]
Cpp17Erasable from X, [container.alloc.reqmts]
Cpp17ForwardIterator, [forward.iterators]
Cpp17InputIterator, [input.iterators]
Cpp17Iterator, [iterator.iterators]
Cpp17LessThanComparable, [utility.arg.requirements]
Cpp17MoveAssignable, [utility.arg.requirements]
Cpp17MoveConstructible, [utility.arg.requirements]
Cpp17MoveInsertable into X, [container.alloc.reqmts]
Cpp17NullablePointer, [nullablepointer.requirements]
Cpp17OutputIterator, [output.iterators]
Cpp17RandomAccessIterator, [random.access.iterators]
Cpp17SharedLockable, [thread.req.lockable.shared]
Cpp17SharedTimedLockable, [thread.req.lockable.shared.timed]
Cpp17Swappable, [swappable.requirements]
Cpp17TimedLockable, [thread.req.lockable.timed]
Cpp17TransformationTrait, [meta.rqmts]
Cpp17TrivialClock, [time.clock.req]
Cpp17UnaryTypeTrait, [meta.rqmts]
Cpp17ValueSwappable, [swappable.requirements]
<cstdalign>
<cstdbool>
<ctgmath>
ctor-initializer, [class.base.init], [gram.class]
current class, see class, current
current instantiation, [temp.dep.type]
dependent member of the, [temp.dep.type]
member of the, [temp.dep.type]
currently handled exception, see exception handling, currently handled exception
customization point object, see object, customization point
cv-qualifier, [basic.type.qualifier]
cv-qualifier-seq, [dcl.decl.general], [gram.dcl]
cv-unqualified, [basic.type.qualifier]

D

d-char-sequence, [lex.string], [gram.lex]
DAG
multiple inheritance, [class.mi]
non-virtual base class, [class.mi]
virtual base class, [class.mi]
data member, see member, [class.mem.general]
data member description, see description, data member
data race, [intro.races]
data-parallel object, see object, data-parallel
data-parallel type, see type, data-parallel
deallocation function, [basic.stc.dynamic.general]
class-specific, [class.free]
decay
decay-copied from, [expos.only.entity]
decimal-floating-point-literal, [lex.fcon], [gram.lex]
decimal-literal, [lex.icon], [gram.lex]
decision variable, see variable, decision
decl-reachable, [module.global.frag]
decl-specifier-seq, [dcl.spec.general], [gram.dcl]
declaration, [basic.pre], [basic.def], [dcl], [dcl.pre]
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]
extern, [basic.def]
extern reference, [dcl.init.ref]
forward, [dcl.stc]
forward class, [class.name]
freestanding item, [freestanding.item]
injected, [expr.const]
local class, [class.local]
locus, see locus
multiple, [basic.link]
name-independent, [basic.scope.scope]
object, [dcl.pre]
opaque enum, [basic.def]
overloaded name and friend, [class.friend]
point of, see locus
pointer, [dcl.ptr]
potentially conflict, [basic.scope.scope]
reference, [dcl.ref]
static member, [basic.def]
storage class, [dcl.stc]
structured binding, see structured binding declaration
typedef, [dcl.pre]
typedef, [basic.def]
typedef as type, [dcl.typedef]
declaration, [dcl.pre], [gram.dcl]
declaration hiding, see name hiding
declaration-seq, [dcl.pre], [gram.dcl]
declaration-statement, [stmt.dcl], [gram.stmt]
declarative, [expr.prim.id.qual]
declarator, [basic.def], [dcl.pre], [dcl.decl.general]
function, [dcl.fct]
multidimensional array, [dcl.array]
pointer, [dcl.ptr]
pointer-to-member, [dcl.mptr]
reference, [dcl.ref]
declared specialization, see specialization, declared
decltype-specifier, [dcl.type.decltype], [gram.dcl]
decrement operator
decrement operator function, see operator function, decrement
deducible template, see template, deducible
deduction
class template argument, [temp.deduct.guide]
deduction substitution loci, [temp.deduct.general]
placeholder type, [dcl.type.auto.deduct]
deduction guide
freestanding item, [freestanding.item]
deduction substitution loci, [temp.deduct.general]
deemed construction, see construction, deemed
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
default contract-violation handler, see contract-violation handler, default
default member initializer, [class.mem.general]
default memory resource pointer, [mem.res.global]
default template argument, see template argument, default
default-initialization, [dcl.init.general]
default-inserted, [container.alloc.reqmts]
deferred function, see function, deferred
definable item, see item, definable
define, [basic.def]
defined, [cpp.cond]
defined prefix, see prefix, defined
defined-macro-expression, [cpp.cond], [gram.cpp]
defining-type-id, [dcl.name], [gram.dcl]
defining-type-specifier, [dcl.type.general], [gram.dcl]
defining-type-specifier-seq, [dcl.type.general], [gram.dcl]
definition, [basic.def], [basic.def]
class name as type, [class.name]
declaration as, [dcl.pre]
function, [dcl.fct.def]
explicitly-defaulted, [dcl.fct.def.default]
local class, [class.local]
member function, [class.mfct]
nested class, [class.nest]
program semantics affected by, [temp.inst]
pure virtual function, [class.abstract]
scope of class, [class.name]
static member, [class.static.data]
virtual function, [class.virtual]
definition domain, [basic.def.odr]
definitions, [intro.defs]
delegating constructor, see constructor, delegating
delete
single-object, [expr.delete]
delete, [lex.key], [basic.stc.dynamic.general], [basic.stc.dynamic.deallocation], [expr.new], [expr.delete], [dcl.fct.def.general], [class.dtor], [over.oper.general], [temp.dep.expr], [new.delete.array], [support.signal], [unique.ptr.dltr.dflt], [gram.expr], [gram.dcl], [gram.over]
destructor and, [expr.delete], [class.dtor]
single-object, [expr.delete]
type of, [class.free]
undefined, [expr.delete]
delete-expression, [expr.delete], [gram.expr]
deleted definition, see definition, deleted
deleted function, see function, deleted
deleted-function-body, [dcl.fct.def.general], [gram.dcl]
denormalized value, see number, subnormal
denote, [basic.pre]
dependent base class, see base class, dependent
dependent call, see call, dependent
dependent member of the current instantiation, see current instantiation, dependent member of the
dependent name, see name, dependent
dereferenceable iterator, see iterator, dereferenceable
dereferencing, see indirection
derivation, see inheritance
derived class, [class.derived.general]
derived object
description
data member, [class.mem.general]
designate, [basic.splice]
designated-initializer-clause, [dcl.init.general], [gram.dcl]
designated-initializer-list, [dcl.init.general], [gram.dcl]
designating class, see class, designating
destringization, [cpp.pragma.op]
destroying operator delete, see operator delete, destroying
destruction, [class.cdtor]
constant, [expr.const]
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], [class.dtor], [functions.within.classes]
address of, [class.dtor]
default, [class.dtor]
explicit call, [class.dtor]
implicit call, [class.dtor]
non-trivial, [class.dtor]
program termination and, [class.dtor]
prospective, [class.dtor]
pure virtual, [class.dtor]
selected, [class.dtor]
virtual, [class.dtor]
destructuring expansion statement, see expansion statement, destructuring
diagnosable rules, [intro.compliance.general]
diagnostic message, see message, diagnostic
digit-sequence, [lex.fcon], [gram.lex]
direct base class, see base class, direct
direct base class relationship, see relationship, direct base class
direct member, see member, direct
direct-initialization, [dcl.init.general]
direct-list-initialization, [dcl.init.list]
direct-non-list-initialization, [dcl.init.list]
directed acyclic graph, see DAG
directive, preprocessing, see preprocessing directive
directive-introducing token, see token, directive-introducing
directory, [fs.general]
directory-separator, [fs.path.generic]
discarded
discarded statement, [stmt.if]
discarded-value expression, [expr.context]
disjunction, [temp.constr.op]
disposition, [exec.async.ops]
disqualifying declaration, see declaration, disqualifying
disqualifying parameter, see parameter, disqualifying
distribution, see random number distribution
dogs
obliviousness to interference, [hardware.interference]
domain error, [sf.cmath.general]
dominance
virtual base class, [class.member.lookup]
dot
dot-dot
dynamic binding, see function, virtual
dynamic extent, see extent, dynamic
dynamic initialization, see initialization, dynamic
dynamic type, see type, dynamic

E

E (complete elliptic integrals), [sf.cmath.comp.ellint.2]
E (incomplete elliptic integrals), [sf.cmath.ellint.2]
ECMA-262, [re.general]
Ei (exponential integrals), [sf.cmath.expint]
elaborated type specifier, see class name, elaborated
elaborated-type-specifier, [dcl.type.elab], [gram.dcl]
element access functions, [algorithms.parallel.defns]
element block, [hive.overview]
element type, [dcl.array], see type, element
element-wise operation, see operation, element-wise
elements
selected, [simd.general]
elif-group, [cpp.pre], [gram.cpp]
elif-groups, [cpp.pre], [gram.cpp]
eligible
for subsumption, [temp.constr.order]
eligible special member function, see special member function, eligible
eligible to be unblocked, [atomics.wait]
elision
copy constructor, see constructor, copy, elision
copy|seeconstructor, copy, elision, [class.copy.elision]
move constructor, see constructor, move, elision
ellipsis
conversion sequence, [expr.call], [over.ics.ellipsis]
overload resolution and, [over.match.viable]
elliptic integrals
incomplete E, [sf.cmath.ellint.2]
incomplete F, [sf.cmath.ellint.1]
incomplete Π, [sf.cmath.ellint.3]
else-group, [cpp.pre], [gram.cpp]
embed-parameter, [cpp.pre], [gram.cpp]
embed-parameter-seq, [cpp.pre], [gram.cpp]
embed-prefixed-parameter, [cpp.pre], [gram.cpp]
embed-standard-parameter, [cpp.pre], [gram.cpp]
empty-declaration, [dcl.pre], [gram.dcl]
enclosed by statement, [stmt.pre]
enclosing scope, see scope, enclosing
enclosing statement, [stmt.pre]
enclosing-namespace-specifier, [namespace.def.general], [gram.dcl]
encoded character type, [fs.req]
encoding
literal, [lex.charset]
ordinary literal, [lex.charset]
registered character, [text.encoding.general]
wide literal, [lex.charset]
encoding-prefix, [lex.ccon], [gram.lex]
end-of-file, [bitset.operators]
endif-line, [cpp.pre], [gram.cpp]
engine adaptor, see random number engine adaptor
entity, [basic.pre]
freestanding item, [freestanding.item]
implicitly movable, [expr.prim.id.unqual]
templated, [temp.pre]
underlying, [basic.pre]
enum, [lex.key], [basic.lookup.elab], [basic.compound], [dcl.type.elab], [dcl.enum], [enum.udecl], [future.syn], [gram.dcl], [diff.class]
type of, [dcl.enum]
underlying type, see type, underlying
enum name
typedef, [dcl.typedef]
enum-head-name, [dcl.enum], [gram.dcl]
enum-specifier, [dcl.enum], [gram.dcl]
enumerated element, [enumerated.types]
enumerated type, see type, enumerated
enumerating expansion statement, see expansion statement, enumerating
enumeration, [dcl.enum]
linkage of, [basic.link]
scoped, [dcl.enum]
unscoped, [dcl.enum]
using declaration, [enum.udecl]
enumeration scope, see scope, enumeration
enumeration type
conversion to, [expr.static.cast]
static_cast
conversion to, [expr.static.cast]
enumerator
definition, [basic.def.odr]
scoped, [dcl.enum]
unscoped, [dcl.enum]
value of, [dcl.enum]
enumerator, [dcl.enum], [gram.dcl]
enumerator-definition, [dcl.enum], [gram.dcl]
enumerator-list, [dcl.enum], [gram.dcl]
environment, [exec.async.ops]
epoch, [time.clock.req]
equality operator function, see operator function, equality
equality-expression, [expr.eq], [gram.expr]
equivalence
template type, [temp.type]
equivalent
expressions, [temp.over.link]
template-heads, [temp.over.link]
template-parameters, [temp.over.link]
equivalent-key group, [unord.req.general]
erroneous value, see value, erroneous
error completion, see completion, error
escape character, see backslash character
escape sequence
escape-sequence, [lex.ccon], [gram.lex]
estimated field width, see field width, estimated
Eulerian integral of the first kind, see beta functions B
evaluate in sequence, [basic.contract.eval]
evaluation, [intro.execution]
order of argument, [expr.call]
signal-safe, [support.signal]
unspecified order of argument, [expr.call]
unspecified order of function call, [expr.call]
evaluation context, [expr.const]
evaluation semantics, [basic.contract.eval]
evaluation semantics|seecontract evaluation semantics, [basic.contract.eval]
exception
arithmetic, [expr.pre]
undefined arithmetic, [expr.pre]
exception handling, [except]
constructors and destructors, [except.ctor]
currently handled exception, [except.handle]
exception object, [except.throw], [except.throw]
constructor, [except.throw]
destructor, [except.throw]
function try block, [except.pre]
handler, [except.pre], [except.throw], [except.handle], [res.on.exception.handling]
array in, [except.handle]
incomplete type in, [except.handle]
pointer to function in, [except.handle]
rvalue reference in, [except.handle]
nearest handler, [except.throw]
rethrowing, [except.throw]
switch, [except.pre]
try block, [except.pre]
uncaught, [except.throw]
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]
exception-declaration, [except.pre], [gram.except]
exclusive-or-expression, [expr.xor], [gram.expr]
execution character set, see character set, execution
execution policy, [execpol.general]
execution policy template parameter, see template parameter, execution policy
execution resource, see resource, execution
execution step, [intro.progress]
execution wide-character set, see wide-character set, execution
expansion statement
destructuring, [stmt.expand]
enumerating, [stmt.expand]
iterating, [stmt.expand]
expansion-init-list, [stmt.expand], [gram.stmt]
expansion-initializer, [stmt.expand], [gram.stmt]
expansion-iterable, [stmt.expand]
expansion-statement, [stmt.expand], [gram.stmt]
explicit object member function, see member function, explicit object
explicit object parameter, see parameter, explicit object
explicit type conversion, see casting
explicit-instantiation, [temp.explicit], [gram.temp]
explicit-object-parameter-declaration, [dcl.fct]
explicit-specialization, [temp.expl.spec], [gram.temp]
explicit-specifier, [dcl.fct.spec], [gram.dcl]
explicitly captured, [expr.prim.lambda.capture]
explicitly initialized elements
aggregate, [dcl.init.aggr]
exponent-part, [lex.fcon], [gram.lex]
exponential integrals Ei, [sf.cmath.expint]
export-declaration, [module.interface], [gram.module]
export-keyword, [lex.pptoken]
exposure, [basic.link]
expr-or-braced-init-list, [dcl.init.general], [gram.dcl]
expression, [expr.pre]
additive operators, [expr.add]
assignment and compound assignment, [expr.assign]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
conditional operator, [expr.cond]
const cast, [expr.const.cast]
controlling, [stmt.iter.general]
converted constant, [expr.const]
core constant, [expr.const]
destructor call, [expr.prim.id.dtor]
dynamic cast, [expr.dynamic.cast]
equality operators, [expr.eq]
equality-preserving, [concepts.equality]
equivalent, see equivalent, expressions
function call, [expr.call]
functionally equivalent, see functionally equivalent, expressions
immediate-escalating, [expr.const]
integral constant, [expr.const]
left-shift-operator, [expr.shift]
logical AND, [expr.log.and]
logical OR, [expr.log.or]
multiplicative operators, [expr.mul]
order of evaluation of, [expr.pre]
parenthesized, [expr.prim.paren]
pointer-to-member, [expr.mptr.oper]
pointer-to-member constant, [expr.unary.op]
potentially constant evaluated, [expr.const]
potentially evaluated, [basic.def.odr]
primary, [expr.prim]
pseudo-destructor call, [expr.prim.id.dtor]
reference, [expr.type]
reinterpret cast, [expr.reinterpret.cast]
relational operators, [expr.rel]
right-shift-operator, [expr.shift]
rvalue reference, [basic.lval]
spaceship, [expr.spaceship]
static cast, [expr.static.cast]
subscript, [expr.sub]
three-way comparison, [expr.spaceship]
type identification, [expr.typeid]
type-dependent, [temp.dep.general]
unary operator, [expr.unary.op]
value-dependent, [temp.dep.general]
expression-equivalent, [defns.expression.equivalent]
expression-statement, [stmt.expr], [gram.stmt]
extend, see namespace, extend
extended alignment, see alignment, extended
extended integer type, see type, extended integer
extended signed integer type, see type, extended signed integer
extended unsigned integer type, see type, extended unsigned integer
extent
extern, [lex.key], [basic.def], [basic.scope.pdecl], [basic.link], [basic.stc.static], [basic.stc.auto], [dcl.stc], [dcl.meaning.general], [dcl.ref], [dcl.init.ref], [dcl.link], [class.mem.general], [temp.explicit], [gram.dcl], [gram.temp], [diff.basic], [diff.dcl]
linkage of, [dcl.stc]
extern template, see instantiation, explicit
external linkage, see linkage, external

F

F (incomplete elliptic integrals), [sf.cmath.ellint.1]
fallback-separator, [fs.path.generic]
fallthrough statement, see statement, fallthrough
feature-test macro, see macro, feature-test
field width
field width units, see units, field width
file attributes, [fs.class.directory.entry.general]
file system, [fs.general]
file system race, [fs.race.behavior]
file, source, see source file
fill character, see character, fill
final await expression, see await expression, final
final overrider, [class.virtual]
final suspend point, see suspend point, final
first declaration, see declaration, first
floating-point conversion rank, see conversion rank, floating-point
floating-point literal, see literal, floating-point
floating-point promotion, [conv.fpprom]
floating-point type, see type, floating-point
floating-point-literal, [lex.fcon], [gram.lex]
floating-point-suffix, [lex.fcon], [gram.lex]
fold
fold expanded constraint, see constraint, fold expanded
fold-expression, [expr.prim.fold], [gram.expr]
for-range-declaration, [stmt.pre], [gram.stmt]
for-range-initializer, [stmt.pre], [gram.stmt]
format specification
formatter
debug-enabled specialization of, [format.formatter.spec]
formatting locale, see locale, formatting
forward, [forward]
forward progress guarantees
concurrent, [intro.progress]
delegation of, [intro.progress]
weakly parallel, [intro.progress]
forwarding reference, [temp.deduct.call]
fractional-constant, [lex.fcon], [gram.lex]
free store, see also new, see also delete, [class.free]
freestanding deleted function, see function, freestanding deleted
freestanding implementation, see implementation, freestanding
freestanding item, [freestanding.item]
friend
access specifier and, [class.friend]
class access and, [class.friend]
inheritance and, [class.friend]
local class and, [class.friend]
template and, [temp.friend]
virtual and, [class.virtual]
friend function
access and, [class.friend]
linkage of, [basic.link]
member function and, [class.friend]
nested class, [class.nest]
friend-type-declaration, [class.mem.general], [gram.class]
friend-type-specifier, [class.mem.general], [gram.class]
friend-type-specifier-list, [class.mem.general], [gram.class]
full-expression, [intro.execution]
function, see also friend function, see also member function, see also inline function, see also virtual function
addressable, [namespace.std]
completion, [exec.async.ops]
deferred, [futures.async]
definition, [basic.def.odr]
freestanding deleted, [freestanding.item]
handler of type, [except.handle]
immediate, [expr.const]
immediate-escalating, [expr.const]
inline, [dcl.inline]
linkage specification overloaded, [dcl.link]
named by expression or conversion, [basic.def.odr]
needed for constant evaluation, [expr.const]
non-template, [dcl.fct]
operator, [over.oper.general]
overload resolution and, [over.match.funcs.general]
overloaded, see overloading
parameter of type, [dcl.fct]
pointer to member, [expr.mptr.oper]
program semantics affected by the existence of a function definition, [temp.inst]
template parameter of type, [temp.param]
templated, [temp.pre]
vararg, [dcl.fct]
virtual, [class.virtual], [class.virtual]
override, [class.virtual]
virtual function call, [expr.call]
virtual member, [derived.classes]
function argument, see argument
function call, [expr.call]
recursive, [expr.call]
function call operator
overloaded, [over.call]
function call operator function, see operator function, function call
function contract assertion, see contract assertion, function
function object, [function.objects.general]
mem_fn, [func.memfn]
reference_wrapper, [refwrap.general]
function parameter, see parameter
function parameter pack, [temp.variadic]
function parameter scope, see scope, function parameter
function pointer type, [basic.compound]
function return, see return
function return type, see return type
function type, see type, function
function-body, [dcl.fct.def.general], [gram.dcl]
function-contract-specifier, [dcl.contract.func], [gram.dcl]
function-contract-specifier-seq, [dcl.contract.func], [gram.dcl]
function-definition, [dcl.fct.def.general], [gram.dcl]
function-like macro, see macro, function-like
function-local predefined variable, see variable, function-local predefined
function-specifier, [dcl.fct.spec], [gram.dcl]
function-try-block, [except.pre], [gram.except]
function_ref​::​is-invocable-using, [func.wrap.ref.ctor]
functionally equivalent
expressions, [temp.over.link]
template-heads, [temp.over.link]
functions
fundamental alignment, see alignment, fundamental
fundamental type, [basic.fundamental]
destructor and, [class.dtor]
fundamental type conversion, see conversion, user-defined
future
shared state, [futures.state]

G

generated destructor, see destructor, default
generic parameter type placeholder, [dcl.spec.auto.general]
global module, see module, global
global module fragment, [module.global.frag]
global namespace, see namespace, global
global scope, see scope, global
global-module-fragment, [module.global.frag], [gram.module]
glvalue, [basic.lval]
goto, [lex.key], [expr.const], [stmt.while], [stmt.jump.general], [stmt.return.coroutine], [except.pre], [gram.stmt]
and handler, [except.pre]
and try block, [except.pre]
initialization and, [stmt.dcl]
grammar, [gram.general]
regular expression, [re.grammar]
group-part, [cpp.pre], [gram.cpp]

H

h-char-sequence, [lex.header], [gram.lex]
h-pp-tokens, [cpp.cond], [gram.cpp]
h-preprocessing-token, [cpp.cond], [gram.cpp]
handle
happens before, [intro.races]
hardened implementation, see implementation, hardened
has-attribute-expression, [cpp.cond], [gram.cpp]
has-embed-expression, [cpp.cond], [gram.cpp]
has-include-expression, [cpp.cond], [gram.cpp]
hash
instantiation restrictions, [unord.hash]
hash function, [unord.req.general]
hazard pointer, [saferecl.hp.general]
unassociated, [saferecl.hp.general]
hazard-protectable, [saferecl.hp.general]
header, [headers]
C library, [using.linkage]
C++ library, [headers]
importable, [module.import]
header unit, [module.import]
preprocessing, [cpp.import]
header-name, [lex.header], [gram.lex]
header-name-tokens, [cpp.cond], [gram.cpp]
headers
heap with respect to comp and proj, [alg.heap.operations.general]
Hermite polynomials
hexadecimal-digit, [lex.icon], [gram.lex]
hexadecimal-digit-sequence, [lex.icon], [gram.lex]
hexadecimal-escape-sequence, [lex.ccon], [gram.lex]
hexadecimal-floating-point-literal, [lex.fcon], [gram.lex]
hexadecimal-fractional-constant, [lex.fcon], [gram.lex]
hexadecimal-literal, [lex.icon], [gram.lex]
hexadecimal-prefix, [lex.icon], [gram.lex]
host scope, see scope, host
hosted implementation, see implementation, hosted
hosted library facilities, see library facilities, hosted

I

id-expression, [expr.prim.id.general]
identical
atomic constraints, see atomic constraint, identical
identifier, [lex.name], [gram.lex]
identifier-continue, [lex.name], [gram.lex]
identifier-list, [cpp.pre], [gram.cpp]
identifier-start, [lex.name], [gram.lex]
if-section, [cpp.pre], [gram.cpp]
ill-formed program, see program, ill-formed
immediate function, see function, immediate
immediate function context, [expr.const]
immediate invocation, [expr.const]
immediate scope, see scope, immediate
immediate subexpression, [intro.execution]
immediate-escalating, [expr.const]
conversion|seeconversion, immediate-escalating, [expr.const]
expression|seeexpression, immediate-escalating, [expr.const]
function|seefunction, immediate-escalating, [expr.const]
implementation
implementation limits, see limits, implementation
implementation-defined behavior, see behavior, implementation-defined
implementation-generated, [basic.def]
implementation-resource-count, [cpp.embed.gen]
implementation-resource-width, [cpp.embed.gen]
implicit conversion, see conversion, implicit
implicit conversion sequence, see conversion sequence, implicit
implicit object member function, see member function, implicit object
implicit object parameter, see object parameter, implicit
implicit-lifetime class, see class, implicit-lifetime
implicit-lifetime type, see type, implicit-lifetime
implicitly movable entity, see entity, implicitly movable
implicitly-declared default constructor, see constructor, default, [class.default.ctor]
implied object argument, [over.match.funcs.general]
implicit conversion sequences, [over.match.funcs.general]
non-static member function and, [over.match.funcs.general]
import-keyword, [lex.pptoken]
importable C++ library headers, see C++ library headers, importable
importable header, see header, importable
inclusion
inclusive-or-expression, [expr.or], [gram.expr]
incomplete, [expr.add]
incomplete type, see type, incomplete
incompletely-defined object type, see object type, incompletely-defined
increment operator
increment operator function, see operator function, increment
indeterminate value, see value, indeterminate
indeterminately sequenced, [intro.execution]
index
multidimensional, [mdspan.overview]
index space
multidimensional, [mdspan.overview]
indices
selected, [simd.general]
indirect base class, see base class, indirect
indirection, [expr.unary.op]
inheritance, [class.derived.general]
using-declaration and, [namespace.udecl]
init-declarator, [dcl.decl.general], [gram.dcl]
init-declarator-list, [dcl.decl.general], [gram.dcl]
init-statement, [stmt.pre], [gram.stmt]
initial await expression, see await expression, initial
initial suspend point, see suspend point, initial
initialization, [basic.start.static], [dcl.init.general]
aggregate, [dcl.init.aggr]
array of class objects, [dcl.init.aggr], [class.expl.init]
automatic, [stmt.dcl]
base class, [class.base.init]
by inherited constructor, [class.inhctor.init]
character array, [dcl.init.string]
const member, [class.base.init]
default constructor and, [class.init.general]
definition and, [dcl.pre]
dynamic block-scope, [stmt.dcl]
dynamic non-block, [basic.start.dynamic]
jump past, [stmt.dcl]
list-initialization, [dcl.init.list]
local static, [stmt.dcl]
local thread_local, [stmt.dcl]
member function call during, [class.base.init]
member object, [class.base.init]
order of base class, [class.base.init]
order of member, [class.base.init]
order of virtual base class, [class.base.init]
overloaded assignment and, [class.expl.init]
parameter, [expr.call]
reference member, [class.base.init]
static and thread, [basic.start.static]
static member, [class.static.data]
vacuous, [basic.life]
virtual base class, [class.copy.ctor]
initializer
pack expansion, [class.base.init]
scope of member, [class.base.init]
temporary and declarator, [class.temporary]
initializer-clause, [dcl.init.general], [gram.dcl]
initializer-list, [dcl.init.general], [gram.dcl]
initializer-list constructor, [dcl.init.list]
initializing declaration, [dcl.init.general]
injected declaration, see declaration, injected
injected-class-name, [class.pre]
inline, [lex.key], [basic.start.main], [dcl.spec.general], [dcl.inline], [dcl.meaning.general], [namespace.def.general], [namespace.unnamed], [class.mfct], [class.ctor.general], [class.dtor], [over.literal], [temp.friend], [temp.explicit], [gram.dcl]
linkage of, [basic.link]
inline function, [dcl.inline], see function, inline
inline namespace, see namespace, inline
inline namespace set, [namespace.def.general]
inline variable, [dcl.inline], see variable, inline
instantiation
explicit, [temp.explicit]
point of, [temp.point]
template implicit, [temp.inst]
instantiation context, [module.context]
integer literal, see literal, integer
integer type, [basic.fundamental]
integer-class type, see type, integer-class
integer-literal, [lex.icon], [gram.lex]
integer-suffix, [lex.icon], [gram.lex]
integral constant expression, see expression, integral constant
integral promotion, [conv.prom]
integral type, [basic.fundamental]
implementation-defined sizeof, [basic.fundamental]
interface dependency, [module.import]
internal linkage, see linkage, internal
invalid iterator, see iterator, invalid
invalid pointer value, see value, invalid pointer
invocation
invocation sequence, [stacktrace.general]
item
definable, [basic.def.odr]
freestanding, see freestanding item
iterating expansion statement, see expansion statement, iterating
iteration statement
trivially empty, [stmt.iter.general]
iterator, [iterator.requirements.general]

J

K

K (complete elliptic integrals), [sf.cmath.comp.ellint.1]
key parameter, see parameter, key
known to be initialized, [except.ctor]

L

label, [stmt.goto]
scope of, [stmt.label]
labeled-statement, [stmt.label], [gram.stmt]
Laguerre polynomials
lambda scope, see scope, lambda
language linkage, [dcl.link]
lattice, see DAG, see subobject
layout
bit-field, [class.bit]
layout mapping, [mdspan.layout.reqmts]
layout mapping policy, [mdspan.layout.policy.reqmts]
layout-compatible
enumeration, [dcl.enum]
layout-compatible type, see type, layout-compatible
left shift
undefined, [expr.shift]
left shift operator, see operator, left shift
Legendre functions
Legendre polynomials
lexical conventions, see conventions, lexical
library
library call
library clauses, [intro.structure]
library facilities
hosted, [compliance]
lifetime, [basic.life]
lifetime of an asynchronous operation, [exec.async.ops]
limits
implementation, [defns.impl.limits]
line number, [cpp.line]
line splicing, [lex.phases]
line-directive, [cpp.line], [gram.cpp]
line-directives, [cpp.pre], [gram.cpp]
linear algebra value type, see value type, linear algebra
linkage, [basic.pre], [basic.link]
const and, [basic.link]
implementation-defined object, [dcl.link]
inline and, [basic.link]
internal, [basic.link]
module, [basic.link]
static and, [basic.link]
linkage specification, see specification, linkage
linkage-specification, [dcl.link], [gram.dcl]
list-initialization, [dcl.init.list]
literal, [lex.literal], [expr.prim.literal]
base of integer, [lex.icon]
boolean, [lex.bool]
char16_t, [lex.ccon]
char32_t, [lex.ccon]
char8_t, [lex.ccon]
character, [lex.ccon]
ordinary, [lex.ccon]
UTF-16, [lex.ccon]
UTF-32, [lex.ccon]
UTF-8, [lex.ccon]
float, [lex.fcon]
floating-point, [lex.fcon]
integer, [lex.icon]
long double, [lex.fcon]
multicharacter, [lex.ccon]
narrow-character, [lex.string]
operator, [over.literal]
template, [over.literal]
template numeric, [over.literal]
template string, [over.literal]
pointer, [lex.nullptr]
string, [lex.string]
char16_t, [lex.string]
char32_t, [lex.string]
narrow, [lex.string]
ordinary, [lex.string]
undefined change to, [lex.string]
UTF-16, [lex.string]
UTF-32, [lex.string]
suffix identifier, [over.literal]
type of character, [lex.ccon]
type of floating-point, [lex.fcon]
type of integer, [lex.icon]
unsigned, [lex.icon]
user-defined, [lex.ext]
literal encoding, see encoding, literal
literal type, see type, literal
literal-operator-id, [over.literal], [gram.over]
living dead
local class, see class, local
member function in, [class.mfct]
local entity, see entity, local
local scope, see scope, block
local variable
destruction of, [stmt.jump.general]
locale, [re.req], [re.synopt]
formatting, [time.format]
locale-specific, [character.seq.general]
locale-specific behavior, see behavior, locale-specific
locale-specific form
format string, [format.string.std]
lock
lock-free execution, [intro.progress]
logical-and-expression, [expr.log.and], [gram.expr]
logical-or-expression, [expr.log.or], [gram.expr]
long, [lex.key], [lex.fcon], [basic.align], [basic.fundamental], [conv.rank], [conv.prom], [dcl.type.simple], [format.parse.ctx], [gram.dcl]
typedef and, [dcl.spec.general]
long-long-suffix, [lex.icon], [gram.lex]
long-suffix, [lex.icon], [gram.lex]
lookup
class member, [class.qual]
elaborated type specifier, [basic.lookup.elab]
namespace aliases and, [basic.lookup.udir]
unqualified name, [basic.lookup.unqual]
using-directives and, [basic.lookup.udir]
loop
trivial infinite, [stmt.iter.general]
lower triangle, see triangle, lower
lvalue reference, [dcl.ref]

M

macro
active, [cpp.import]
argument substitution, [cpp.subst]
definition, [cpp.import]
freestanding item, [freestanding.item]
function-like, [cpp.replace.general], [cpp.replace.general]
point of definition, [cpp.import]
point of import, [cpp.import]
point of undefinition, [cpp.import]
pragma operator, [cpp.pragma.op]
predefined, [cpp.predefined]
replacement list, [cpp.replace.general]
rescanning and replacement, [cpp.rescan]
scope of definition, [cpp.scope]
main function, [basic.start.main]
implementation-defined linkage of, [basic.start.main]
implementation-defined parameters to, [basic.start.main]
parameters to, [basic.start.main]
make progress
make-unsigned-like-t, [ranges.syn]
manifestly constant-evaluated, [expr.const]
mathematical special functions, [sf.cmath.general]
mem-initializer-id, [class.base.init], [gram.class]
mem-initializer-list, [class.base.init], [gram.class]
member
anonymous union, [class.union.anon]
class static, [basic.stc.static]
default initializer, [class.mem.general]
template and static, [temp.static]
member access operator
overloaded, [over.ref]
member candidate, [over.match.oper]
member data
member function, [class.mem.general]
const volatile, [class.mfct.non.static]
constructor and, [class.ctor.general]
destructor and, [class.dtor]
explicit object, [dcl.fct]
implicit object, [dcl.fct]
inline, [class.mfct]
local class, [class.local]
nested class, [class.access.nest]
overload resolution and, [over.match.funcs.general]
member of the current instantiation, see current instantiation, member of the
member pointer to, see pointer to member
member subobject, [intro.object]
member-declaration, [class.mem.general], [gram.class]
member-declarator, [class.mem.general], [gram.class]
member-declarator-list, [class.mem.general], [gram.class]
member-qualified name, see name, member-qualified
member-specification, [class.mem.general], [gram.class]
memory location, [intro.memory]
memory management, see new, see delete
memory model, [intro.memory]
message
minimum field width, see field width, minimum
model
modifiable, [basic.lval]
modification order, [intro.races]
modify-write operation
module, [module.unit]
exported, [module.import]
reserved name of, [module.unit]
module implementation unit, [module.unit]
module interface unit, [module.unit]
module linkage, see linkage, module
module partition, [module.unit]
module unit, [module.unit]
module unit purview, see purview, module unit
module-declaration, [module.unit], [gram.module]
module-file, [cpp.pre], [gram.cpp]
module-import-declaration, [module.import], [gram.module]
module-keyword, [lex.pptoken]
module-name-qualifier, [module.unit], [gram.module]
module-partition, [module.unit], [gram.module]
more constrained, [temp.constr.order]
more cv-qualified, [basic.type.qualifier]
more partial-ordering-constrained, [temp.constr.order]
more specialized, [temp.spec.partial.order], [temp.deduct.partial]
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
move, [forward]
move-eligible, [expr.prim.id.unqual]
move_only_function​::​is-callable-from, [func.wrap.move.ctor]
multibyte character, see character, multibyte
multicharacter literal, see literal, multicharacter
multidimensional index, see index, multidimensional
multidimensional index space, see index space, multidimensional
multiple inheritance, [class.derived.general], [class.mi]
virtual and, [class.virtual]
multiple threads, see threads, multiple
multiplicative-expression, [expr.mul], [gram.expr]

N

name, [lex.name], [basic.pre], [basic.link], [expr.prim.id.general]
address of cv-qualified, [expr.unary.op]
elaborated
length of, [lex.name]
macro, see macro, name
member-qualified, [basic.lookup.qual.general]
predefined macro, see macro, predefined
name class, see class name
name hiding, [basic.scope.pdecl], [expr.prim.id.qual], [stmt.dcl]
using-declaration and, [namespace.udecl]
name-declaration, [dcl.pre], [gram.dcl]
named module, see module, named
named-namespace-definition, [namespace.def.general], [gram.dcl]
named-universal-character, [lex.universal.char], [gram.lex]
namespace, [contents]
namespace alias, see alias, namespace
namespace scope, see scope, namespace
namespace-alias, [namespace.alias], [gram.dcl]
namespace-alias-definition, [namespace.alias], [gram.dcl]
namespace-body, [namespace.def.general], [gram.dcl]
namespace-definition, [namespace.def.general], [gram.dcl]
narrow character type, see type, narrow character
narrowing conversion, see conversion, narrowing
native encoding, [fs.path.type.cvt]
native handle, see handle, native
native pathname format, [fs.class.path.general]
necessarily reachable, see reachable, necessarily
needed
exception specification, [except.spec]
function contract assertion, [dcl.contract.func]
needed for constant evaluation, [expr.const]
nested class, see class, nested
local class, [class.local]
nested within, [intro.object]
nested-name-specifier, [expr.prim.id.qual], [gram.expr]
nested-namespace-definition, [namespace.def.general], [gram.dcl]
nested-requirement, [expr.prim.req.nested], [gram.expr]
Neumann functions
new, [lex.key], [intro.object], [basic.stc.dynamic.general], [basic.stc.dynamic.allocation], [basic.stc.dynamic.deallocation], [expr.new], [expr.delete], [expr.const], [dcl.name], [over.oper.general], [temp.dep.expr], [except.spec], [new.delete.array], [support.signal], [util.smartptr.shared.general], [saferecl.rcu.domain.func], [gram.expr], [gram.over]
array of class objects and, [expr.new]
constructor and, [expr.new]
default constructor and, [expr.new]
exception and, [expr.new]
initialization and, [expr.new]
scoping and, [expr.new]
storage allocation, [expr.new]
type of, [class.free]
unspecified constructor and, [expr.new]
unspecified order of evaluation, [expr.new]
new-declarator, [expr.new], [gram.expr]
new-expression, [expr.new], [gram.expr]
placement, [expr.new]
new-extended alignment, see alignment, new-extended
new-initializer, [expr.new], [gram.expr]
new-placement, [expr.new], [gram.expr]
new-type-id, [expr.new], [gram.expr]
no linkage, see linkage, no
nodeclspec-function-declaration, [dcl.pre], [gram.dcl]
nodiscard call, see call, nodiscard
nodiscard type, see type, nodiscard
noexcept-expression, [expr.unary.noexcept], [gram.expr]
noexcept-specifier, [except.spec], [gram.except]
non-dependent sender, see sender, non-dependent
non-initialization odr-use, see odr-use, non-initialization
non-member candidate, [over.match.oper]
non-object parameter, see parameter, non-object
non-object-parameter-type-list, [dcl.fct]
non-shared lock, see lock, non-shared
non-static data member, see data member, non-static
non-static member, see member, non-static
non-static member function, see member function, non-static
non-template function, see function, non-template
non-throwing exception specification, [except.spec]
non-virtual base class, see base class, non-virtual
nonzero-digit, [lex.icon], [gram.lex]
noptr-abstract-declarator, [dcl.name], [gram.dcl]
noptr-abstract-pack-declarator, [dcl.name], [gram.dcl]
noptr-declarator, [dcl.decl.general], [gram.dcl]
noptr-new-declarator, [expr.new], [gram.expr]
normal distributions, [rand.dist.norm]
normal form
normalization, see constraint, normalization
normative references, see references, normative
notation
syntax, [syntax]
ntbs, [byte.strings]
ntmbs, [multibyte.strings]
null character, see character, null
null member pointer conversion, see conversion, null member pointer
null pointer conversion, see conversion, null pointer
null pointer value, see value, null pointer
null reflection, see reflection, null
null statement, see statement, null
null wide character, see wide-character, null
number
preprocessing, [lex.ppnumber]
numeric type, see type, numeric
numeric-escape-sequence, [lex.ccon], [gram.lex]
numeric_limits, [limits.syn]

O

object, see also object model, [basic.pre], [intro.object]
byte copying and, [basic.types.general]
callable, [func.def]
complete, [intro.object]
const volatile, [basic.type.qualifier]
customization point, [customization.point.object]
data-parallel, [simd.general]
definition, [basic.def.odr]
destructor and placement of, [class.dtor]
destructor static, [basic.start.term]
implicit creation, [intro.object]
linkage specification, [dcl.link]
local static, [basic.stc.static]
nested within, [intro.object]
nonzero size, [intro.object]
potentially non-unique, [intro.object]
providing storage for, [intro.object]
range adaptor, [range.adaptor.object]
range adaptor closure, [range.adaptor.object]
suitable created, [intro.object]
zero size, [intro.object]
object class, see class object
object expression, [expr.ref], [expr.mptr.oper]
object lifetime, [basic.life]
object model, [intro.object]
object parameter, see parameter, object
corresponding, [basic.scope.scope]
object pointer type, [basic.compound]
object type, [basic.types.general]
incompletely-defined, [basic.types.general]
object-like macro, see macro, object-like
observable behavior, see behavior, observable
observable checkpoints, see checkpoints, observable
octal-digit, [lex.icon], [gram.lex]
octal-escape-sequence, [lex.ccon], [gram.lex]
octal-literal, [lex.icon], [gram.lex]
odr-usable, [basic.def.odr]
odr-use, [basic.def.odr]
non-initialization, [basic.start.dynamic]
one-definition rule, [basic.def.odr]
opaque-enum-declaration, [dcl.enum], [gram.dcl]
operating system dependent, [fs.conform.os]
operation
asynchronous, [exec.async.ops]
binary element-wise, [simd.general]
completion, [exec.async.ops]
element-wise, [simd.general]
stop request, [stoptoken.concepts]
unary element-wise, [simd.general]
operation state, see state, operation
operations
operator, [lex.operators], [over.oper.general]
addition, [expr.add]
additive, [expr.add]
bitwise AND, [expr.bit.and]
bitwise exclusive OR, [expr.xor]
bitwise inclusive OR, [expr.or]
class member access, [expr.ref]
comparison
conditional expression, [expr.cond]
copy assignment, see assignment operator, copy
defaulted comparison operator function, [class.compare.default]
division, [expr.mul]
equality, [expr.eq]
defaulted, [class.eq]
greater than, [expr.rel]
greater than or equal to, [expr.rel]
implementation, [over.oper.general]
inequality, [expr.eq]
left shift, [expr.shift]
less than, [expr.rel]
less than or equal to, [expr.rel]
logical AND, [expr.log.and]
logical OR, [expr.log.or]
move assignment, see assignment operator, move
multiplication, [expr.mul]
multiplicative, [expr.mul]
pointer to member, [expr.mptr.oper]
precedence of, [expr.pre]
reflection, [expr.reflect]
relational, [expr.rel]
remainder, [expr.mul]
right shift, [expr.shift]
side effects and comma, [expr.comma]
side effects and logical AND, [expr.log.and]
side effects and logical OR, [expr.log.or]
spaceship, [expr.spaceship]
subtraction, [expr.add]
three-way comparison, [expr.spaceship]
operator delete
operator delete, see also delete, [expr.new], [expr.delete]
operator function, see function, operator
class member access, [over.ref]
decrement, [over.inc]
function call, [over.call]
increment, [over.inc]
prefix unary, [over.unary]
simple assignment, [over.assign]
subscripting, [over.sub]
three-way comparison, [over.binary.general]
operator new, see also new, [expr.new]
operator overloading, see overloading, operator
operator use
scope resolution, [class.static.data]
operator-function-id, [over.oper.general], [gram.over]
operator-or-punctuator, [lex.operators], [gram.lex]
operators
built-in, [expr.pre]
optimization of temporary, see temporary, elimination of
optional object, [optional.general]
order of evaluation in expression, see expression, order of evaluation of
order of execution
base class constructor, [class.default.ctor]
base class destructor, [class.dtor]
constructor and array, [class.init.general]
constructor and static data members, [class.expl.init]
destructor, [class.dtor]
destructor and array, [class.dtor]
member constructor, [class.default.ctor]
member destructor, [class.dtor]
ordering
function template partial, see template, function, partial ordering
ordinary character type, see type, ordinary character
ordinary literal encoding, see encoding, ordinary literal
over-aligned type, see type, over-aligned
overflow, [expr.pre]
undefined, [expr.pre]
overload resolution, [over.pre]
overloaded function, see overloading
overloaded operator, see overloading, operator
inheritance of, [over.oper.general]
overloading, [dcl.fct], [class.name], [over], [temp.over.link]
address of overloaded function, [over.over]
assignment operator, [over.assign]
binary operator, [over.binary.general]
built-in operators and, [over.built]
candidate functions, [over.match.funcs.general]
decrement operator, [over.inc]
example of, [over.pre]
function call operator, [over.call]
increment operator, [over.inc]
member access operator, [over.ref]
resolution, [over.match.general]
best viable function, [over.match.best.general]
better viable function, [over.match.best.general]
function call syntax, [over.match.call.general]
function template, [temp.over]
implicit conversions and, [over.best.ics.general]
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
owning

P

pack, [temp.variadic]
unexpanded, [temp.variadic]
pack expansion, [temp.variadic]
pack-index-expression, [expr.prim.pack.index], [gram.expr]
pack-index-specifier, [dcl.type.pack.index], [gram.dcl]
padding bits, [basic.types.general]
padding width, see width, padding
pair
tuple interface to, [pairs.general]
parallel algorithm, [algorithms.parallel.defns]
parallel forward progress guarantees, [intro.progress]
parameter, [defns.parameter], [defns.parameter.macro], [defns.parameter.templ]
catch clause, [defns.parameter]
explicit object, [dcl.fct]
function-like macro, [defns.parameter.macro]
non-object, [dcl.fct]
object, [dcl.fct]
reference, [dcl.ref]
void, [dcl.fct]
parameter declaration, [basic.def]
parameter list
parameter mapping, [temp.constr.atomic]
parameter-declaration, [dcl.fct], [gram.dcl]
parameter-declaration-clause, [dcl.fct], [gram.dcl]
parameter-declaration-list, [dcl.fct], [gram.dcl]
parameter-type-list, [dcl.fct]
parameterized type, see template
parameters-and-qualifiers, [dcl.decl.general], [gram.dcl]
parent directory, [fs.general]
parent operation, see operation, parent
parent scope, see scope, parent
past-the-end iterator, see iterator, past-the-end
path, [fs.class.path.general]
normalization, [fs.path.generic]
path equality, [fs.path.nonmember]
path-format-spec, [fs.path.fmtr.funcs]
pathname resolution, [fs.class.path.general]
perfect forwarding call wrapper, see call wrapper, perfect forwarding
permissible completion, see completion, permissible
permissible types, see types, permissible
phase completion step, [thread.barrier.class]
phase synchronization point, see barrier, phase synchronization point
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]
pipeable sender adaptor closure object, see sender adaptor closure object, pipeable
pipeable sender adaptor object, see sender adaptor object, pipeable
placeholder type deduction, [dcl.type.auto.deduct]
placeholder-type-specifier, [dcl.spec.auto.general], [gram.dcl]
placeholders
freestanding item, [func.bind.place]
placement new-expression, see new-expression, placement
plain lock-free atomic operation, [support.signal]
plain-string-literal, [lex.string], [gram.lex]
point, [basic.compound]
synthesized, [expr.const]
point of
macro definition, see macro, point of definition
macro import, see macro, point of import
macro undefinition, see macro, point of undefinition
pointer, see also void*
composite pointer type, [expr.type]
strict total order, [defns.order.ptr]
pointer literal, see literal, pointer
pointer past the end of, [basic.compound]
pointer to, [basic.compound]
pointer-interconvertible, [basic.compound]
pointer-literal, [lex.nullptr], [gram.lex]
pointer-to-member, [basic.compound]
Poisson distributions, [rand.dist.pois]
polymorphic class, see class, polymorphic
pool resource classes, [mem.res.pool.overview]
POSIX, [library.general]
extended regular expressions, [re.synopt]
regular expressions, [re.synopt]
possibly-reclaimable, [saferecl.hp.general]
postcondition assertion, see assertion, postcondition
postcondition-specifier, [dcl.contract.func], [gram.dcl]
postfix ++, [expr.post.incr]
postfix ++ and --
overloading, [over.inc]
postfix --, [expr.post.incr]
postfix-expression, [expr.post.general], [gram.expr]
potential results, [basic.def.odr]
potentially concurrent, [intro.races]
potentially conflict, [basic.scope.scope]
potentially constant evaluated, [expr.const]
potentially evaluated, [basic.def.odr]
potentially invoked, [class.dtor]
potentially non-unique object, see object, potentially non-unique
potentially usable in constant expressions, [expr.const]
potentially-constant, [expr.const]
potentially-evaluated subexpression, see subexpression, potentially-evaluated
potentially-overlapping subobject, [intro.object]
potentially-throwing
exception specification, [except.spec]
expression, [except.spec]
pp-balanced-token, [cpp.pre], [gram.cpp]
pp-balanced-token-seq, [cpp.pre], [gram.cpp]
pp-global-module-fragment, [cpp.pre], [gram.cpp]
pp-module-name, [cpp.module]
pp-module-name-qualifier, [cpp.module]
pp-module-partition, [cpp.module]
pp-private-module-fragment, [cpp.pre], [gram.cpp]
pp-tokens, [cpp.pre], [gram.cpp]
preallocated backend storage for a proxy, [exec.par.scheduler]
precedence of operator, see operator, precedence of
precondition assertion, see assertion, precondition
precondition-specifier, [dcl.contract.func], [gram.dcl]
predicate
contract-assertion, [basic.contract.general]
preferred-separator, [fs.path.generic]
prefix
prefix ++, [expr.pre.incr]
prefix ++ and --
overloading, [over.inc]
prefix --, [expr.pre.incr]
prefix unary operator function, see operator function, prefix unary
preprocessing, [cpp.pre]
preprocessing directive, [cpp], [cpp.pre]
conditional inclusion, [cpp.cond]
diagnostic, [cpp.error]
embed a resource, [cpp.embed]
header inclusion, [cpp.include]
import, [cpp.import]
line control, [cpp.line]
macro replacement, see macro, replacement
module, [cpp.module]
pragma, [cpp.pragma]
source-file inclusion, [cpp.include]
warning, [cpp.error]
preprocessing translation unit, see translation unit, preprocessing
preprocessing-file, [cpp.pre], [gram.cpp]
preprocessing-op-or-punc, [lex.operators], [gram.lex]
preprocessing-operator, [lex.operators], [gram.lex]
preprocessing-token, [lex.pptoken], [gram.lex]
primary equivalence class, [defns.regex.primary.equivalence.class]
primary module interface unit, [module.unit]
primary template, see template, primary
primary-expression, [expr.prim.grammar], [gram.expr]
private-module-fragment, [module.private.frag], [gram.module]
produce, [expr.const]
program, [basic.link], [basic.link]
ill-formed, [defns.ill.formed]
termination, [basic.start.term]
program execution, [intro.abstract], [intro.execution]
abstract machine, [intro.abstract]
as-if rule, see as-if rule
program semantics
affected by the existence of a variable or function definition, [temp.inst]
projection, [defns.projection]
promise object, [dcl.fct.def.coroutine]
promise type, see coroutine, promise type
promoted integral type, [over.built]
promotion
bool to int, [conv.prom]
default argument promotion, [expr.call]
floating-point, [conv.fpprom]
integral, [conv.prom]
prospective destructor, see destructor, prospective
protection epoch, see epoch, protection
prototype parameter
provides storage, [intro.object]
proxy, [exec.par.scheduler]
bulk chunked, [exec.par.scheduler]
bulk unchunked, [exec.par.scheduler]
prvalue, [basic.lval]
pseudo-destructor, [expr.prim.id.dtor]
ptr-abstract-declarator, [dcl.name], [gram.dcl]
ptrdiff_t, [expr.add]
punctuator, [lex.operators]
purview
global module, [module.unit]
module unit, [module.unit]
named module, [module.unit]

Q

q-char-sequence, [lex.header], [gram.lex]
qualification
qualification-combined type, see type, qualification-combined
qualification-decomposition, [conv.qual]
qualified name, see name, qualified
qualified-namespace-specifier, [namespace.alias], [gram.dcl]
queryable object, see object, queryable

R

r-char-sequence, [lex.string], [gram.lex]
random number distribution
requirements, [rand.req.dist]
random number distributions
Bernoulli, [rand.dist.bern]
random number engine
requirements, [rand.req.eng]
with predefined parameters, [rand.predef]
random number engine adaptor
with predefined parameters, [rand.predef]
random number generation, [rand.general]
distributions, [rand.dist]
predefined engines and adaptors, [rand.predef]
requirements, [rand.req]
synopsis, [rand.synopsis]
utilities, [rand.util]
random number generator, see uniform random bit generator
range, [iterator.requirements.general]
counted, [iterator.requirements.general], [range.counted]
range adaptor closure object, see object, range adaptor closure
range adaptor object, see object, range adaptor
rank index, [mdspan.overview]
raw string literal, [lex.string]
rcu-protectable, [saferecl.rcu.general]
reachable
declaration, [module.reach]
necessarily
translation unit, [module.reach]
translation unit, [module.reach]
reachable from, [iterator.requirements.general]
declaration, [module.reach]
reference, [basic.compound]
assignment to, [expr.assign]
call by, [expr.call]
forwarding, [temp.deduct.call]
null, [dcl.ref]
reference collapsing, [dcl.ref]
reference lifetime, [basic.life]
reference-compatible, [dcl.init.ref]
references
normative, [intro.refs]
reflect-expression, [expr.reflect], [gram.expr]
reflection, [basic.fundamental]
reflection operator, see operator, reflection
reflection-name, [expr.reflect], [gram.expr]
region of RCU protection, [saferecl.rcu.general]
register storage class, [diff.cpp14.dcl.dcl]
registered character encoding, see encoding, registered character
registration
stoppable callback, [stoptoken.concepts]
regular expression, [re]
grammar, [re.grammar]
requirements, [re.req]
regular expression traits, [re.grammar]
requirements, [re.req], [re.traits]
transform_primary, [re.req], [re.grammar]
reified object, see object, reified
relational operator function, see operator function, relational
relational-expression, [expr.rel], [gram.expr]
relationship
direct base class, [class.derived.general]
relative path, see path, relative
relative-path, [fs.path.generic]
release sequence, [intro.races]
remainder operator, see operator, remainder
remote time zone database, [time.zone.db.remote]
replaceable
function, see function, replaceable
replacement
replacement body, see body, replacement
replacement field
replacement function, see function, replacement
replacement-list, [cpp.pre], [gram.cpp]
representation
represents the address, [basic.compound]
requirement
requirement-body, [expr.prim.req.general], [gram.expr]
requirement-parameter-list, [expr.prim.req.general], [gram.expr]
requirements, [structure.requirements]
container, [container.requirements], [unord.req.general], [array.overview], [array.cons], [re.results.general]
not required for unordered associated containers, [unord.req.general]
random number distribution, [rand.req.dist]
random number engine, [rand.req.eng]
regular expression traits, [re.req], [re.traits]
seed sequence, [rand.req.seedseq]
uniform random bit generator, [rand.req.urng]
unordered associative container, [unord.req.general]
requires-clause, [temp.pre], [gram.temp]
requires-expression, [expr.prim.req.general], [gram.expr]
rescanning and replacement, see macro, rescanning and replacement
reserved block, see block, reserved
reserved identifier, [lex.name]
resolution, see overloading, resolution
resource
execution, [exec.async.ops]
resource-count, [cpp.embed.gen]
restriction, [res.on.arguments], [res.on.macro.definitions], [res.on.exception.handling]
address of bit-field, [class.bit]
anonymous union, [class.union.anon]
bit-field, [class.bit]
destructor, [class.dtor]
extern, [dcl.stc]
local class, [class.local]
operator overloading, [over.oper.general]
overloading, [over.oper.general]
pointer to bit-field, [class.bit]
reference, [dcl.ref]
static, [dcl.stc]
static member local class, [class.local]
result
glvalue, [basic.lval]
prvalue, [basic.lval]
result binding, [dcl.contract.res]
result object, [basic.lval]
result-name-introducer, [dcl.contract.res], [gram.dcl]
return, [lex.key], [basic.fundamental], [basic.start.main], [conv.general], [expr.prim.lambda.general], [expr.call], [stmt.jump.general], [stmt.return], [except.pre], [except.ctor], [except.handle], [gram.stmt]
and handler, [except.pre]
and try block, [except.pre]
constructor and, [stmt.return]
reference and, [dcl.init.ref]
return statement, see return
return type, [dcl.fct]
covariant, [class.virtual]
return-type-requirement, [expr.prim.req.compound], [gram.expr]
reversible container, see container, reversible
rewritten candidate, [over.match.oper]
right shift operator, see operator, right shift
root-directory, [fs.path.generic]
rounding, [conv.fpint]
rvalue, [basic.lval]
lvalue conversion to, see conversion, lvalue-to-rvalue, [diff.expr]
rvalue reference, [dcl.ref]

S

s-char-sequence, [lex.string], [gram.lex]
sampling distributions, [rand.dist.samp]
sb-identifier, [dcl.pre], [gram.dcl]
sb-identifier-list, [dcl.pre], [gram.dcl]
scalar type, see type, scalar
schedule sender, [exec.async.ops]
schedule-expression, [exec.async.ops]
scheduler, [exec.async.ops]
scope, [intro.scope], [basic.pre], [basic.scope], [basic.scope.scope], [dcl.pre]
anonymous union at namespace, [class.union.anon]
contract-assertion, [basic.scope.contract]
declarations and, see locus
destructor and exit from, [stmt.jump.general]
enumeration, [basic.scope.enum]
function parameter, [basic.scope.param]
function prototype, see scope, function parameter
iteration-statement, [stmt.iter.general]
macro definition, see macro, scope of definition
name lookup and, see lookup, name
search, [class.member.lookup]
selection-statement, [stmt.select.general]
template parameter, [basic.scope.temp]
scope resolution operator, see operator, scope resolution
scoped enumeration, see enumeration, scoped
search, [class.member.lookup]
bracket resource, [cpp.embed.gen]
quote resource, [cpp.embed.gen]
source file, [cpp.include]
secondary comparison operator, [class.compare.secondary]
seed sequence, [rand.req.seedseq]
requirements, [rand.req.seedseq]
selected destructor, see destructor, selected
selected elements, see elements, selected
selected indices, see indices, selected
selection-statement, [stmt.select.general], [gram.stmt]
semantics
class member, [expr.ref]
sender, [exec.async.ops]
non-dependent, [exec.async.ops]
sender adaptor, [exec.async.ops]
sender adaptor closure object
sender adaptor object
sender consumer, [exec.async.ops]
sender factory, [exec.async.ops]
separate compilation, see compilation, separate
separate translation, see compilation, separate
sequence
characteristic, [expr.const]
sorted
with respect to a comparator, [alg.sorting.general]
with respect to a comparator and projection, [alg.sorting.general]
sequence container, see container, sequence
sequenced after, [intro.execution]
sequenced before, [intro.execution]
sequencing operator, see operator, comma
shared state, see future, shared state
shift operator
shift-expression, [expr.shift], [gram.expr]
short, [lex.key], [basic.fundamental], [conv.rank], [dcl.type.simple], [gram.dcl]
typedef and, [dcl.spec.general]
side effects, [intro.abstract], [class.temporary], [intro.execution], [intro.execution], [intro.races], [stmt.expr], [class.base.init], [class.copy.elision], [cpp.replace.general], [res.on.data.races]
signal-safe
evaluation, see evaluation, signal-safe
forward, [forward]
initializer_list functions, [support.initlist.general]
memmove, [cstring.syn]
move, [forward]
move_if_noexcept, [forward]
numeric_limits members, [numeric.limits.members]
signature, [defns.signature], [defns.signature.friend], [defns.signature.templ], [defns.signature.templ.friend], [defns.signature.spec], [defns.signature.member], [defns.signature.member.templ], [defns.signature.member.spec], [defns.signature.template.head]
corresponding, [basic.scope.scope]
signed, [lex.key], [basic.fundamental], [conv.rank], [dcl.type.simple], [gram.dcl]
typedef and, [dcl.spec.general]
signed integer representation
signed integer type, see type, signed integer
signed-integer-class type, see type, signed-integer-class
signed-integer-like, [iterator.concept.winc]
significand, [lex.fcon]
similar types, [conv.qual]
simple assignment operator function, see operator function, simple assignment
simple call wrapper, [func.require]
simple-declaration, [dcl.pre], [gram.dcl]
simple-escape-sequence, [lex.ccon], [gram.lex]
simple-escape-sequence-char, [lex.ccon], [gram.lex]
simple-hexadecimal-digit-sequence, [lex.universal.char], [gram.lex]
simple-octal-digit-sequence, [lex.ccon], [gram.lex]
simple-requirement, [expr.prim.req.simple], [gram.expr]
simple-template-id, [temp.names], [gram.temp]
simple-type-specifier, [dcl.type.simple], [gram.dcl]
size of a multidimensional index space, [mdspan.overview]
size-suffix, [lex.icon], [gram.lex]
slice type
sliceable layout mapping requirements, [mdspan.sub.map.sliceable]
smart pointers, [util.smartptr.weak.bad]
source file character, see character, source file
source line
logical, [lex.phases]
special member function, see constructor, see assignment operator, see destructor
eligible, [special]
special-declaration, [dcl.pre], [gram.dcl]
specialization, [temp.spec.general]
class template partial, [temp.spec.partial.general]
declared, [temp.inst]
program-defined, [defns.prog.def.spec]
template explicit, [temp.expl.spec]
specification
linkage, [dcl.link]
extern, [dcl.link]
implementation-defined, [dcl.link]
nesting, [dcl.link]
template argument, [temp.arg.explicit]
specifications
C standard library exception, [res.on.exception.handling]
specifier, [dcl.spec.general]
consteval, [dcl.constexpr]
constexpr, [dcl.constexpr]
constinit, [dcl.constinit]
cv-qualifier, [dcl.type.cv]
declaration, [dcl.spec.general]
explicit, [dcl.fct.spec]
function, [dcl.fct.spec]
inline, [dcl.inline]
storage class, [dcl.stc]
type, see type specifier
typedef, [dcl.typedef]
specifier access, see access specifier
spherical harmonics
splice-expression, [expr.prim.splice], [gram.expr]
splice-scope-specifier, [expr.prim.id.qual], [gram.expr]
splice-specialization-specifier, [basic.splice], [gram.basic]
splice-specifier, [basic.splice], [gram.basic]
splice-type-specifier, [dcl.type.splice], [gram.dcl]
stack unwinding, [except.ctor]
stacktrace entry, [stacktrace.general]
standard
structure of, [intro.structure]
standard integer type, see type, standard integer
standard signed integer type, see type, standard signed integer
standard unsigned integer type, see type, standard unsigned integer
standard-layout class, see class, standard-layout
standard-layout struct, see struct, standard-layout
standard-layout type, see type, standard-layout
standard-layout union, see union, standard-layout
start
startup
state, [any.class.general]
operation, [exec.async.ops]
state entity, [func.def]
statement, [stmt]
compound, [stmt.block]
consteval if, [stmt.if]
continue in for, [stmt.for]
control-flow-limited, [stmt.label]
declaration, [stmt.dcl]
declaration in switch, [stmt.switch]
declaration in while, [stmt.while]
enclosed by, [stmt.pre]
enclosing, [stmt.pre]
expansion, [stmt.expand]
expression, [stmt.expr]
iteration, [stmt.iter]
labeled, [stmt.label]
range based for, [stmt.ranged]
selection, [stmt.select]
statement-seq, [stmt.block], [gram.stmt]
static, [lex.key], [basic.link], [basic.stc.static], [basic.stc.auto], [basic.start.main], [expr.prim.lambda.general], [expr.prim.lambda.closure], [dcl.spec.general], [dcl.stc], [dcl.inline], [dcl.meaning.general], [dcl.fct], [class.mem.general], [class.static.general], [class.free], [class.union.anon], [numeric.limits.general], [atomics.types.operations], [gram.expr], [gram.dcl], [diff.dcl]
destruction of local, [stmt.dcl]
linkage of, [basic.link], [dcl.stc]
static data member, see data member, static
static extent, see extent, static
static initialization, see initialization, static
static member, see member, static
static member function, see member function, static
static storage duration, see storage duration, static
static type, see type, static
static_assert, [lex.key], [dcl.pre], [gram.dcl], [diff.cpp03.lex]
failed, [dcl.pre]
static_assert-declaration, [dcl.pre], [gram.dcl]
static_assert-message, [dcl.pre], [gram.dcl]
STATICALLY-WIDEN, [character.seq.general]
__STDC_EMBED_EMPTY__, [cpp.predefined]
__STDC_EMBED_FOUND__, [cpp.predefined]
__STDC_EMBED_NOT_FOUND__, [cpp.predefined]
<stdnoreturn.h>
stop request operation, see operation, stop request
stoppable callback deregistration, see callback deregistration, stoppable
stoppable callback registration, see registration, stoppable callback
stopped completion, see completion, stopped
storage
reachable through a pointer value, [basic.compound]
storage class, [basic.pre]
storage duration, [basic.stc.general], [basic.stc.general]
class member, [basic.stc.general]
local object, [basic.stc.auto]
storage management, see new, see delete
storage-class-specifier, [dcl.stc], [gram.dcl]
string
formatted as escaped, [format.string.escaped]
null terminator, [basic.string.general]
null-terminated byte, see ntbs
null-terminated character type, [defns.ntcts]
null-terminated multibyte, see ntmbs
type of, [lex.string]
string literal, see literal, string
string-literal, [lex.string], [gram.lex]
stringize, see # operator
stringizing argument, [cpp.stringize]
strongly happens before, [intro.races]
<strstream>
struct
standard-layout, [class.prop]
structural type, see type, structural
structure tag, see class name
structured binding, [dcl.struct.bind]
structured binding declaration, [dcl.pre], [dcl.struct.bind]
structured binding pack, [temp.variadic]
structured binding size, [dcl.struct.bind]
structured-binding-declaration, [dcl.pre], [gram.dcl]
sub-expression
regular expression, [defns.regex.subexpression]
subexpression, [intro.execution]
potentially-evaluated, [intro.execution]
submdspan
canonical index type for IndexType, [mdspan.sub.overview]
canonical slice type for IndexType, [mdspan.sub.overview]
slice range of s for the
slice type for IndexType, [mdspan.sub.overview]
valid slice for the
valid slice type for the
subnormal number, see number, subnormal
subobject, see also object model, [intro.object], [intro.object]
corresponding direct, [intro.object]
initialized, known to be, [except.ctor]
subscript expression, see expression, subscript
subscripting operator
overloaded, [over.sub]
subscripting operator function, see operator function, subscripting
subsequence rule
overloading, [over.ics.rank]
substatement, [stmt.pre]
substitutability, [cmp.categories.pre]
subsumption
compatible for, [temp.constr.fold]
eligible for, [temp.constr.order]
subtraction operator, see operator, subtraction
suffix
suitable created object, see object, suitable created
summary
compatibility with C, [diff.iso.general]
compatibility with ISO C++ 2003, [diff.cpp03.general]
compatibility with ISO C++ 2011, [diff.cpp11.general]
compatibility with ISO C++ 2014, [diff.cpp14.general]
compatibility with ISO C++ 2017, [diff.cpp17.general]
compatibility with ISO C++ 2020, [diff.cpp20.general]
compatibility with ISO C++ 2023, [diff.cpp23.general]
surrogate call function, [over.call.object]
suspend point, [expr.await]
swappable with, [swappable.requirements]
switch, [lex.key], [conv.general], [stmt.pre], [stmt.label], [stmt.select.general], [stmt.switch], [stmt.break], [stmt.dcl], [dcl.attr.fallthrough], [gram.stmt], [implimits]
and handler, [except.pre]
and try block, [except.pre]
synchronize with, [intro.races]
syntax
class member, [expr.ref]
synthesized point, see point, synthesized
synthesized three-way comparison, see three-way comparison, synthesized

T

tag
completion, [exec.async.ops]
target constructor, see constructor, target
target object, [func.def]
target scope, see scope, target
template, [temp], [temp.pre]
deducible arguments of, [over.match.class.deduct]
function, [temp.fct.spec.general]
abbreviated, [dcl.fct]
corresponding object parameter, [basic.scope.scope]
corresponding signature, [basic.scope.scope]
key parameter of, [concept.booleantestable]
partial ordering, [temp.func.order]
member function, [temp.mem.func]
static data member, [temp.pre]
variable, [temp.pre]
template argument
default, [temp.param]
template instantiation, [temp.spec.general]
template name
linkage of, [temp.pre]
template parameter, [basic.def]
concept, [temp.param]
constant, [temp.param]
execution policy, [algorithms.parallel.defns]
type template, [temp.param]
variable template, [temp.param]
template parameter pack, [temp.variadic]
template parameter scope, see scope, template parameter
template parameters
template, [temp.param]
template template parameters, see template parameters, template
template-argument, [temp.names], [gram.temp]
template-argument-equivalent, [temp.type]
template-argument-list, [temp.names], [gram.temp]
template-argument-name, [temp.names], [gram.temp]
template-declaration, [temp.pre], [gram.temp]
template-head, [temp.pre], [gram.temp]
template-id, [temp.names], [gram.temp]
template-name, [temp.names], [gram.temp]
template-parameter, [temp.param], [gram.temp]
template-parameter-list, [temp.pre], [gram.temp]
templated, [temp.pre]
templated class, see class, templated
templated function, see function, templated
templated variable, see variable, templated
temporary, [class.temporary]
constructor for, [class.temporary]
destruction of, [class.temporary]
destructor for, [class.temporary]
implementation-defined generation of, [class.temporary]
order of destruction of, [class.temporary]
temporary object, see object, temporary
terminal name, see name, terminal
terminate, [except.terminate]
terminating semantics|seecontract evaluation semanticsterminating, [basic.contract.eval]
termination
terminology
text representation, [thread.thread.id]
text-line, [cpp.pre], [gram.cpp]
thread of execution, [intro.multithread.general]
thread storage duration, see storage duration, thread
threads
<threads.h>
three-way comparison
synthesized, [class.spaceship]
three-way comparison operator function, see operator function, three-way comparison
throw-expression, [expr.throw], [gram.expr]
to-unsigned-like, [ranges.syn]
token, [lex.token]
alternative, [lex.digraph]
directive-introducing, [cpp.pre]
preprocessing, [lex.pptoken]
trailing requires-clause, see requires-clause, trailing
trailing-return-type, [dcl.decl.general], [gram.dcl]
transform_primary
regular expression traits, [re.req], [re.grammar]
translation
phases, [lex.phases]
separate, see compilation, separate
translation character set, see character set, translation
translation unit, [lex.phases], [basic.link]
name and, [basic.pre]
preprocessing, [lex.separate]
translation-unit, [basic.link], [gram.basic]
transparently replaceable, [basic.life]
triangle
trigraph sequence, [diff.cpp14.lex]
trivial class, see class, trivial
trivial infinite loop, see loop, trivial infinite
trivial type, see type, trivial
trivially copyable class, see class, trivially copyable
trivially copyable type, see type, trivially copyable
trivially empty iteration statement, see iteration statement, trivially empty
truncation, [conv.fpint]
TU-local
entity, [basic.link]
value or object, [basic.link]
tuple
and pair, [pairs.general]
type, [basic.pre], [basic.types.general]
allocated, [expr.new]
arithmetic, [basic.fundamental]
promoted, [over.built]
callable, [func.def]
character container, [defns.character.container]
class and, [class.pre]
data-parallel, [simd.general]
destination, [dcl.init.general]
example of incomplete, [basic.types.general]
extended integer, [basic.fundamental]
extended signed integer, [basic.fundamental]
extended unsigned integer, [basic.fundamental]
floating-point, [basic.fundamental]
fundamental, [basic.fundamental]
implementation-defined sizeof, [basic.fundamental]
implicit-lifetime, [basic.types.general]
incompletely-defined object, [basic.types.general]
integral, [basic.fundamental]
promoted, [over.built]
layout-compatible, [basic.types.general]
long double, [basic.fundamental]
narrow character, [basic.fundamental]
ordinary character, [basic.fundamental]
over-aligned, [basic.align]
polymorphic, [class.virtual]
program-defined, [defns.prog.def.type]
qualification-combined, [conv.qual]
referenceable, [defns.referenceable]
signed char, [basic.fundamental]
signed integer, [basic.fundamental]
signed-integer-class, [iterator.concept.winc]
similar, see similar types
standard integer, [basic.fundamental]
standard signed integer, [basic.fundamental]
standard unsigned integer, [basic.fundamental]
standard-layout, [basic.types.general]
structural, [temp.param]
underlying, [basic.fundamental]
enumeration, [conv.prom], [dcl.enum]
fixed, [dcl.enum]
unsigned char, [basic.fundamental]
unsigned int, [basic.fundamental]
unsigned integer, [basic.fundamental]
unsigned long, [basic.fundamental]
unsigned long, [basic.fundamental]
unsigned short, [basic.fundamental]
unsigned-integer-class, [iterator.concept.winc]
vectorizable, [simd.general]
type alias, see alias, type
type checking
argument, [expr.call]
type concept, see concept, type
type conversion, explicit, see casting
type generator, see template
type name, [dcl.name]
type specifier
decltype(auto), [dcl.spec.auto.general]
volatile, [dcl.type.cv]
type template parameter, see template parameter, type
type template template parameter, see template parameter, type template
type-accessible, [basic.lval]
type-constraint, [temp.param], [gram.temp]
type-only
context, see context, type-only
lookup, see lookup, type-only
type-parameter, [temp.param], [gram.temp]
type-parameter-key, [temp.param], [gram.temp]
type-specifier-seq, [dcl.type.general], [gram.dcl]
type-tt-parameter, [temp.param], [gram.temp]
type-tt-parameter-default, [temp.param], [gram.temp]
type_info, [expr.typeid]
typedef
function, [dcl.fct]
typedef name for linkage purposes, [dcl.typedef]
typedef-name, [dcl.typedef], [gram.dcl]
typeid, [lex.key], [basic.def.odr], [basic.life], [basic.fundamental], [expr.prim.lambda.capture], [expr.prim.splice], [expr.post.general], [expr.typeid], [expr.const], [temp.dep.expr], [temp.dep.constexpr], [except.throw], [except.spec], [gram.expr], [diff.cpp03.expr]
construction and, [class.cdtor]
destruction and, [class.cdtor]
typename-specifier, [temp.res.general], [gram.temp]
types
implementation-defined, [type.descriptions.general]

U

ud-suffix, [lex.ext], [gram.lex]
unary element-wise operation, see operation, unary element-wise
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]
uncaught exception, [except.throw]
undefined behavior, see behavior, undefined
underlying constant, see constant, underlying
underlying entity, see entity, underlying
underlying type, see type, underlying
unevaluated operand, [expr.context]
unevaluated-string, [lex.string.uneval], [gram.lex]
uniform distributions, [rand.dist.uni]
uniform random bit generator
requirements, [rand.req.urng]
union, [class.union.general]
standard-layout, [class.prop]
union, [lex.key], [basic.compound], [dcl.type.elab], [class.pre], [class.prop], [class.union.general], [class.union.anon], [class.access.general], [gram.class], [diff.dcl], [diff.class]
global anonymous, [class.union.anon]
union-like class, see class, union-like
unique pointer, [unique.ptr.general]
unit
unit-stride slice type, see slice type, unit-stride
units
field width, [format.string.std]
universal-character-name, [lex.universal.char], [gram.lex]
unnamed bit-field, see bit-field, unnamed
unnamed class, see class, unnamed
unnamed-namespace-definition, [namespace.def.general], [gram.dcl]
unordered associative container, see container, unordered associative
unordered associative containers, [unord.req.general]
equality function, [unord.req.general]
exception safety, [unord.req.except]
hash function, [unord.req.general]
iterator invalidation, [unord.req.general]
lack of comparison functions, [unord.req.general]
unordered_map
element access, [unord.map.elem]
unordered_multimap
equivalent keys, [unord.multimap.overview]
unordered_multiset
equivalent keys, [unord.multiset.overview]
unordered_set
unqualified name, see name, unqualified
unscoped enumeration, see enumeration, unscoped
unsequenced, [intro.execution]
unsigned, [lex.key], [intro.object], [basic.types.general], [basic.fundamental], [conv.rank], [basic.lval], [conv.prom], [expr.new], [dcl.type.simple], [dcl.init.string], [format.parse.ctx], [gram.dcl], [diff.cpp20.dcl]
typedef and, [dcl.spec.general]
unsigned integer type, see type, unsigned integer
unsigned-integer-class type, see type, unsigned-integer-class
unsigned-integer-like, [iterator.concept.winc]
unsigned-suffix, [lex.icon], [gram.lex]
unspecified behavior, see behavior, unspecified
unwinding
upper triangle, see triangle, upper
upstream allocator, [mem.res.pool.overview]
usable
binary operator expression, [class.compare.default]
usable candidate, see candidate, usable
usable in constant expressions, [expr.const]
user-defined conversion sequence, see conversion sequence, user-defined
user-defined literal, see literal, user-defined
overloaded, [over.literal]
user-defined-character-literal, [lex.ext], [gram.lex]
user-defined-floating-point-literal, [lex.ext], [gram.lex]
user-defined-integer-literal, [lex.ext], [gram.lex]
user-defined-literal, [lex.ext], [gram.lex]
user-defined-string-literal, [lex.ext], [gram.lex]
user-provided, [dcl.fct.def.default]
uses-allocator construction, [allocator.uses.construction]
using-declaration, [namespace.udecl]
using-declaration, [namespace.udecl], [gram.dcl]
using-declarator, [namespace.udecl], [gram.dcl]
using-declarator-list, [namespace.udecl], [gram.dcl]
using-directive, [namespace.udir]
using-directive, [namespace.udir], [gram.dcl]
using-enum-declaration, [enum.udecl], [gram.dcl]
using-enum-declarator, [enum.udecl], [gram.dcl]
usual arithmetic conversions, see conversion, usual arithmetic
usual deallocation function, [basic.stc.dynamic.deallocation]

V

va-opt-replacement, [cpp.subst], [gram.cpp]
vacuous initialization, see initialization, vacuous
valid but unspecified state, [defns.valid]
valid contained type
valid in the context of, [basic.compound]
valid range, see range, valid
value, [basic.types.general]
call by, [expr.call]
denormalized, see number, subnormal
erroneous, [basic.indet]
indeterminate, [basic.indet]
invalid pointer, [basic.compound]
null member pointer, [conv.mem]
undefined unrepresentable integral, [conv.fpint]
valid in the context of an evaluation, [basic.compound]
value category, [basic.lval]
value completion, see completion, value
value type, [iterator.requirements.general]
linear algebra, [linalg.reqs.val]
value-initialization, [dcl.init.general]
value-preserving, [simd.general]
valueless
indirect object, [indirect.general]
polymorphic object, [polymorphic.general]
vararg function, see function, vararg
variable, [basic.pre]
active, [stmt.dcl]
anonymous union, [class.union.anon]
decision, [stmt.pre]
function-local predefined, [dcl.fct.def.general]
indeterminate uninitialized, [dcl.init.general]
inline, [dcl.inline]
needed for constant evaluation, [expr.const]
program semantics affected by the existence of a variable definition, [temp.inst]
templated, [temp.pre]
variable arguments, [cpp.replace.general]
variable template
definition of, [temp.pre]
variable template template parameter, see template parameter, variable template
variable-tt-parameter, [temp.param], [gram.temp]
variant member, [class.union.anon]
vectorizable type, see type, vectorizable
vectorization-unsafe, [algorithms.parallel.defns]
virt-specifier-seq, [class.mem.general], [gram.class]
virtual base class, see base class, virtual
virtual function, see function, virtual
virtual function call, [class.virtual]
constructor and, [class.cdtor]
destructor and, [class.cdtor]
undefined pure, [class.abstract]
visible side effects, see side effects, visible
void, [lex.key], [basic.def.odr], [basic.life], [basic.stc.dynamic.allocation], [basic.stc.dynamic.deallocation], [class.temporary], [basic.types.general], [basic.fundamental], [basic.compound], [basic.type.qualifier], [basic.lval], [expr.type], [conv.ptr], [conv.mem], [expr.call], [expr.type.conv], [expr.ref], [expr.dynamic.cast], [expr.static.cast], [expr.reinterpret.cast], [expr.unary.op], [expr.await], [expr.new], [expr.delete], [expr.rel], [expr.cond], [expr.throw], [expr.const], [stmt.return], [stmt.return.coroutine], [dcl.type.simple], [dcl.spec.auto.general], [dcl.type.auto.deduct], [dcl.ref], [dcl.mptr], [dcl.array], [dcl.fct], [dcl.contract.res], [dcl.fct.def.general], [dcl.attr.nodiscard], [class.conv.fct], [class.static.data], [over.ics.rank], [temp.param], [temp.arg.nontype], [temp.res.general], [temp.deduct.general], [temp.deduct.type], [except.throw], [except.handle], [structure.specifications], [cmp.common], [concept.swappable], [assertions.assert], [pointer.traits.functions], [util.smartptr.shared.obs], [meta.unary.cat], [meta.unary.prop], [meta.rel], [meta.trans.ptr], [meta.trans.other], [func.require], [container.reqmts], [container.alloc.reqmts], [sequence.reqmts], [associative.reqmts.general], [unord.req.general], [readable.traits], [iterator.traits], [iterator.iterators], [common.iter.types], [format.parse.ctx], [rand.req.seedseq], [rand.req.eng], [rand.req.dist], [ios.base.storage], [thread.mutex.requirements.mutex.general], [thread.sharedmutex.requirements.general], [gram.dcl], [diff.cpp17.containers], [diff.cpp03.containers], [diff.expr], [diff.stat], [depr.meta.types]
void&, [dcl.ref]
void*
volatile, [lex.key], [basic.type.qualifier], [intro.execution], [intro.races], [expr.ref], [dcl.decl.general], [meta.trans.cv], [gram.dcl], [diff.class]
constructor and, [class.ctor.general]
destructor and, [class.dtor]
implementation-defined, [dcl.type.cv]
volatile object, see object, volatile
volatile-qualified, [basic.type.qualifier]

W

waiting function, see function, waiting
weakly parallel forward progress guarantees, [intro.progress]
well-formed program, see program, well-formed
whitespace, [lex.pptoken]
wide literal encoding, see encoding, wide literal
wide-character, [lex.ccon]
wide-character set
width, [basic.fundamental], [class.bit], [simd.general]
of integer-class type, [iterator.concept.winc]
worse conversion sequence, see conversion sequence, worse

X

xvalue, [basic.lval]

Y

yield-expression, [expr.yield], [gram.expr]

Z

zero
division by undefined, [expr.pre]
remainder undefined, [expr.pre]
undefined division by, [expr.mul]
zero-initialization, [dcl.init.general]
zeta functions ζ, [sf.cmath.riemann.zeta]

Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant