Index
!
,
см
operator, logical negation
!=
,
см
operator, inequality
#
оператор
[cpp.replace]
,
[cpp.stringize]
##
оператор
[cpp.concat]
#define
,
[cpp.replace]
#elif
,
[cpp.cond]
#else
,
[cpp.cond]
#endif
,
[cpp.cond]
#error
,
см
preprocessing directives, error
#if
,
[cpp.cond]
,
[res.on.macro.definitions]
#ifdef
,
[cpp.cond]
#ifndef
,
[cpp.cond]
#include
,
[cpp.include]
,
[using.headers]
#line
,
см
preprocessing directives, line control
#pragma
,
см
preprocessing directives, pragma
#undef
,
[cpp.scope]
,
[macro.names]
%
,
см
operator, remainder
&
,
смотри
operator, address-of
,
смотри
operator, bitwise AND
,
смотри
declarator, reference
&&
,
см
operator, logical AND
()
,
смотри
operator, function call
,
смотри
declarator, function
*
,
смотри
operator, indirection
,
смотри
operator, multiplication
,
смотри
declarator, pointer
+
,
смотри
operator, unary plus
,
смотри
operator, addition
++
,
см
operator, increment
,
,
см
operator, comma
-
,
смотри
operator, unary minus
,
смотри
operator, subtraction
--
,
см
operator, decrement
->
,
см
operator, class member access
->*
,
см
operator, pointer to member
.
,
см
operator, class member access
.*
,
см
operator, pointer to member
...
,
см
ellipsis
/
,
см
operator, division
:
объявление битового поля,
[class.bit]
спецификатор метки,
[stmt.label]
::
,
см
operator, scope resolution
::*
,
см
declarator, pointer to member
<
,
см
operator, less than
шаблон и
[temp.param]
,
[temp.names]
<<
,
см
operator, left shift
<=
,
см
operator, less than or equal to
=
,
см
assignment operator
==
,
см
operator, equality
>
,
см
operator, greater than
>=
,
см
operator, greater than or equal to
>>
,
см
operator, right shift
?:
,
см
operator, conditional expression
[]
,
смотри
operator, subscripting
,
смотри
declarator, array
\
,
см
backslash character
^
,
см
operator, bitwise exclusive OR
_
,
см
character, underscore
__cplusplus
,
[cpp.predefined]
__DATE__
,
[cpp.predefined]
__FILE__
,
[cpp.predefined]
__func__
,
[dcl.fct.def.general]
__has_include
,
[cpp.cond]
__LINE__
,
[cpp.predefined]
__STDC__
,
[cpp.predefined]
__STDC_HOSTED__
,
[cpp.predefined]
__STDC_ISO_10646__
,
[cpp.predefined]
__STDC_MB_MIGHT_NEQ_WC__
,
[cpp.predefined]
__STDC_VERSION__
,
[cpp.predefined]
__STDCPP_DEFAULT_NEW_ALIGNMENT__
,
[cpp.predefined]
__STDCPP_STRICT_POINTER_SAFETY__
,
[cpp.predefined]
__STDCPP_THREADS__
,
[cpp.predefined]
__TIME__
,
[cpp.predefined]
__VA_ARGS__
,
[cpp.replace]
{}
оператор блока,
[stmt.block]
объявление класса,
[class]
определение класса,
[class]
enum
декларация
[dcl.enum]
список инициализаторов,
[dcl.init.aggr]
|
,
см
operator, bitwise inclusive OR
||
,
см
operator, logical OR
~
,
смотри
operator, ones' complement
,
смотри
destructor
0
,
Смотри также
zero, null
нулевой символ,
см.
character, null
терминатор строки,
[lex.string]
abort
,
[basic.start.term]
,
[stmt.jump]
доступ,
[defns.access]
контроль доступа,
[class.access]
анонимный
union
,
[class.union.anon]
базовый класс,
[class.access.base]
член базового класса,
[class.derived]
член класса
[expr.ref]
дефолт,
[class.access]
аргумент по умолчанию,
[class.access]
функция друга,
[class.friend]
функция-член и,
[special]
имя члена,
[class.access]
множественный доступ,
[class.paths]
вложенный класс,
[class.access.nest]
разрешение перегрузки и,
[class.member.lookup]
перегрузка и,
[over.dcl]
private
,
[class.access]
protected
,
[class.access]
,
[class.protected]
public
,
[class.access]
union
член по умолчанию,
[class]
объявление-использование и,
[namespace.udecl]
виртуальная функция,
[class.access.virt]
спецификатор доступа
[class.access.spec]
,
[class.access.base]
активный
член профсоюза
[class.union]
оператор сложения,
см.
operator, addition
адрес
[basic.compound]
,
[expr.eq]
совокупности
[dcl.init.aggr]
,
[dcl.init.aggr]
элементы
[dcl.init.aggr]
совокупная инициализация,
[dcl.init.aggr]
<algorithm>
,
[algorithm.syn]
алгоритм
стабильный
[defns.stable]
,
[algorithm.stable]
псевдоним
пространство имен,
[namespace.alias]
шаблон псевдонима,
[temp.alias]
выравнивание,
[basic.align]
расширенный,
[basic.align]
фундаментальный
[basic.align]
новый-расширенный,
[basic.align]
строже,
[basic.align]
сильнее,
[basic.align]
слабее,
[basic.align]
требование выравнивания
определяется реализацией,
[basic.align]
распределение
хранение центровки,
[expr.new]
битовое поле, определяемое реализацией,
[class.bit]
неопределенные,
[class.mem]
функции распределения,
[basic.stc.dynamic]
альтернативный токен,
см.
token, alternative
двусмысленность
член базового класса,
[class.member.lookup]
преобразование класса,
[class.member.lookup]
тип объявления,
[dcl.spec]
объявление по сравнению с приведением,
[dcl.ambig.res]
декларация против выражения,
[stmt.ambig]
объявление функции,
[dcl.init]
членский доступ,
[class.member.lookup]
перегруженная функция,
[over.match]
круглые скобки и,
[expr.new]
Поправка 1,
[extern.names]
анонимный союз
[class.union.anon]
анонимный объект объединения,
[class.union.anon]
<any>
,
[any.synop]
принадлежать
[dcl.attr.grammar]
argc
,
[basic.start.main]
аргумент
[defns.argument]
,
[defns.argument.macro]
,
[defns.argument.throw]
,
[defns.argument.templ]
,
[res.on.arguments]
,
[res.on.macro.definitions]
,
[out.of.range]
проверка доступа и дефолт,
[class.access]
привязка дефолта,
[dcl.fct.default]
оценка дефолта,
[dcl.fct.default]
пример дефолта,
[dcl.fct.default]
выражение вызова функции,
[defns.argument]
функционально-подобный макрос,
[defns.argument.macro]
перегруженный оператор и по умолчанию,
[over.oper]
ссылка,
[expr.call]
объем неисполнения обязательств,
[dcl.fct.default]
шаблон,
[temp.arg]
создание экземпляра шаблона,
[defns.argument.templ]
бросить выражение
[defns.argument.throw]
проверка типов по умолчанию,
[dcl.fct.default]
аргумент и скрытие имени
дефолт,
[dcl.fct.default]
аргумент и виртуальная функция
дефолт,
[dcl.fct.default]
список аргументов
пустой,
[dcl.fct]
Переменная,
[dcl.fct]
передача аргументов,
[expr.call]
ссылка и,
[dcl.init.ref]
подстановка аргументов,
см.
macro, argument substitution
тип аргумента
неизвестный,
[dcl.fct]
argv
,
[basic.start.main]
арифметика
указатель,
[expr.add]
unsigned
,
[basic.fundamental]
<array>
,
[array.syn]
множество
как совокупность,
[array.overview]
граница,
[dcl.array]
const
,
[basic.type.qualifier]
непрерывное хранилище,
[array.overview]
delete
,
[expr.delete]
обработчик типа,
[except.handle]
инициализации
[array.overview]
,
[array.cons]
многомерный,
[dcl.array]
new
,
[expr.new]
перегрузка и указатель против,
[over.load]
параметр типа,
[dcl.fct]
sizeof
,
[expr.sizeof]
хранение,
[dcl.array]
параметр шаблона типа,
[temp.param]
интерфейс кортежа к,
[array.tuple]
нулевой размер,
[array.zero]
размер массива
дефолт,
[dcl.array]
оператор стрелки,
см.
operator, class member access
как если бы правило,
[intro.execution]
asm
определяется реализацией,
[dcl.asm]
ассемблер
[dcl.asm]
<assert.h>
,
[using.headers]
,
[cassert.syn]
назначение
и lvalue,
[expr.ass]
преобразование по,
[expr.ass]
копия,
см
assignment operator, copy
двигайся,
смотри
assignment operator, move
,
[defns.move.assign]
ссылка,
[dcl.init.ref]
оператор присваивания
копировать,
[special]
,
[class.copy.assign]
,
[class.copy.assign]
скрытый,
[class.copy.assign]
неявно заявлено,
[class.copy.assign]
неявно определено,
[class.copy.assign]
недоступный,
[class.copy]
нетривиальный,
[class.copy.assign]
тривиальный,
[class.copy.assign]
виртуальные базы и,
[class.copy.assign]
двигаться,
[special]
,
[class.copy.assign]
,
[class.copy.assign]
скрытый,
[class.copy.assign]
неявно заявлено,
[class.copy.assign]
неявно определено,
[class.copy.assign]
недоступный,
[class.copy]
нетривиальный,
[class.copy.assign]
тривиальный,
[class.copy.assign]
перегружен,
[over.ass]
ассоциативные контейнеры
безопасность исключений,
[associative.reqmts]
требования,
[associative.reqmts]
неупорядоченный,
см.
unordered associative containers
асинхронный провайдер,
[futures.state]
асинхронный возвращаемый объект,
[futures.state]
по крайней мере, столь же специализированный, как,
см.
more specialized
atexit
,
[basic.start.term]
<atomic>
,
[atomics.syn]
атомарные операции,
см.
operation, atomic
атрибут,
[dcl.attr]
выравнивание,
[dcl.align]
несет зависимость,
[dcl.attr.depend]
устарело,
[dcl.attr.deprecated]
провалиться,
[dcl.attr.fallthrough]
может быть неиспользованным,
[dcl.attr.unused]
нодискард
[dcl.attr.nodiscard]
без возврата,
[dcl.attr.noreturn]
синтаксис и семантика,
[dcl.attr.grammar]
автоматическая продолжительность хранения,
[basic.stc.auto]
awk
,
[re.synopt]
символ обратной косой черты,
[lex.ccon]
bad_alloc
,
[expr.new]
bad_cast
,
[expr.dynamic.cast]
bad_typeid
,
[expr.typeid]
базовая характеристика,
[meta.rqmts]
базовый класс,
[class.derived]
,
[class.mi]
зависимый
[temp.dep.type]
непосредственный,
[class.derived]
косвенный,
[class.derived]
не виртуальный,
[class.mi]
перегрузка и,
[over.dcl]
private
,
[class.access.base]
protected
,
[class.access.base]
public
,
[class.access.base]
виртуальный
[class.mi]
подобъект базового класса,
[intro.object]
поведение
условно-поддерживается,
[defns.cond.supp]
,
[intro.compliance]
по умолчанию,
[defns.default.behavior.impl]
,
[defns.default.behavior.func]
,
[structure.specifications]
определяется реализацией
[defns.impl.defined]
,
[intro.execution]
зависит от региона,
[defns.locale.specific]
наблюдаемыми
[intro.execution]
,
[intro.execution]
при получении сигнала,
[intro.execution]
требуется,
[defns.required.behavior]
,
[structure.specifications]
неопределенный,
[defns.undefined]
,
[intro.compliance]
,
[intro.execution]
,
[istreambuf.iterator]
неопределенные,
[defns.unspecified]
,
[intro.execution]
Бен,
[over.dcl]
Распределения Бернулли,
[rand.dist.bern]
bernoulli_distribution
дискретная функция вероятности,
[rand.dist.bern.bernoulli]
Функции Бесселя
I
ν
,
[sf.cmath.cyl_bessel_i]
j
n
,
[sf.cmath.sph_bessel]
J
ν
,
[sf.cmath.cyl_bessel_j]
K
ν
,
[sf.cmath.cyl_bessel_k]
n
n
,
[sf.cmath.sph_neumann]
N
ν
,
[sf.cmath.cyl_neumann]
бета-функции
B
,
[sf.cmath.beta]
двоичная складка
[expr.prim.fold]
двоичная левая складка,
[expr.prim.fold]
бинарный оператор
интерпретация,
[over.binary]
перегружен,
[over.binary]
двоичная правая складка,
[expr.prim.fold]
BinaryTypeTrait,
[meta.rqmts]
привязать напрямую,
[dcl.init.ref]
привязка
ссылка,
[dcl.init.ref]
binomial_distribution
дискретная функция вероятности,
[rand.dist.bern.bin]
битовое поле,
[class.bit]
адрес,
[class.bit]
выравнивание,
[class.bit]
согласование, определяемое реализацией,
[class.bit]
определяемый реализацией признак,
[diff.class]
тип,
[class.bit]
безымянный
[class.bit]
нулевая ширина,
[class.bit]
битовая маска
пустой,
[bitmask.types]
<bitset>
,
[bitset.syn]
блокировать,
[defns.block]
инициализация в,
[stmt.dcl]
объем блока,
[basic.scope.block]
оператор блока,
см.
statement, compound
блочная структура,
[stmt.dcl]
блок с делегированием гарантии продвижения вперед,
[intro.progress]
тело
функция
[dcl.fct.def.general]
Связь
Джеймс Бонд,
[expr.prim.lambda.capture]
Логическое,
[class.bit]
Логический литерал,
см
literal, boolean
,
[lex.bool]
Логический тип,
[basic.fundamental]
связанные аргументы,
[func.bind.bind]
граница массива
[dcl.array]
мозги
имена, которые хотят съесть твои,
[zombie.names]
ведра
[unord.req]
байт,
[intro.memory]
,
[expr.sizeof]
C
связь с,
[dcl.link]
стандарт
[intro.scope]
стандартная библиотека,
[intro.refs]
вызов
операторная функция,
[over.oper]
псевдодеструктор,
[expr.pseudo]
подпись звонка,
[func.def]
обертка вызова
[func.require]
,
[func.def]
пересылка
[func.require]
просто,
[func.require]
тип,
[func.def]
вызываемый объект,
[func.def]
вызываемый типа,
[func.wrap.func]
,
[func.def]
захватывать
скрытый,
[expr.prim.lambda.capture]
захвачен
[expr.prim.lambda.capture]
по копии,
[expr.prim.lambda.capture]
по ссылке,
[expr.prim.lambda.capture]
несет зависимость,
[intro.races]
нести
subtract_with_carry_engine
,
[rand.eng.sub]
<cassert>
,
[using.headers]
,
[cassert.syn]
,
[clocale.syn]
В ролях
базовый класс,
[expr.static.cast]
Const,
[expr.const.cast]
,
[expr.cast]
производный класс,
[expr.static.cast]
динамический,
[expr.dynamic.cast]
,
[bad.cast]
строительство и,
[class.cdtor]
разрушение и,
[class.cdtor]
целое число на указатель,
[expr.reinterpret.cast]
lvalue
[expr.static.cast]
,
[expr.reinterpret.cast]
указатель на целое число,
[expr.reinterpret.cast]
указатель на функцию,
[expr.reinterpret.cast]
указатель на член,
[expr.static.cast]
,
[expr.reinterpret.cast]
ссылка,
[expr.static.cast]
,
[expr.reinterpret.cast]
переинтерпретировать,
[expr.reinterpret.cast]
,
[expr.cast]
целое число на указатель,
[expr.reinterpret.cast]
lvalue,
[expr.reinterpret.cast]
указатель на целое число,
[expr.reinterpret.cast]
указатель на функцию,
[expr.reinterpret.cast]
указатель на член,
[expr.reinterpret.cast]
ссылка,
[expr.reinterpret.cast]
статичны,
[expr.static.cast]
,
[expr.cast]
lvalue,
[expr.static.cast]
ссылка,
[expr.static.cast]
неопределенный указатель на функцию,
[expr.reinterpret.cast]
Кастинг,
[expr.type.conv]
отбрасывая постоянство,
[expr.const.cast]
catch
,
[except]
кошки
вмешиваясь в клыки,
[hardware.interference]
cauchy_distribution
функция плотности вероятности,
[rand.dist.norm.cauchy]
<ccomplex>
,
[diff.mods.to.headers]
<cctype>
,
[cctype.syn]
<cerrno>
,
[extern.names]
,
[cerrno.syn]
<cfenv>
,
[cfenv.syn]
char
определяемый реализацией признак,
[basic.fundamental]
шарообразный объект,
[strings.general]
char-like тип,
[strings.general]
char_class_type
особенности регулярных выражений,
[re.req]
char16_t
,
см
type,
char16_t
char16_t
персонаж,
[lex.ccon]
char32_t
,
см
type,
char32_t
char32_t
персонаж,
[lex.ccon]
персонаж,
[defns.character]
десятичная точка,
[character.seq]
многобайтовый
[defns.multibyte]
нулевой,
[lex.charset]
signed
,
[basic.fundamental]
исходный файл,
[lex.phases]
подчеркивать,
[lex.name]
в идентификаторе,
[lex.name]
символьный литерал,
см.
literal, character
набор символов,
[lex.charset]
основное исполнение,
[intro.memory]
,
[lex.charset]
Основной источник,
[lex.phases]
,
[lex.charset]
исполнение,
[lex.charset]
символьная строка,
[lex.string]
литерал символьной строки,
[cpp.stringize]
проверка
точка ошибки,
[temp.res]
синтаксис,
[temp.res]
chi_squared_distribution
функция плотности вероятности,
[rand.dist.norm.chisq]
<chrono>
,
[time.syn]
куски
[mem.res.pool.overview]
<cinttypes>
,
[cinttypes.syn]
класс
[basic.compound]
,
[class]
Аннотация,
[class.abstract]
связанный,
[basic.lookup.argdep]
основание,
[derived.classes]
,
[derivation]
бросить к неполному,
[expr.cast]
конструктор и аннотация,
[class.abstract]
определение,
[basic.def]
полученный,
[derivation]
связь,
[basic.link]
спецификация связи,
[dcl.link]
местный,
см.
local class
функция-член,
см.
member function, class
вложенный,
см.
nested class
указатель на аннотацию,
[class.abstract]
полиморфный,
[class.virtual]
объем счетчика,
[dcl.enum]
типовая планировка,
[class]
тривиальный,
[class]
тривиально копируемый,
[class]
подобный союзу,
[class.union.anon]
безымянный
[dcl.typedef]
вариант член,
[class.union.anon]
название класса
развернутый,
[dcl.type.elab]
,
[class.name]
пункт декларации,
[class.name]
объем,
[class.name]
typedef
,
[dcl.typedef]
,
[class.name]
объект класса
назначение,
[expr.ass]
член,
[class.mem]
sizeof
,
[expr.sizeof]
копия объекта класса,
см.
constructor, copy
инициализация объекта класса,
см.
constructor
<climits>
,
[depr.strstreambuf.cons]
<clocale>
,
[character.seq]
закрытие объекта,
[expr.prim.lambda]
Тип закрытия,
[expr.prim.lambda.closure]
<cmath>
,
[cmath.syn]
,
[c.math.abs]
<codecvt>
,
[depr.locale.stdcvt]
элемент сортировки,
[re.def]
оператор запятой,
см.
operator, comma
комментарий,
[lex.pptoken]
,
[lex.comment]
/*
*/
,
[lex.comment]
//
,
[lex.comment]
общая начальная последовательность,
[class.mem]
сравнение
указатель,
[expr.eq]
указатель на функцию,
[expr.eq]
неопределенный указатель,
[expr.add]
совместим с
shared_ptr
,
[util.smartptr.shared]
сборник
отдельный,
[lex.separate]
строка управления компилятором,
см.
preprocessing directives
готовый объект,
[intro.object]
полный объект,
[intro.object]
полностью определен,
[class.mem]
<complex>
,
[complex.numbers]
,
[complex.syn]
<complex.h>
,
[diff.mods.to.headers]
составная часть,
[defns.component]
составной указатель типа,
[expr]
конкатенация
аргумент макроса,
см.
##
operator
нить,
[lex.string]
одновременные гарантии продвижения вперед,
[intro.progress]
condition
s
правила для,
[stmt.stmt]
<condition_variable>
,
[condition_variable.syn]
условное выражение
бросить выражение в
[expr.cond]
условно поддерживаемое поведение,
см.
behavior, conditionally-supported
конфликт
[intro.races]
Требования к соответствию,
[intro.compliance]
,
[intro.execution]
шаблоны классов,
[intro.compliance]
классы
[intro.compliance]
Общее,
[intro.compliance]
библиотека,
[intro.compliance]
метод описания,
[intro.compliance]
последовательность
связь,
[dcl.stc]
спецификация связи,
[dcl.link]
объявление типа,
[basic.link]
const
,
[basic.type.qualifier]
выбрасывать,
[expr.const.cast]
конструктор и
[class.this]
,,
[class.ctor]
деструктор и
[class.this]
,
[class.dtor]
связь,
[basic.link]
перегрузка и,
[over.load]
const
-объект
неопределенное изменение на,
[dcl.type.cv]
const-default-constructible,
[dcl.init]
const-квалифицированный,
[basic.type.qualifier]
const-volatile-квалифицированный,
[basic.type.qualifier]
const_cast
,
см
cast, const
const_local_iterator
,
[unord.req]
постоянная
[lex.literal.kinds]
,
[expr.prim.literal]
перечисление
[dcl.enum]
нулевой указатель
[conv.ptr]
,
[conv.mem]
постоянное выражение,
[expr.const]
разрешенный результат,
[expr.const]
постоянная инициализация,
[basic.start.static]
постоянный инициализатор,
[basic.start.static]
постоянный итератор,
[iterator.requirements.general]
постоянное подвыражение,
[defns.const.subexpr]
функция constexpr,
[dcl.constexpr]
constexpr если,
[stmt.if]
составляющее выражение,
[intro.execution]
строительство,
[class.cdtor]
динамический состав и,
[class.cdtor]
членский доступ,
[class.cdtor]
двигаться,
[defns.move.constr]
указатель на член или базу,
[class.cdtor]
typeid
оператор
[class.cdtor]
вызов виртуальной функции,
[class.cdtor]
конструктор,
[class.ctor]
адрес,
[class.ctor]
массив объектов класса и,
[class.expl.init]
преобразование
[class.conv.ctor]
копировать,
[special]
,
[class.temporary]
,
[class.copy.ctor]
,
[class.copy.ctor]
,
[functions.within.classes]
элизия
[class.copy.elision]
неявно заявлено,
[class.copy.ctor]
неявно определено,
[class.copy.ctor]
недоступный,
[class.copy]
нетривиальный,
[class.copy.ctor]
тривиальный,
[class.copy.ctor]
по умолчанию,
[special]
,
[class.ctor]
нетривиальный,
[class.ctor]
тривиальный,
[class.ctor]
обработка исключений,
см.
exception handling, constructors and destructors
явный вызов,
[class.ctor]
неявно называется,
[class.ctor]
неявно определено,
[class.ctor]
наследование,
[class.ctor]
двигаться,
[special]
,
[class.copy.ctor]
,
[class.copy.ctor]
элизия
[class.copy.elision]
неявно заявлено,
[class.copy.ctor]
неявно определено,
[class.copy.ctor]
недоступный,
[class.copy]
нетривиальный,
[class.copy.ctor]
тривиальный,
[class.copy.ctor]
нетривиальный,
[class.ctor]
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
union
,
[class.union]
конструктор, преобразование по,
см.
conversion, user-defined
содержащаяся ценность
any
,
[any.class]
optional
,
[optional.optional]
variant
,
[variant.variant]
контейнер
смежный,
[container.requirements.general]
содержит значение
optional
,
[optional.optional]
контекст
невыведенный,
[temp.deduct.type]
контекстно преобразованное постоянное выражение типа
bool
,
см.
conversion, contextual
контекстно преобразован в bool,
см.
conversion, contextual
контекстно неявно преобразованный,
[conv]
непрерывный контейнер,
[container.requirements.general]
смежные итераторы,
[iterator.requirements.general]
continue
и обработчик,
[except]
и попробуйте заблокировать,
[except]
линия управления,
см.
preprocessing directives
условности
лексический
[lex.separate]
преобразование
аргумент
[dcl.fct]
от массива к указателю,
[conv.array]
bool
,
[conv.integral]
логическое значение
[conv.bool]
класс,
[class.conv]
контекстуальный,
[conv]
контекстуально
bool
,
[conv]
контекстное постоянное выражение типа
bool
,
[expr.const]
выведенный тип возвращаемого значения, определяемый пользователем,
[class.conv.fct]
производное к основанию,
[over.best.ics]
с плавающей точкой в интеграл,
[conv.fpint]
плавающая запятая,
[conv.double]
указатель на функцию,
[conv.fctptr]
функция-указатель,
[conv.func]
целое число указателя, определяемого реализацией,
[expr.reinterpret.cast]
неявный,
[conv]
,
[class.conv]
неявный пользовательский,
[class.conv]
наследование пользовательских,
[class.conv.fct]
целочисленный ранг,
[conv.rank]
интеграл,
[conv.integral]
неотъемлемая часть плавающего,
[conv.fpint]
Lvalue к RValue,
[conv.lval]
,
[diff.expr]
сужение,
[dcl.init.list]
разрешение перегрузки и,
[over.match.best]
разрешение перегрузки и указатель,
[over.over]
указатель,
[conv.ptr]
указатель на член,
[conv.mem]
void*
,
[conv.mem]
квалификация,
[conv.qual]
тип возврата,
[stmt.return]
стандарт
[conv]
временная материализация,
[conv.rval]
подписать,
[conv.integral]
до беззнакового,
[conv.integral]
тип,
[class.conv.fct]
определяемый пользователем,
[class.conv.ctor]
,
[class.conv.fct]
,
[class.conv]
обычная арифметика,
[expr]
виртуальный пользовательский,
[class.conv.fct]
явный тип преобразования,
см.
casting
функция преобразования,
см.
conversion, user-defined
,
[class.conv.fct]
рейтинг конверсии,
[over.ics.scs]
копировать
объект класса,
см.
constructor, copy
,
см.
assignment operator, copy
конструктор копирования
требование механизма случайных чисел,
[rand.req.eng]
копия кандидата на вычет,
[over.match.class.deduct]
копировать элизию,
см.
constructor, copy, elision
копирование-инициализация,
[dcl.init]
копирование-список-инициализация,
[dcl.init.list]
CopyInsertable
в
X
,
[container.requirements.general]
<csetjmp>
,
[extern.names]
,
[support.runtime]
,
[csetjmp.syn]
<csignal>
,
[support.runtime]
,
[csignal.syn]
<cstdarg>
,
[dcl.fct]
,
[extern.names]
,
[support.runtime]
,
[cstdarg.syn]
<cstdbool>
,
[support.runtime]
<cstddef>
,
[expr.sizeof]
,
[expr.add]
<cstdint>
,
[cstdint.syn]
<cstdio>
,
[iostream.objects.overview]
,
[narrow.stream.objects]
,
[wide.stream.objects]
,
[filebuf.members]
,
[cstdio.syn]
<cstdlib>
,
[basic.start.term]
,
[compliance]
,
[cstdlib.syn]
,
[support.start.term]
,
[support.runtime]
,
[c.malloc]
,
[c.mb.wcs]
,
[alg.c.library]
,
[c.math.rand]
,
[c.math.abs]
,
[depr.c.headers]
<cstring>
,
[byte.strings]
,
[cstring.syn]
,
[depr.strstreambuf.cons]
,
[depr.ostrstream.cons]
<ctgmath>
,
[diff.mods.to.headers]
<ctime>
,
[support.runtime]
,
[ctime.syn]
,
[locale.syn]
<ctype.h>
,
[cctype.syn]
<cuchar>
,
[extern.names]
,
[cuchar.syn]
текущий экземпляр,
[temp.dep.type]
зависимый член,
[temp.dep.type]
член,
[temp.dep.type]
в настоящее время обрабатываемое исключение,
см.
exception handling, currently handled exception
cv-разложение,
[conv.qual]
CV-квалификационная подпись,
[conv.qual]
cv-квалификатор,
[basic.type.qualifier]
высший уровень,
[basic.type.qualifier]
<cwchar>
,
[extern.names]
,
[cwchar.syn]
,
[c.mb.wcs]
<cwctype>
,
[extern.names]
,
[cwctype.syn]
DAG
множественное наследование,
[class.mi]
не виртуальный базовый класс,
[class.mi]
виртуальный базовый класс,
[class.mi]
Элемент данных,
см
member
,
[class.mem]
статический
[class.mem]
гонка данных
[intro.races]
тупик
[defns.deadlock]
функция освобождения
обычный,
[basic.stc.dynamic.deallocation]
функции освобождения,
[basic.stc.dynamic]
разлагаться
массив,
см.
conversion, array to pointer
функция,
см.
conversion, function to pointer
DECAY_COPY
,
[thread.decaycopy]
декларация
[basic.def]
,
[basic]
,
[dcl.dcl]
множество,
[dcl.array]
asm
,
[dcl.asm]
битовое поле,
[class.bit]
название класса,
[basic.def]
постоянный указатель,
[dcl.ptr]
аргумент по умолчанию,
[dcl.fct.default]
определение против,
[basic.def]
многоточие в функции
[expr.call]
,
[dcl.fct]
точка счетчика,
[basic.scope.pdecl]
extern
,
[basic.def]
extern
ссылка,
[dcl.init.ref]
вперед,
[dcl.stc]
форвард класс,
[class.name]
функция
[basic.def]
,
[dcl.fct]
местный класс,
[class.local]
член,
[class.mem]
несколько,
[basic.link]
имя,
[basic.def]
непрозрачное перечисление,
[basic.def]
перегружен,
[over]
перегруженное имя и
friend
,
[class.friend]
Параметр,
[basic.def]
,
[dcl.fct]
Круглые скобки в,
[dcl.ambig.res]
,
[dcl.meaning]
указатель,
[dcl.ptr]
ссылка,
[dcl.ref]
static
член,
[basic.def]
класс хранения,
[dcl.stc]
структурированная привязка,
см.
structured binding declaration
тип,
[dcl.meaning]
typedef
,
[basic.def]
typedef
как тип,
[dcl.typedef]
декларация скрывается,
см.
name hiding
декларативный регион,
[basic.scope.declarative]
описатель,
[basic.def]
,
[dcl.dcl]
,
[dcl.decl]
множество,
[dcl.array]
функция
[dcl.fct]
значение,
[dcl.meaning]
многомерный массив,
[dcl.array]
указатель,
[dcl.ptr]
указатель на член,
[dcl.mptr]
ссылка,
[dcl.ref]
оператор декремента
перегружен,
см.
overloading, decrement operator
вычет
аргумент шаблона класса,
[temp.deduct.guide]
аргументы шаблона класса,
[expr.type.conv]
,
[dcl.type.simple]
,
[dcl.type.class.deduct]
,
[over.match.class.deduct]
тип заполнителя,
[dcl.type.auto.deduct]
контроль доступа по умолчанию,
см.
access control, default
аргумент по умолчанию
разрешение перегрузки и,
[over.match.viable]
создание экземпляра аргумента по умолчанию,
[temp.inst]
конструктор по умолчанию,
см.
constructor, default
требование распределения случайных чисел,
[rand.req.dist]
требование последовательности семян,
[rand.req.seedseq]
инициализаторы по умолчанию
перегрузка и,
[over.load]
инициализатор члена по умолчанию,
[class.mem]
указатель ресурса памяти по умолчанию,
[mem.res.global]
инициализация по умолчанию,
[dcl.init]
вставлено по умолчанию,
[container.requirements.general]
дефолт,
[dcl.fct.def.default]
DefaultInsertable
в
X
,
[container.requirements.general]
отложенная функция,
[futures.async]
defined
,
[cpp.cond]
определение,
[basic.def]
,
[basic.def]
альтернативный,
[replacement.functions]
класс
[class]
,
[class.mem]
имя класса как тип,
[class.name]
конструктор,
[dcl.fct.def.general]
декларация как,
[dcl.dcl]
функция
[dcl.fct.def]
удалено,
[dcl.fct.def.delete]
явно дефолт,
[dcl.fct.def.default]
местный класс,
[class.local]
функция-член,
[class.mfct]
пространство имен,
[namespace.def]
вложенный класс,
[class.nest]
чистая виртуальная функция,
[class.abstract]
объем класса,
[class.name]
статический член
[class.static.data]
виртуальная функция,
[class.virtual]
определения,
[intro.defs]
delete
,
[basic.stc.dynamic]
,
[expr.delete]
,
[class.free]
множество,
[expr.delete]
деструктор и
[expr.delete]
,
[class.dtor]
объект,
[expr.delete]
operator
сменный,
[replacement.functions]
перегрузка и,
[basic.stc.dynamic.deallocation]
тип,
[class.free]
неопределенный,
[expr.delete]
удалитель
[unique.ptr]
денормализованное значение,
см.
number, subnormal
зависимость, заказанная ранее,
[intro.races]
зависимый базовый класс,
см.
base class, dependent
зависимый член текущего экземпляра,
см.
current instantiation, dependent member of the
зависимое имя,
см.
name, dependent
<deque>
,
[deque.syn]
разыменование,
см. также
indirection
вывод,
см.
inheritance
производный класс,
[class.derived]
большинство,
см
most derived class
производный объект
большинство,
см
most derived object
разрушение
[class.cdtor]
динамический состав и,
[class.cdtor]
членский доступ,
[class.cdtor]
указатель на член или базу,
[class.cdtor]
typeid
оператор
[class.cdtor]
вызов виртуальной функции,
[class.cdtor]
деструктор
[class.dtor]
,
[functions.within.classes]
дефолт,
[class.dtor]
обработка исключений,
см.
exception handling, constructors and destructors
явный вызов,
[class.dtor]
неявный вызов,
[class.dtor]
неявно определено,
[class.dtor]
нетривиальный,
[class.dtor]
завершение программы и,
[class.dtor]
чисто виртуальный,
[class.dtor]
union
,
[class.union]
виртуальный
[class.dtor]
диагностируемые правила,
[intro.compliance]
диагностическое сообщение,
см.
message, diagnostic
диграф,
смотри
token, alternative
,
[lex.digraph]
прямой член,
[class.mem]
прямая инициализация,
[dcl.init]
инициализация прямого списка,
[dcl.init.list]
прямая инициализация без списка,
[defns.direct-non-list-init]
ориентированный ациклический граф,
см.
DAG
директива, предварительная обработка,
см.
preprocessing directives
discard
требование механизма случайных чисел,
[rand.req.eng]
discard_block_engine
алгоритм генерации,
[rand.adapt.disc]
штат,
[rand.adapt.disc]
текстовое представление,
[rand.adapt.disc]
алгоритм перехода,
[rand.adapt.disc]
отклоненное заявление,
[stmt.if]
выражение отброшенного значения,
[expr]
дискретная функция вероятности
bernoulli_distribution
,
[rand.dist.bern.bernoulli]
binomial_distribution
,
[rand.dist.bern.bin]
discrete_distribution
,
[rand.dist.samp.discrete]
geometric_distribution
,
[rand.dist.bern.geo]
negative_binomial_distribution
,
[rand.dist.bern.negbin]
poisson_distribution
,
[rand.dist.pois.poisson]
uniform_int_distribution
,
[rand.dist.uni.int]
discrete_distribution
дискретная функция вероятности,
[rand.dist.samp.discrete]
веса,
[rand.dist.samp.discrete]
распространение,
см.
random number distribution
собаки
невнимание к вмешательству,
[hardware.interference]
ошибка домена,
[sf.cmath]
господство
виртуальный базовый класс,
[class.member.lookup]
оператор точки,
см.
operator, class member access
динамическое связывание,
см.
virtual function
динамическая инициализация,
[basic.start.static]
динамический тип,
см.
type, dynamic
dynamic_cast
,
см
cast, dynamic
E
(полные эллиптические интегралы),
[sf.cmath.comp_ellint_2]
E
(неполные эллиптические интегралы),
[sf.cmath.ellint_2]
ECMA-262,
[intro.refs]
ECMAScript
[re.synopt]
,
[re.grammar]
egrep
,
[re.synopt]
Ei
(экспоненциальные интегралы),
[sf.cmath.expint]
подробный спецификатор типа,
см.
class name, elaborated
функции доступа к элементам,
[algorithms.parallel.defns]
элизия
копия,
см
constructor, copy, elision
конструктор копирования,
см.
constructor, copy, elision
переместить конструктор,
см.
constructor, move, elision
многоточие
Последовательность преобразования,
[expr.call]
,
[over.ics.ellipsis]
разрешение перегрузки и,
[over.match.viable]
эллиптические интегралы
полный
E
,
[sf.cmath.comp_ellint_2]
полный
K
,
[sf.cmath.comp_ellint_1]
полный
Π
,
[sf.cmath.comp_ellint_3]
неполный
E
,
[sf.cmath.ellint_2]
неполный
F
,
[sf.cmath.ellint_1]
неполный
Π
,
[sf.cmath.ellint_3]
EmplaceConstructible
в
X
из
args
,
[container.requirements.general]
пустой
future
объект,
[futures.unique_future]
пустой
shared_future
объект,
[futures.shared_future]
закодированный символьный тип,
[fs.req]
кодирование
многобайтовый
[lex.string]
конец файла,
[bitset.operators]
двигатель,
см
random number engine
переходник двигателя,
см.
random number engine adaptor
двигатели с заданными параметрами
default_random_engine
,
[rand.predef]
knuth_b
,
[rand.predef]
minstd_rand
,
[rand.predef]
minstd_rand0
,
[rand.predef]
mt19937
,
[rand.predef]
mt19937_64
,
[rand.predef]
ranlux24
,
[rand.predef]
ranlux24_base
,
[rand.predef]
ranlux48
,
[rand.predef]
ranlux48_base
,
[rand.predef]
организация,
[basic]
шаблонный
[temp]
enum
,
[basic.compound]
перегрузка и,
[over.load]
тип,
[dcl.enum]
базовый тип,
см.
type, underlying
имя перечисления
typedef
,
[dcl.typedef]
перечисление
[dcl.enum]
связь,
[basic.link]
ограниченный
[dcl.enum]
без области действия
[dcl.enum]
область перечисления
[basic.scope.enum]
,
[basic.scope.enum]
тип перечисления
преобразование в,
[expr.static.cast]
static_cast
преобразование в,
[expr.static.cast]
счетчик
определение,
[basic.def]
значение,
[dcl.enum]
среда
программа
[basic.start.main]
эпоха
[time.clock.req]
эквивалентность
тип шаблона,
[temp.type]
типа,
[dcl.typedef]
,
[class.name]
эквивалент
выражение,
см
expression, equivalent
шаблон функции,
см.
template, function, equivalent
функционально
выражение,
см
expression, functionally equivalent
шаблон функции,
см.
template, function, functionally equivalent
объявления эквивалентных параметров,
[over.load]
перегрузка и,
[over.load]
группа эквивалентных ключей,
[unord.req]
равнозначные,
[allocator.requirements]
Erasable
из
X
,
[container.requirements.general]
<errno.h>
,
[errno]
escape-символ,
см.
backslash character
escape-последовательность
неопределенный,
[lex.ccon]
Интеграл Эйлера первого рода,
см.
beta
оценка,
[intro.execution]
порядок аргументации,
[expr.call]
сигнально-безопасный,
[support.signal]
неопределенный порядок,
[intro.execution]
,
[basic.start.dynamic]
неуказанный порядок аргументации,
[expr.call]
неуказанный порядок вызова функции,
[expr.call]
пример
множество,
[dcl.array]
определение класса,
[class.mem]
const
,
[dcl.ptr]
постоянный указатель,
[dcl.ptr]
конструктор,
[class.ctor]
конструктор и инициализация,
[class.expl.init]
декларация
[basic.def]
,
[dcl.fct]
декларатор,
[dcl.name]
определение,
[basic.def]
delete
,
[class.free]
производный класс,
[class.derived]
деструктор и
delete
,
[class.free]
многоточие
[dcl.fct]
перечисление
[dcl.enum]
явный вызов деструктора,
[class.dtor]
явная квалификация,
[class.member.lookup]
друг
[class.name]
функция друга,
[class.friend]
объявление функции,
[dcl.fct]
определение функции,
[dcl.fct.def.general]
согласованность связей,
[dcl.stc]
местный класс,
[class.local]
функция,
[class.mfct.non-static]
,
[class.friend]
вложенный класс,
[class.nest]
определение вложенного класса
[class.nest]
,
[class.access.nest]
предварительное объявление вложенного класса,
[class.nest]
имя вложенного типа,
[class.nested.type]
указатель на член,
[dcl.mptr]
чистая виртуальная функция,
[class.abstract]
объем
delete
,
[class.free]
оператор разрешения области видимости,
[class.member.lookup]
статический член
[class.static.data]
индексирование,
[dcl.array]
имя типа,
[dcl.name]
typedef
,
[dcl.typedef]
безымянный параметр,
[dcl.fct.def.general]
список переменных параметров,
[dcl.fct]
виртуальная функция,
[class.virtual]
<exception>
,
[exception.syn]
,
[depr.uncaught]
исключение
арифметика,
[expr]
неопределенная арифметика,
[expr]
Обработка исключений,
[except]
конструкторы и деструкторы,
[except.ctor]
в настоящее время обрабатываемое исключение,
[except.handle]
объект исключения,
[except.throw]
,
[except.throw]
конструктор,
[except.throw]
деструктор
[except.throw]
блок попытки функции,
[except]
goto
,
[except]
Обработчик,
[except]
,
[except.throw]
,
[except.handle]
,
[res.on.exception.handling]
активный
[except.handle]
массив в,
[except.handle]
неполный тип в,
[except.handle]
соответствие,
[except.handle]
указатель на функцию в,
[except.handle]
ссылка rvalue в,
[except.handle]
объем памяти,
[except.throw]
ближайший обработчик,
[except.throw]
повторно выдать,
[expr.throw]
,
[except.throw]
перебрасывание
[except.throw]
switch
,
[except]
terminate
называется,
[expr.throw]
,
[except.throw]
,
[except.spec]
бросать,
[expr.throw]
,
[except.throw]
попробуйте заблокировать,
[except]
объект исключения,
см.
exception handling, exception object
спецификация исключения,
[except.spec]
,
[except.spec]
нет кроме
постоянное выражение и,
[except.spec]
не метательный,
[except.spec]
потенциально-бросающий,
[except.spec]
виртуальная функция и,
[except.spec]
<execution>
,
[execution.syn]
агент исполнения,
[thread.req.lockable.general]
политика исполнения,
[execpol.general]
шаг исполнения,
[intro.progress]
exit
,
[basic.start.main]
,
[basic.start.term]
,
[stmt.jump]
явное преобразование типа,
см.
casting
explicit-specialization
,
[temp.expl.spec]
явно захвачено,
[expr.prim.lambda.capture]
экспоненциальные интегралы
Ei
,
[sf.cmath.expint]
exponential_distribution
функция плотности вероятности,
[rand.dist.pois.exp]
выражение,
[expr]
аддитивные операторы,
[expr.add]
alignof
,
[expr.alignof]
присвоение и составное присвоение,
[expr.ass]
побитовое И,
[expr.bit.and]
побитовое исключающее ИЛИ,
[expr.xor]
побитовое включающее ИЛИ,
[expr.or]
литье,
[expr.type.conv]
,
[expr.cast]
доступ к члену класса,
[expr.ref]
запятая
[expr.comma]
условный оператор,
[expr.cond]
const cast,
[expr.const.cast]
постоянная
[expr.const]
,
[expr.const]
преобразованная константа,
[expr.const]
основная постоянная,
[expr.const]
декремент,
[expr.post.incr]
,
[expr.pre.incr]
delete
,
[expr.delete]
динамический состав,
[expr.dynamic.cast]
операторы равенства,
[expr.eq]
эквивалент,
[temp.over.link]
складывать,
[expr.prim.fold]
вызов функции,
[expr.call]
функционально эквивалентен,
[temp.over.link]
приращение
[expr.post.incr]
,
[expr.pre.incr]
интегральная постоянная,
[expr.const]
лямбда
[expr.prim.lambda]
левый-Shift-оператор,
[expr.shift]
логическое И,
[expr.log.and]
логическое ИЛИ,
[expr.log.or]
мультипликативные операторы,
[expr.mul]
new
,
[expr.new]
noexcept
,
[expr.unary.noexcept]
порядок оценки,
[intro.execution]
в скобках
[expr.prim.paren]
указатель на константу члена,
[expr.unary.op]
указатель на член,
[expr.mptr.oper]
постфикс
[expr.post]
начальный,
[expr.prim]
вызов псевдодеструктора,
[expr.pseudo]
ссылка,
[expr]
переосмыслить актерский состав,
[expr.reinterpret.cast]
реляционные операторы,
[expr.rel]
оператор сдвига вправо,
[expr.shift]
ссылка rvalue,
[expr]
sizeof
,
[expr.sizeof]
статический бросок,
[expr.static.cast]
throw
,
[expr.throw]
идентификация типа,
[expr.typeid]
типозависимый,
[temp.dep]
унарный
[expr.unary]
унарный оператор,
[expr.unary.op]
ценностно-зависимый,
[temp.dep]
расширить,
см
namespace, extend
расширенное выравнивание,
[basic.align]
расширенный целочисленный тип,
[basic.fundamental]
расширенный знаковый целочисленный тип,
[basic.fundamental]
расширенный беззнаковый целочисленный тип,
[basic.fundamental]
extern
,
[dcl.stc]
,
[gram.dcl]
связь,
[dcl.stc]
extern "C"
,
[using.linkage]
,
[extern.names]
extern "C++"
,
[using.linkage]
,
[extern.names]
внешняя связь,
[basic.link]
extreme_value_distribution
функция плотности вероятности,
[rand.dist.pois.extreme]
F
(неполные эллиптические интегралы),
[sf.cmath.ellint_1]
грань
[locale.facet]
атрибуты файла,
[fs.class.directory_entry]
кешировано,
[fs.class.directory_entry]
файл, источник,
см.
source file
<filesystem>
,
[fs.filesystem.syn]
окончательный приоритет,
[class.virtual]
конечный автомат,
[defns.regex.collating.element]
fisher_f_distribution
функция плотности вероятности,
[rand.dist.norm.f]
плавающий литерал,
см.
literal, floating
литерал с плавающей запятой,
см.
literal, floating
тип с плавающей запятой,
[basic.fundamental]
определяется реализацией,
[basic.fundamental]
складывать
двоичный
[expr.prim.fold]
унарный
[expr.prim.fold]
for
объем декларации в,
[stmt.for]
спецификатор формата,
[defns.regex.finite.state.machine]
гарантии продвижения вперед
одновременный,
[intro.progress]
делегирование,
[intro.progress]
параллельно
[intro.progress]
слабо параллельный,
[intro.progress]
<forward_list>
,
[forward_list.syn]
оболочка для переадресации вызовов,
[func.require]
ссылка на переадресацию,
[temp.deduct.call]
бесплатный магазин,
см. также
new
,
delete
,
[class.free]
автономное исполнение,
[intro.compliance]
друг
спецификатор доступа и,
[class.friend]
доступ к классу и,
[class.friend]
наследование и,
[class.friend]
местный класс и,
[class.friend]
шаблон и,
[temp.friend]
virtual
а также,
[class.virtual]
функция друга
доступ и,
[class.friend]
в линию,
[class.friend]
связь,
[class.friend]
функция-член и,
[class.friend]
вложенный класс,
[class.nest]
<fstream>
,
[fstream.syn]
полное выражение,
[intro.execution]
функция,
см. также
friend function; member function; inline function; virtual function
распределение,
[basic.stc.dynamic.allocation]
,
[expr.new]
сравнение,
[defns.comparison]
преобразование
[class.conv.fct]
открепление,
[basic.stc.dynamic.deallocation]
,
[class.free]
определение,
[basic.def]
глобальные,
[extern.names]
,
[res.on.macro.definitions]
обработчик
[defns.handler]
обработчик типа,
[except.handle]
спецификация связи перегружена,
[dcl.link]
модификатор,
[defns.modifier]
наблюдатель
[defns.observer]
оператор
[over.oper]
разрешение перегрузки и,
[over.match.funcs]
перегрузка и указатель против,
[over.load]
параметр типа,
[dcl.fct]
указатель на член,
[expr.mptr.oper]
замена,
[defns.replacement]
зарезервированный,
[defns.reserved.function]
параметр шаблона типа,
[temp.param]
жизнеспособный,
[over.match]
вызов виртуальной функции,
[expr.call]
виртуальный член
[derived.classes]
аргумент функции,
см.
argument
вызов функции,
[expr.call]
рекурсивный,
[expr.call]
неопределенный,
[expr.reinterpret.cast]
оператор вызова функции
перегружен,
[over.call]
функциональный объект,
[function.objects]
связующие,
[func.bind]
mem_fn
,
[func.memfn]
reference_wrapper
,
[refwrap]
тип,
[function.objects]
обертка
[func.wrap]
параметр функции,
см.
parameter
пакет параметров функции,
[temp.variadic]
тип указателя функции,
[basic.compound]
прототип функции,
[basic.scope.proto]
возврат функции,
см.
return
тип возвращаемого значения функции,
см.
return type
функциональный блок try,
см.
exception handling, function try block
функция, перегружена,
см.
overloading
функция, виртуальный,
см.
virtual function
function-definition
,
[dcl.fct.def.general]
функционально-подобный макрос,
см.
macro, function-like
<functional>
,
[functional.syn]
,
[depr.negators]
функционально эквивалентный
выражение,
см
expression, functionally equivalent
шаблон функции,
см.
template, function, functionally equivalent
функции
кандидат
[temp.dep.candidate]
фундаментальное выравнивание,
[basic.align]
основной тип
деструктор и,
[class.dtor]
преобразование основного типа,
см.
conversion, user-defined
<future>
,
[future.syn]
будущее
общее состояние,
[futures.state]
gamma_distribution
функция плотности вероятности,
[rand.dist.pois.gamma]
generate
требование последовательности семян,
[rand.req.seedseq]
сгенерированный деструктор,
см.
destructor, default
алгоритм генерации
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
общая лямбда
значение,
[dcl.spec.auto]
geometric_distribution
дискретная функция вероятности,
[rand.dist.bern.geo]
Глобальный,
[basic.scope.namespace]
глобальное пространство имен,
[basic.scope.namespace]
область глобального пространства имен,
[basic.scope.namespace]
глобальный охват,
[basic.scope.namespace]
glvalue,
[basic.lval]
goto
и обработчик,
[except]
и попробуйте заблокировать,
[except]
инициализация и,
[stmt.dcl]
грамматика
[gram]
регулярное выражение,
[re.grammar]
grep
,
[re.synopt]
H
n
(Полиномы Эрмита),
[sf.cmath.hermite]
обработчик,
см.
exception handling, handler
происходит после,
[intro.races]
происходит раньше,
[intro.races]
hash
ограничения на создание экземпляров,
[unord.hash]
хэш-код,
[unord.req]
хеш-функция,
[unord.req]
хеш-таблицы,
см.
unordered associative containers
заголовок
С,
[extern.names]
,
[res.on.macro.definitions]
,
[depr.c.headers]
Библиотека C,
[using.linkage]
Библиотека C ++,
[headers]
имя,
[lex.header]
заголовки
Библиотека C,
[depr.c.headers]
Полиномы Эрмита
H
n
,
[sf.cmath.hermite]
прячется,
смотри
name hiding
бит старшего разряда,
[intro.memory]
размещенная реализация,
[intro.compliance]
I
ν
(Функции Бесселя),
[sf.cmath.cyl_bessel_i]
я бы
квалифицированный,
[expr.prim.id.qual]
id-выражение,
[expr.prim.id]
Идентификатор,
[lex.name]
,
[expr.prim.id.unqual]
,
[dcl.dcl]
метка идентификатора,
[stmt.label]
плохо сформированная программа,
см.
program, ill-formed
немедленное подвыражение,
[intro.execution]
реализация
отдельно стоящий
[compliance]
размещен,
[compliance]
пределы реализации,
см.
limits, implementation
поведение, определяемое реализацией,
см.
behavior, implementation-defined
зависит от реализации,
[istream::sentry]
сгенерированный реализацией,
[basic.def]
неявный захват
значение,
[expr.prim.lambda.capture]
неявное преобразование,
см.
conversion, implicit
неявный параметр объекта,
[over.match.funcs]
неявно объявлен конструктор по умолчанию,
см
constructor, default
,
[class.ctor]
подразумеваемый объектный аргумент,
[over.match.funcs]
неявные последовательности преобразования,
[over.match.funcs]
нестатическая функция-член и,
[over.match.funcs]
включение
условный,
см.
preprocessing directive, conditional inclusion
исходный файл,
см.
preprocessing directives, source-file inclusion
неполный,
[expr.add]
оператор приращения
перегружен,
см.
overloading, increment operator
independent_bits_engine
алгоритм генерации,
[rand.adapt.ibits]
штат,
[rand.adapt.ibits]
текстовое представление,
[rand.adapt.ibits]
алгоритм перехода,
[rand.adapt.ibits]
неопределенное значение,
[dcl.init]
неопределенная последовательность,
[intro.execution]
косвенное обращение,
[expr.unary.op]
наследование
[class.derived]
,
[class.derived]
using-declaration
а также,
[namespace.udecl]
инициализации
[basic.start.static]
,
[dcl.init]
совокупность
[dcl.init.aggr]
множество,
[dcl.init.aggr]
Массив объектов класса,
[dcl.init.aggr]
,
[class.expl.init]
автомат
[stmt.dcl]
автоматический объект,
[dcl.init]
базовый класс,
[class.base.init]
унаследованным конструктором,
[class.inhctor.init]
массив символов,
[dcl.init.string]
член класса
[dcl.init]
класс объектов,
смотри также
constructor
,
[dcl.init.aggr]
,
[class.init]
const
,
[dcl.type.cv]
,
[dcl.init]
константный член,
[class.base.init]
постоянный,
[basic.start.static]
конструктор и
[class.init]
,,
[class.expl.init]
копия
[dcl.init]
дефолт,
[dcl.init]
конструктор по умолчанию и,
[class.init]
определение и,
[dcl.dcl]
непосредственный,
[dcl.init]
динамический
[basic.start.static]
динамический блок-область видимости,
[stmt.dcl]
динамический нелокальный,
[basic.start.dynamic]
явный,
[class.expl.init]
прыгать мимо,
[stmt.dcl]
список-инициализация,
[dcl.init.list]
местный
static
,
[stmt.dcl]
местный
thread_local
,
[stmt.dcl]
член,
[class.base.init]
вызов функции-члена во время,
[class.base.init]
объект-член,
[class.base.init]
непустой,
[basic.life]
Порядковый,
[basic.start.dynamic]
,
[class.mi]
порядок базового класса,
[class.base.init]
порядок члена,
[class.base.init]
порядок виртуального базового класса,
[class.base.init]
перегруженное присвоение и,
[class.expl.init]
параметр,
[expr.call]
ссылка,
[dcl.ref]
,
[dcl.init.ref]
ссылочный член,
[class.base.init]
время выполнения
[basic.start.static]
статический и поток,
[basic.start.static]
статический член
[class.static.data]
static
объект
[basic.start.static]
,
[dcl.init]
union
,
[dcl.init.aggr]
,
[class.union.anon]
виртуальный базовый класс,
[class.copy.ctor]
нулевая инициализация,
[dcl.init]
инициализатор
базовый класс,
[dcl.fct.def.general]
член,
[dcl.fct.def.general]
расширение пакета,
[class.base.init]
объем члена,
[class.base.init]
временный и декларатор,
[class.temporary]
конструктор списка инициализаторов,
[dcl.init.list]
требование последовательности семян,
[rand.req.seedseq]
<initializer_list>
,
[support.initlist]
инициализация объявления,
[dcl.init]
injected-class-name
,
[class]
,
[class]
inline
,
[res.on.macro.definitions]
связь,
[basic.link]
встроенная функция,
[dcl.inline]
реализация
явный,
[temp.explicit]
точка
[temp.point]
шаблон неявный,
[temp.inst]
единицы создания экземпляров,
[lex.phases]
целочисленный литерал,
см.
literal, integer
целочисленное представление,
[basic.stc.dynamic.safety]
целочисленный тип,
[basic.fundamental]
интегральный тип,
[basic.fundamental]
определяется реализацией
sizeof
,
[basic.fundamental]
межпоток происходит раньше,
[intro.races]
внутренняя связь,
[basic.link]
границы интервалов
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
<inttypes.h>
,
[cinttypes.syn]
недопустимое значение указателя,
[basic.compound]
призыв
макрос
[cpp.replace]
<iomanip>
,
[iomanip.syn]
<ios>
,
[ios.syn]
<iosfwd>
,
[iosfwd.syn]
<iostream>
,
[iostream.syn]
isctype
особенности регулярных выражений,
[re.req]
<istream>
,
[istream.syn]
iteration-statement
,
[stmt.break]
,
[stmt.cont]
<iterator>
,
[iterator.synopsis]
,
[depr.iterator.basic]
j
n
(сферические функции Бесселя),
[sf.cmath.sph_bessel]
J
ν
(Функции Бесселя),
[sf.cmath.cyl_bessel_j]
Джесси,
[class.conv.ctor]
K
(полные эллиптические интегралы),
[sf.cmath.comp_ellint_1]
K
ν
(Функции Бесселя),
[sf.cmath.cyl_bessel_k]
ключевое слово
[lex.key]
,
[gram.key]
L
n
(Полиномы Лагерра),
[sf.cmath.laguerre]
L
m
n
(ассоциированные полиномы Лагерра),
[sf.cmath.assoc_laguerre]
метка,
[stmt.goto]
case
,
[stmt.label]
,
[stmt.switch]
default
,
[stmt.label]
,
[stmt.switch]
объем
[basic.funscope]
,
[stmt.label]
Полиномы Лагерра
L
n
,
[sf.cmath.laguerre]
L
m
n
,
[sf.cmath.assoc_laguerre]
lambda-introducer
,
[dcl.type.simple]
решетка,
см.
DAG, subobject
макет
битовое поле,
[class.bit]
класс объектов,
[class.mem]
,
[class.mi]
макет совместимый,
[basic.types]
класс,
[class.mem]
перечисление
[dcl.enum]
макет-совместимый тип,
[basic.types]
левый "шифт
неопределенный,
[expr.shift]
оператор сдвига влево,
см.
operator, left shift
Функции Лежандра
Y
m
ℓ
,
[sf.cmath.sph_legendre]
Полиномы Лежандра
P
ℓ
,
[sf.cmath.legendre]
P
m
ℓ
,
[sf.cmath.assoc_legendre]
лексические соглашения,
см.
conventions, lexical
ЛИА-1,
[intro.refs]
библиотека
С стандарт,
[library.c]
,
[character.seq]
,
[headers]
,
[using.linkage]
,
[diff.library]
,
[diff.mods.to.headers]
,
[depr.c.headers]
C ++ стандарт
[library.general]
,
[derived.classes]
,
[replacement.functions]
,
[res.on.arguments]
,
[derivation]
,
[res.on.exception.handling]
статьи библиотеки,
[intro.structure]
продолжительность жизни,
[basic.life]
<limits>
,
[limits.syn]
пределы
реализация,
[defns.impl.limits]
сращивание линий,
[lex.phases]
linear_congruential_engine
алгоритм генерации,
[rand.eng.lcong]
модуль,
[rand.eng.lcong]
штат,
[rand.eng.lcong]
текстовое представление,
[rand.eng.lcong]
алгоритм перехода,
[rand.eng.lcong]
связь,
[basic]
,
[basic.link]
,
[basic.link]
const
а также,
[basic.link]
внешний,
[basic.link]
,
[using.linkage]
,
[extern.names]
объект, определяемый реализацией,
[dcl.link]
inline
а также,
[basic.link]
внутренний,
[basic.link]
нет,
[basic.link]
static
а также,
[basic.link]
спецификацию связи,
см.
specification, linkage
linkage-specification
,
[dcl.link]
<list>
,
[list.syn]
список-инициализация,
[dcl.init.list]
буквальный
[lex.literal]
,
[expr.prim.literal]
основание целого числа,
[lex.icon]
двоичный
[lex.icon]
логическое значение
[lex.bool]
char16_t
,
[lex.ccon]
char32_t
,
[lex.ccon]
персонаж,
[lex.ccon]
char16_t
,
[lex.ccon]
char32_t
,
[lex.ccon]
обычный,
[lex.ccon]
UTF-8,
[lex.ccon]
широкий,
[lex.ccon]
постоянный,
[lex.literal.kinds]
десятичный,
[lex.icon]
десятичное число с плавающей запятой,
[lex.fcon]
double
,
[lex.fcon]
float
,
[lex.fcon]
плавающий
[lex.fcon]
шестнадцатеричный
[lex.icon]
шестнадцатеричный с плавающей запятой,
[lex.fcon]
значение
char
, определяемое реализацией ,
[lex.ccon]
целое число
[lex.icon]
,
[lex.icon]
long
,
[lex.icon]
long double
,
[lex.fcon]
многосимвольный,
[lex.ccon]
значение, определяемое реализацией,
[lex.ccon]
узкоспециализированный,
[lex.ccon]
восьмеричный
[lex.icon]
указатель,
[lex.nullptr]
нить,
[lex.string]
char16_t
,
[lex.string]
char32_t
,
[lex.string]
узкий,
[lex.string]
сырье,
[lex.pptoken]
,
[lex.string]
тип,
[lex.string]
неопределенное изменение на,
[lex.string]
UTF-8,
[lex.string]
широкий,
[lex.string]
тип персонажа,
[lex.ccon]
тип с плавающей точкой,
[lex.fcon]
тип целого числа,
[lex.icon]
unsigned
,
[lex.icon]
определяемые пользователем,
[lex.ext]
буквальный тип,
[basic.types]
живые мертвецы
название,
[zombie.names]
местный класс,
[class.local]
друг
[class.friend]
функция-член в,
[class.mfct]
объем,
[class.local]
локальное лямбда-выражение,
[expr.prim.lambda.capture]
локальный охват,
см.
block scope
локальная переменная,
[basic.scope.block]
разрушение
[stmt.jump]
,
[stmt.dcl]
local_iterator
,
[unord.req]
<locale>
,
[locale.syn]
,
[locale]
локаль,
[re.def]
,
[defns.regex.matched]
,
[re.req]
,
[re.synopt]
поведение, зависящее от локали,
см.
behavior, locale-specific
<locale.h>
,
[clocale.syn]
безблокировочное исполнение,
[intro.progress]
lognormal_distribution
функция плотности вероятности,
[rand.dist.norm.lognormal]
long
typedef
а также,
[dcl.spec]
Погляди
аргумент-зависимый,
[basic.lookup.argdep]
член класса,
[class.qual]
,
[basic.lookup.classref]
разработанный спецификатор типа,
[basic.lookup.elab]
имя члена,
[class.member.lookup]
имя,
[basic.lookup]
,
[basic]
псевдонимы пространств имен и,
[basic.lookup.udir]
член пространства имен,
[namespace.qual]
полное имя,
[basic.lookup.qual]
Имя Шаблона,
[temp.res]
неквалифицированное имя,
[basic.lookup.unqual]
директивы using и,
[basic.lookup.udir]
lookup_classname
признаки регулярного выражения
[re.req]
,
[re.grammar]
lookup_collatename
особенности регулярных выражений,
[re.req]
младший бит,
[intro.memory]
строчные буквы,
[character.seq]
lvalue
[basic.lval]
,
[diff.expr]
ссылка lvalue
[basic.compound]
,
[dcl.ref]
Lvalue-Callable,
[func.wrap.func]
макрос
подстановка аргументов,
[cpp.subst]
функция, как,
[cpp.replace]
,
[cpp.replace]
аргументы
[cpp.replace]
маскировка
[res.on.macro.definitions]
имя,
[cpp.replace]
Объект-подобный,
[cpp.replace]
,
[cpp.replace]
оператор прагмы,
[cpp.pragma.op]
предопределенный,
[cpp.predefined]
замена,
[cpp.replace]
список замены,
[cpp.replace]
повторное сканирование и замена,
[cpp.rescan]
объем определения,
[cpp.scope]
main
функция
[basic.start.main]
привязка, определяемая реализацией,
[basic.start.main]
параметры, определяемые реализацией,
[basic.start.main]
параметры к,
[basic.start.main]
возвращения из,
[basic.start.main]
,
[basic.start.term]
прогрессировать
нить,
[intro.progress]
<map>
,
[associative.map.syn]
match_results
как последовательность,
[re.results]
совпадает,
[defns.regex.format.specifier]
математические специальные функции,
[sf.cmath]
max
требование распределения случайных чисел,
[rand.req.dist]
требование единого генератора случайных битов,
[rand.req.urng]
иметь в виду
normal_distribution
,
[rand.dist.norm.normal]
poisson_distribution
,
[rand.dist.pois.poisson]
член
класс
static
,
[basic.stc.static]
инициализатор по умолчанию,
[class.mem]
счетчик
[dcl.enum]
статичны,
[class.mem]
,
[class.static]
шаблон и
static
,
[temp.static]
оператор доступа к членам
перегружен,
[over.ref]
данные участника
статический
[class.static.data]
функция-член,
[class.mem]
вызов undefined,
[class.mfct.non-static]
класс,
[class.mfct]
const
,
[class.this]
конструктор и,
[class.ctor]
деструктор и,
[class.dtor]
друг
[class.friend]
в линию,
[class.mfct]
местный класс,
[class.local]
вложенный класс,
[class.access.nest]
нестатический,
[class.mfct.non-static]
разрешение перегрузки и,
[over.match.funcs]
статичны,
[class.mem]
,
[class.static.mfct]
this
,
[class.this]
union
,
[class.union]
volatile
,
[class.this]
имена участников,
[basic.scope.namespace]
участник неизвестной специализации,
[temp.dep.type]
член текущего экземпляра,
см.
current instantiation, member of the
указатель на член,
см.
pointer to member
подобъект члена,
[intro.object]
члены,
[basic.scope.namespace]
<memory>
,
[memory.syn]
,
[depr.storage.iterator]
,
[depr.temporary.buffer]
место в памяти,
[intro.memory]
управление памятью,
см. также
new
,
delete
модель памяти,
[intro.memory]
<memory_resource>
,
[mem.res.syn]
mersenne_twister_engine
алгоритм генерации,
[rand.eng.mers]
штат,
[rand.eng.mers]
текстовое представление,
[rand.eng.mers]
алгоритм перехода,
[rand.eng.mers]
сообщение
диагностика
[defns.diagnostic]
,
[intro.compliance]
min
требование распределения случайных чисел,
[rand.req.dist]
требование единого генератора случайных битов,
[rand.req.urng]
изменяемый,
[basic.lval]
порядок модификации,
[intro.races]
больше cv-квалифицированных,
[basic.type.qualifier]
более специализированный
шаблон класса,
[temp.class.order]
шаблон функции,
[temp.deduct.partial]
самый производный класс,
[intro.object]
самый производный объект,
[intro.object]
битовое поле,
[intro.object]
подобъект нулевого размера,
[intro.object]
двигаться
объект класса,
см.
constructor, move
,
см.
assignment operator, move
MoveInsertable
в
X
,
[container.requirements.general]
многопроходная гарантия,
[forward.iterators]
многобайтовый символ,
см.
character, multibyte
многосимвольный литерал,
см.
literal, multicharacter
multiline
,
[re.synopt]
множественное наследование,
[class.derived]
,
[class.mi]
virtual
а также,
[class.virtual]
несколько потоков,
см.
threads, multiple
mutable
,
[dcl.stc]
,
[gram.dcl]
изменяемый итератор,
[iterator.requirements.general]
<mutex>
,
[mutex.syn]
типы мьютексов,
[thread.mutex.requirements.mutex]
n
n
(сферические функции Неймана),
[sf.cmath.sph_neumann]
N
ν
(Функции Неймана),
[sf.cmath.cyl_neumann]
имя,
[lex.name]
,
[basic]
,
[expr.prim.id]
адрес квалифицированного резюме,
[expr.unary.op]
зависимая,
[temp.dep.res]
,
[temp.dep]
разработан
enum
,
[dcl.type.elab]
Глобальный,
[basic.scope.namespace]
длина,
[lex.name]
макрос,
см.
macro, name
пункт декларации,
[basic.scope.pdecl]
предопределенный макрос,
см.
macro, predefined
квалифицированный,
[basic.lookup.qual]
зарезервированный,
[reserved.names]
тем же,
[basic]
объем,
[basic.scope.declarative]
неквалифицированный,
[basic.lookup.unqual]
живой мертвец,
[zombie.names]
название класса,
см.
class name
имя укрывистость
[basic.scope.pdecl]
,
[basic.scope.hiding]
,
[expr.prim.id.qual]
,
[stmt.dcl]
определение класса,
[class.name]
функция
[over.dcl]
перегрузка против,
[over.dcl]
определяемое пользователем преобразование и,
[class.conv]
объявление-использование и,
[namespace.udecl]
пространство имен
метка,
[stmt.label]
Пространство имен
[contents]
,
[depr.c.headers]
псевдоним
[namespace.alias]
связанный,
[basic.lookup.argdep]
определение,
[namespace.def]
продлевать,
[namespace.def]
Глобальный,
[lex.name]
определение члена,
[namespace.memdef]
безымянный
[namespace.unnamed]
пространства имен,
[basic.namespace]
NaN,
[sf.cmath]
сужение конверсии,
[dcl.init.list]
NDEBUG
,
[using.headers]
нужный
спецификация исключения,
[except.spec]
negative_binomial_distribution
дискретная функция вероятности,
[rand.dist.bern.negbin]
вложенный класс,
[class.nest]
местный класс,
[class.local]
объем,
[class.nest]
вложенный в,
[intro.object]
Функции Неймана
n
n
,
[sf.cmath.sph_neumann]
N
ν
,
[sf.cmath.cyl_neumann]
<new>
,
[new.syn]
new
,
[basic.stc.dynamic]
,
[expr.new]
массив объектов класса и,
[expr.new]
конструктор и,
[expr.new]
конструктор по умолчанию и,
[expr.new]
исключение и,
[expr.new]
инициализация и,
[expr.new]
operator
сменный,
[replacement.functions]
определение объема работ и,
[expr.new]
распределение памяти,
[expr.new]
тип,
[class.free]
неуказанный конструктор и,
[expr.new]
неустановленный порядок оценки,
[expr.new]
new-expression
размещение,
[expr.new]
новое-расширенное выравнивание,
[basic.align]
new_handler
,
[basic.stc.dynamic.allocation]
нет связи,
[basic.link]
без инициализации odr-use,
см.
odr-use, non-initialization
нестатический член данных,
[class.mem]
нестатический член,
[class.mem]
нестатическая функция-член,
[class.mem]
спецификация не вызывающего исключения исключения,
[except.spec]
нормальные распределения,
[rand.dist.norm]
normal_distribution
иметь в виду,
[rand.dist.norm.normal]
функция плотности вероятности,
[rand.dist.norm.normal]
среднеквадратичное отклонение,
[rand.dist.norm.normal]
нормативные ссылки,
см.
references, normative
обозначение
синтаксис,
[syntax]
НТБ
[byte.strings]
,
[multibyte.strings]
,
[filebuf.members]
,
[depr.istrstream.cons]
,
[depr.ostrstream.cons]
статический
[byte.strings]
NTCTS,
[defns.ntcts]
НТМБС,
[multibyte.strings]
статический
[multibyte.strings]
нулевой символ,
см.
character, null
значение нулевого указателя,
см.
value, null pointer
пустой оператор,
[stmt.expr]
нулевой широкий символ,
см.
wide-character, null
количество
шестнадцатеричный
[lex.ccon]
восьмеричный
[lex.ccon]
предварительная обработка,
[lex.ppnumber]
субнормальны,
[denorm.style]
,
[numeric.limits.members]
<numeric>
,
[numeric.ops.overview]
numeric_limits
,
[limits.syn]
специализации по арифметическим видам,
[basic.fundamental]
объект,
смотри также
object model
,
[intro.object]
,
[basic]
байтовое копирование и,
[basic.types]
полный,
[intro.object]
const,
[basic.type.qualifier]
const летучая,
[basic.type.qualifier]
определение,
[basic.def]
удалять,
[expr.delete]
деструктор и размещение,
[class.dtor]
деструктор статический,
[basic.start.term]
спецификация связи,
[dcl.link]
местный
static
,
[basic.stc.static]
вложенный в,
[intro.object]
предоставление хранилища для,
[intro.object]
безымянный
[class.ctor]
летучий
[basic.type.qualifier]
класс объекта,
см. также
class object
выражение объекта,
[expr.ref]
,
[expr.mptr.oper]
время жизни объекта,
[basic.life]
объектная модель,
[intro.object]
тип указателя объекта,
[basic.compound]
представление объекта,
[basic.types]
объект временный,
см.
temporary
тип объекта,
[basic.types]
не полностью определено,
[basic.types]
объект, исключение,
см.
exception handling, exception object
объектно-подобный макрос,
см.
macro, object-like
наблюдаемое поведение,
см.
behavior, observable
odr-use
неинициализация,
[basic.start.dynamic]
odr-б / у,
[basic.def.odr]
правило одного определения,
[basic.def]
операция
атомный
[intro.multithread]
оператор
[lex.operators]
,
[over.oper]
%=
,
[expr.ass]
&=
,
[expr.ass]
*=
,
[expr.ass]
+=
,
[expr.pre.incr]
,
[expr.ass]
-=
,
[expr.ass]
/=
,
[expr.ass]
<<=
,
[expr.ass]
>>=
,
[expr.ass]
^=
,
[expr.ass]
|=
,
[expr.ass]
добавление,
[expr.add]
добавка
[expr.add]
адрес
[expr.unary]
Назначение
[expr.ass]
,
[functions.within.classes]
побитовое,
[expr.bit.and]
побитовое И,
[expr.bit.and]
побитовое исключающее ИЛИ,
[expr.xor]
побитовое включающее ИЛИ,
[expr.or]
литье,
[expr.unary]
,
[dcl.name]
доступ к члену класса,
[expr.ref]
запятая
[expr.comma]
условное выражение,
[expr.cond]
копирование присвоения,
см.
assignment operator, copy
декремент,
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
разделение,
[expr.mul]
равенство,
[expr.eq]
вызов функции,
[expr.call]
,
[over.oper]
больше чем,
[expr.rel]
больше или равно,
[expr.rel]
приращение
[expr.post.incr]
,
[expr.unary]
,
[expr.pre.incr]
косвенное обращение,
[expr.unary]
неравенство,
[expr.eq]
левый "шифт,
[expr.shift]
меньше, чем,
[expr.rel]
меньше или равно,
[expr.rel]
логическое И,
[expr.log.and]
логическое отрицание,
[expr.unary]
,
[expr.unary.op]
логическое ИЛИ,
[expr.log.or]
переместить задание,
см.
assignment operator, move
умножение
[expr.mul]
мультипликативный
[expr.mul]
дополнение
[expr.unary]
,
[expr.unary.op]
перегружен
[expr]
,
[over.oper]
указатель на член,
[expr.mptr.oper]
прагма,
см.
macro, pragma operator
приоритет,
[intro.execution]
реляционный
[expr.rel]
остаток
[expr.mul]
сдвиг вправо,
[expr.shift]
разрешения области видимости,
[basic.lookup.qual]
,
[expr.prim.id.qual]
,
[expr.new]
,
[class.mfct]
,
[class.derived]
,
[class.virtual]
побочные эффекты и запятая,
[expr.comma]
побочные эффекты и логическое И,
[expr.log.and]
побочные эффекты и логическое ИЛИ,
[expr.log.or]
sizeof
,
[expr.unary]
,
[expr.sizeof]
индексации,
[expr.sub]
,
[over.oper]
вычитание
[expr.add]
унарный,
[expr.unary]
,
[expr.unary.op]
унарный минус
[expr.unary]
,
[expr.unary.op]
унарный плюс
[expr.unary]
,
[expr.unary.op]
operator delete
,
Смотри также
delete
,
[expr.new]
,
[expr.delete]
,
[class.free]
operator new
,
см. также
new
,
[expr.new]
перегрузка оператора,
см.
overloading, operator
использование оператора
разрешение прицела,
[class.static.data]
operator!=
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
operator()
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
требование единого генератора случайных битов,
[rand.req.urng]
operator<<
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
operator==
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
operator>>
требование распределения случайных чисел,
[rand.req.dist]
требование механизма случайных чисел,
[rand.req.eng]
операторы
встроенный,
[expr]
оптимизация временного,
см.
temporary, elimination of
<optional>
,
[optional.syn]
необязательный объект,
[optional.general]
порядок оценки в выражении
см.
expression, order of evaluation of
порядок исполнения
конструктор базового класса,
[class.ctor]
деструктор базового класса,
[class.dtor]
конструктор и массив,
[class.init]
конструктор и
static
объекты,
[class.expl.init]
деструктор
[class.dtor]
деструктор и массив,
[class.dtor]
конструктор-член,
[class.ctor]
деструктор члена,
[class.dtor]
заказ
частичный шаблон функции,
см.
template, function, partial ordering
обычный символьный литерал,
[lex.ccon]
обычный строковый литерал,
[lex.string]
<ostream>
,
[ostream.syn]
чрезмерно выровненный шрифт,
см.
type, over-aligned
переполнение
[expr]
неопределенный,
[expr]
перегруженная функция,
см.
overloading
адрес,
[expr.unary.op]
,
[over.over]
перегруженный оператор,
см.
overloading, operator
наследование,
[over.oper]
перегрузки
[dcl.fct]
,
[class.name]
,
[over]
,
[over]
,
[temp.over.link]
контроль доступа и,
[over.dcl]
адрес перегруженной функции,
[over.over]
списки аргументов,
[over.match.funcs]
массив против указателя,
[over.load]
оператор присваивания,
[over.ass]
бинарный оператор,
[over.binary]
встроенные операторы и,
[over.built]
кандидатские функции,
[over.match.funcs]
соответствие декларации,
[over.dcl]
декларации,
[over.load]
пример,
[over]
оператор вызова функции,
[over.call]
функция против указателя,
[over.load]
оператор доступа к участникам,
[over.ref]
оператор
[over.oper]
запрещенный,
[over.load]
разрешающая способность,
[over.match]
лучшая жизнеспособная функция,
[over.match.best]
контексты,
[over.match]
синтаксис вызова функции,
[over.match.call]
шаблон функции,
[temp.over]
неявные преобразования и,
[over.best.ics]
инициализации
[over.match.ctor]
,
[over.match.copy]
,
[over.match.conv]
,
[over.match.ref]
,
[over.match.list]
операторы,
[over.match.oper]
неоднозначность объема работ,
[class.member.lookup]
шаблон,
[temp.func.order]
Имя Шаблона,
[temp.res]
жизнеспособные функции,
[over.match.viable]
индексирующий оператор,
[over.sub]
унарный оператор,
[over.unary]
определяемый пользователем литерал,
[over.literal]
директива using и,
[namespace.udir]
объявление-использование и,
[namespace.udecl]
перегрузки
плавающая запятая,
[cmplx.over]
владелец
финал
[class.virtual]
собственный,
[unique.ptr]
P
ℓ
(Полиномы Лежандра),
[sf.cmath.legendre]
P
m
ℓ
(ассоциированные полиномы Лежандра),
[sf.cmath.assoc_legendre]
расширение пакета,
[temp.variadic]
шаблон,
[temp.variadic]
pair
интерфейс кортежа к,
[pairs.general]
параллельный алгоритм,
[algorithms.parallel.defns]
параллельные гарантии продвижения вперед,
[intro.progress]
param
требование распределения случайных чисел,
[rand.req.dist]
требование последовательности семян,
[rand.req.seedseq]
param_type
требование распределения случайных чисел,
[rand.req.dist]
Параметр,
[defns.parameter]
,
[defns.parameter.macro]
,
[defns.parameter.templ]
оговорка о вылове,
[defns.parameter]
функция
[defns.parameter]
функционально-подобный макрос,
[defns.parameter.macro]
ссылка,
[dcl.ref]
объем,
[basic.scope.block]
шаблон
[defns.parameter.templ]
,
[basic.def]
void
,
[dcl.fct]
объявление параметра,
[basic.def]
список параметров
переменная
[expr.call]
,
[dcl.fct]
пакет параметров,
[temp.variadic]
нерасширенный
[temp.variadic]
список-типов-параметров,
[dcl.fct]
параметризованный тип,
см.
template
параметры
макрос
[cpp.replace]
равенство путей,
[fs.path.nonmember]
узор,
см.
pack expansion, pattern
период,
[character.seq]
этапы перевода,
см.
translation, phases
Π
(полные эллиптические интегралы),
[sf.cmath.comp_ellint_3]
Π
(неполные эллиптические интегралы),
[sf.cmath.ellint_3]
кусочное построение,
[pairs.pair]
piecewise_constant_distribution
границы интервалов,
[rand.dist.samp.pconst]
функция плотности вероятности,
[rand.dist.samp.pconst]
веса,
[rand.dist.samp.pconst]
piecewise_linear_distribution
границы интервалов,
[rand.dist.samp.plinear]
функция плотности вероятности,
[rand.dist.samp.plinear]
веса на границах,
[rand.dist.samp.plinear]
вычет типа заполнителя,
[dcl.type.auto.deduct]
размещение
new-expression
,
[expr.new]
синтаксис размещения
new
,
[expr.new]
простая атомарная операция без блокировки,
[support.signal]
POD класс,
[class]
Структура POD,
[class]
POD союз,
[class]
точка,
[basic.compound]
пункт декларации,
[basic.scope.pdecl]
указатель,
см. также
void*
составной указатель типа,
[expr]
целочисленное представление безопасно полученных,
[basic.stc.dynamic.safety]
безопасно выведенный,
[basic.stc.dynamic.safety]
к отслеживаемому объекту
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
нуль,
[conv.ptr]
литерал указателя,
см.
literal, pointer
указатель за концом,
[basic.compound]
указатель на,
[basic.compound]
указатель на член,
[basic.compound]
,
[expr.mptr.oper]
стрелочный переводчик,
[basic.compound]
Распределения Пуассона,
[rand.dist.pois]
poisson_distribution
дискретная функция вероятности,
[rand.dist.pois.poisson]
иметь в виду,
[rand.dist.pois.poisson]
классы ресурсов пула,
[mem.res.pool.overview]
бассейны
[mem.res.pool.overview]
численность населения,
[alg.random.sample]
POSIX,
[intro.refs]
расширенные регулярные выражения,
[re.synopt]
регулярные выражения,
[re.synopt]
постфикса
++
,
[expr.post.incr]
постфикс
++
и
--
перегрузка,
[over.inc]
постфикса
--
,
[expr.post.incr]
потенциальные результаты,
[basic.def.odr]
потенциальный объем,
[basic.scope.declarative]
потенциально одновременный,
[intro.races]
потенциально оценен,
[basic.def.odr]
потенциально бросающий
спецификация исключения,
[except.spec]
выражение,
[except.spec]
приоритет оператора,
см.
operator, precedence of
приставка
L
,
[lex.ccon]
,
[lex.string]
R
,
[lex.string]
u
,
[lex.ccon]
,
[lex.ccon]
,
[lex.string]
,
[lex.string]
u8
,
[lex.ccon]
,
[lex.string]
префикс
++
,
[expr.pre.incr]
префикс
++
и
--
перегрузка,
[over.inc]
префикс
--
,
[expr.pre.incr]
директива предварительной обработки,
[cpp]
условное включение,
[cpp.cond]
директивы предварительной обработки,
[cpp]
ошибка,
[cpp.error]
включение заголовка,
[cpp.include]
линейный контроль,
[cpp.line]
замена макроса,
см.
macro, replacement
нулевой,
[cpp.null]
прагма,
[cpp.pragma]
включение исходного файла,
[cpp.include]
шаблон основного класса,
см.
template, primary
класс первичной эквивалентности,
[defns.regex.matched]
private
,
см
access control,
private
функция плотности вероятности
cauchy_distribution
,
[rand.dist.norm.cauchy]
chi_squared_distribution
,
[rand.dist.norm.chisq]
exponential_distribution
,
[rand.dist.pois.exp]
extreme_value_distribution
,
[rand.dist.pois.extreme]
fisher_f_distribution
,
[rand.dist.norm.f]
gamma_distribution
,
[rand.dist.pois.gamma]
lognormal_distribution
,
[rand.dist.norm.lognormal]
normal_distribution
,
[rand.dist.norm.normal]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
student_t_distribution
,
[rand.dist.norm.t]
uniform_real_distribution
,
[rand.dist.uni.real]
weibull_distribution
,
[rand.dist.pois.weibull]
программа
[basic.link]
,
[basic.link]
плохо сформированный,
[defns.ill.formed]
Начните,
[basic.start.main]
прекращение,
[basic.start.term]
хорошо сформированные,
[defns.well.formed]
,
[intro.execution]
выполнение программы,
[intro.execution]
абстрактная машина
[intro.execution]
как если бы правило,
см.
as-if rule
выдвинутый арифметический тип,
[over.built]
выдвинутый интегральный тип,
[over.built]
продвижение
bool в int,
[conv.prom]
продвижение аргумента по умолчанию,
[expr.call]
плавающая запятая,
[conv.fpprom]
интеграл,
[conv.prom]
protected
,
см
access control,
protected
защита,
смотри
access control
,
[protection.within.classes]
обеспечивает хранение,
[intro.object]
prvalue,
[basic.lval]
имя-псевдодеструктора,
[expr.pseudo]
ptrdiff_t
,
[expr.add]
тип, определяемый реализацией,
[expr.add]
public
,
см
access control,
public
пунктуатор
[lex.operators]
квалификация
явный,
[basic.lookup.qual]
<queue>
,
[queue.syn]
<random>
,
[rand.synopsis]
распределение случайных чисел
bernoulli_distribution
,
[rand.dist.bern.bernoulli]
binomial_distribution
,
[rand.dist.bern.bin]
cauchy_distribution
,
[rand.dist.norm.cauchy]
chi_squared_distribution
,
[rand.dist.norm.chisq]
discrete_distribution
,
[rand.dist.samp.discrete]
exponential_distribution
,
[rand.dist.pois.exp]
extreme_value_distribution
,
[rand.dist.pois.extreme]
fisher_f_distribution
,
[rand.dist.norm.f]
gamma_distribution
,
[rand.dist.pois.gamma]
geometric_distribution
,
[rand.dist.bern.geo]
lognormal_distribution
,
[rand.dist.norm.lognormal]
negative_binomial_distribution
,
[rand.dist.bern.negbin]
normal_distribution
,
[rand.dist.norm.normal]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
poisson_distribution
,
[rand.dist.pois.poisson]
требования,
[rand.req.dist]
student_t_distribution
,
[rand.dist.norm.t]
uniform_int_distribution
,
[rand.dist.uni.int]
uniform_real_distribution
,
[rand.dist.uni.real]
weibull_distribution
,
[rand.dist.pois.weibull]
распределения случайных чисел
Бернулли,
[rand.dist.bern]
обычный,
[rand.dist.norm]
Пуассон,
[rand.dist.pois]
отбор проб
[rand.dist.samp]
униформа
[rand.dist.uni]
механизм случайных чисел
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
требования,
[rand.req.eng]
subtract_with_carry_engine
,
[rand.eng.sub]
с предопределенными параметрами,
[rand.predef]
адаптер механизма случайных чисел
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
с предопределенными параметрами,
[rand.predef]
генерация случайных чисел,
[rand]
дистрибутивы,
[rand.dist]
двигатели
[rand.eng]
предустановленные двигатели и адаптеры,
[rand.predef]
требования,
[rand.req]
синопсис,
[rand.synopsis]
коммунальные услуги,
[rand.util]
генератор случайных чисел,
см.
uniform random bit generator
random_device
свобода реализации,
[rand.device]
<ratio>
,
[ratio.syn]
необработанный строковый литерал,
[lex.string]
достигая размаха,
[expr.prim.lambda.capture]
готов
[re.results]
,
[futures.state]
переопределение
typedef
,
[dcl.typedef]
ссылка,
[basic.compound]
назначение,
[expr.ass]
позвонить,
[expr.call]
пересылка
[temp.deduct.call]
lvalue,
[basic.compound]
нулевой,
[dcl.ref]
rvalue,
[basic.compound]
sizeof
,
[expr.sizeof]
свертывание ссылок,
[dcl.ref]
справочно-совместимый,
[dcl.init.ref]
справочно-связанные,
[dcl.init.ref]
использованная литература
нормативный,
[intro.refs]
regex_iterator
конец последовательности,
[re.regiter]
regex_token_iterator
конец последовательности,
[re.tokiter]
regex_traits
специализации,
[re.traits]
область
декларативная
[basic]
,
[basic.scope.declarative]
register
класс хранения,
[diff.cpp14.dcl.dcl]
регулярное выражение,
[re]
грамматика
[re.grammar]
совпадает,
[defns.regex.format.specifier]
требования,
[re.req]
особенности регулярных выражений,
[re.grammar]
char_class_type
,
[re.req]
isctype
,
[re.req]
lookup_classname
,
[re.req]
,
[re.grammar]
lookup_collatename
,
[re.req]
требования
[re.req]
,
[re.traits]
transform
,
[re.req]
,
[re.grammar]
transform_primary
,
[re.req]
,
[re.grammar]
translate
,
[re.req]
,
[re.grammar]
translate_nocase
,
[re.req]
,
[re.grammar]
reinterpret_cast
,
см
cast, reinterpret
расслабленная безопасность указателя,
[basic.stc.dynamic.safety]
последовательность выпуска,
[intro.races]
оператор остатка,
см.
operator, remainder
замена
макрос,
см.
macro, replacement
представление
объект,
[basic.types]
ценить,
[basic.types]
представляет адрес,
[basic.compound]
требования,
[structure.requirements]
Allocator
,
[allocator.requirements]
Контейнер,
[container.requirements]
,
[unord.req]
,
[array.overview]
,
[array.cons]
,
[re.results]
не требуется для неупорядоченных связанных контейнеров,
[unord.req]
CopyAssignable
,
[utility.arg.requirements]
CopyConstructible
,
[utility.arg.requirements]
DefaultConstructible
,
[utility.arg.requirements]
Destructible
,
[utility.arg.requirements]
EqualityComparable
,
[utility.arg.requirements]
Hash
,
[hash.requirements]
итератор
[iterator.requirements.general]
LessThanComparable
,
[utility.arg.requirements]
MoveAssignable
,
[utility.arg.requirements]
MoveConstructible
,
[utility.arg.requirements]
NullablePointer
,
[nullablepointer.requirements]
числовой тип,
[numeric.requirements]
распределение случайных чисел,
[rand.req.dist]
механизм случайных чисел,
[rand.req.eng]
признаки регулярного выражения
[re.req]
,
[re.traits]
посевная последовательность,
[rand.req.seedseq]
последовательность,
[re.results]
единый генератор случайных битов,
[rand.req.urng]
неупорядоченный ассоциативный контейнер,
[unord.req]
повторное сканирование и замену
см.
macro, rescanning and replacement
зарезервированный идентификатор,
[lex.name]
сброс настроек,
[unique.ptr]
требование распределения случайных чисел,
[rand.req.dist]
разрешение,
см.
overloading, resolution
ограничение,
[res.on.arguments]
,
[res.on.required]
,
[res.on.macro.definitions]
,
[res.on.exception.handling]
адрес битового поля,
[class.bit]
анонимный
union
,
[class.union.anon]
битовое поле,
[class.bit]
конструктор,
[class.ctor]
деструктор
[class.dtor]
extern
,
[dcl.stc]
местный класс,
[class.local]
перегрузка оператора,
[over.oper]
перегрузка,
[over.oper]
указатель на битовое поле,
[class.bit]
ссылка,
[dcl.ref]
static
,
[dcl.stc]
статический член локального класса,
[class.local]
union
,
[class.union]
результат
glvalue,
[basic.lval]
prvalue,
[basic.lval]
объект результата,
[basic.lval]
result_type
характеристика объекта на основе,
[rand]
требование распределения случайных чисел,
[rand.req.dist]
требование последовательности семян,
[rand.req.seedseq]
требование единого генератора случайных битов,
[rand.req.urng]
перебросить,
посмотреть
exception handling, rethrow
return
,
[stmt.jump]
,
[stmt.return]
и обработчик,
[except]
и попробуйте заблокировать,
[except]
конструктор и,
[stmt.return]
ссылка и,
[dcl.init.ref]
return
заявление,
см.
return
тип возврата,
[dcl.fct]
ковариантный
[class.virtual]
перегрузка и,
[over.load]
сдвиг вправо
определяется реализацией,
[expr.shift]
оператор сдвига вправо,
см.
operator, right shift
округление
[conv.fpint]
rvalue,
[basic.lval]
именующее преобразование в,
см
conversion, lvalue to rvalue
,
[diff.expr]
ссылка rvalue
[basic.compound]
,
[dcl.ref]
безопасно полученный указатель,
[basic.stc.dynamic.safety]
целочисленное представление,
[basic.stc.dynamic.safety]
образец,
[alg.random.sample]
выборочные распределения,
[rand.dist.samp]
скалярный тип,
[basic.types]
Сфера,
[intro.scope]
,
[basic]
,
[basic.scope]
,
[basic.scope.declarative]
,
[dcl.dcl]
анонимный
union
в пространстве имен,
[class.union.anon]
блокировать,
[basic.scope.block]
класс,
[basic.scope.class]
декларации и,
[basic.scope.declarative]
деструктор и выход из,
[stmt.jump]
перечисление
[basic.scope.enum]
объявление исключения,
[basic.scope.block]
функция
[basic.funscope]
прототип функции,
[basic.scope.proto]
Глобальный,
[basic.scope.namespace]
глобальное пространство имен,
[basic.scope.namespace]
iteration-statement
,
[stmt.iter]
определение макроса,
см.
macro, scope of definition
поиск имени и,
[basic.lookup]
пространство имен,
[basic.scope.namespace]
перегрузка и,
[over.dcl]
потенциал
[basic.scope.declarative]
selection-statement
,
[stmt.select]
параметр шаблона,
[basic.scope.temp]
скрытие имени области и,
[basic.scope.hiding]
оператор разрешения области видимости,
см.
operator, scope resolution
<scoped_allocator>
,
[allocator.adaptor.syn]
seed
требование механизма случайных чисел,
[rand.req.eng]
посевная последовательность,
[rand.req.seedseq]
требования,
[rand.req.seedseq]
семантика
член класса
[expr.ref]
отдельная компиляция,
см.
compilation, separate
отдельный перевод,
см.
compilation, separate
последовательность
неоднозначное преобразование,
[over.best.ics]
неявное преобразование,
[over.best.ics]
разделены относительно,
[alg.sorting]
стандартное преобразование,
[conv]
конструктор последовательности
требование последовательности семян,
[rand.req.seedseq]
последовательность после,
[intro.execution]
в последовательности раньше,
[intro.execution]
оператор последовательности,
см.
operator, comma
<set>
,
[associative.set.syn]
<setjmp.h>
,
[csetjmp.syn]
setlocale
,
[character.seq]
общая блокировка,
[thread.sharedmutex.requirements]
общие типы мьютексов,
[thread.sharedmutex.requirements]
общее состояние,
см.
future, shared state
общий тип синхронизированного мьютекса,
[thread.sharedtimedmutex.requirements]
<shared_mutex>
,
[shared_mutex.syn]
оператор смены
слева,
см
operator, left shift
правильно,
смотри
operator, right shift
short
typedef
а также,
[dcl.spec]
shuffle_order_engine
алгоритм генерации,
[rand.adapt.shuf]
штат,
[rand.adapt.shuf]
текстовое представление,
[rand.adapt.shuf]
алгоритм перехода,
[rand.adapt.shuf]
побочные эффекты,
[intro.execution]
,
[intro.races]
,
[intro.execution]
,
[expr.log.and]
,
[expr.log.or]
,
[stmt.expr]
,
[class.temporary]
,
[class.base.init]
,
[class.copy.elision]
,
[cpp.scope]
,
[res.on.data.races]
видно,
[intro.races]
,
[intro.races]
сигнал
[intro.execution]
сигнально-безопасный
_Exit
,
[support.start.term]
abort
,
[support.start.term]
оценка,
см.
evaluation, signal-safe
forward
,
[forward]
initializer_list
функции,
[support.initlist]
memcpy
,
[cstring.syn]
memmove
,
[cstring.syn]
move
,
[forward]
move_if_noexcept
,
[forward]
numeric_limits
члены,
[numeric.limits.members]
quick_exit
,
[support.start.term]
signal
,
[support.signal]
типовые черты,
[meta]
<signal.h>
,
[csignal.syn]
подпись,
[defns.signature]
,
[defns.signature.templ]
,
[defns.signature.spec]
,
[defns.signature.member]
,
[defns.signature.member.templ]
,
[defns.signature.member.spec]
signed
typedef
а также,
[dcl.spec]
целочисленное представление со знаком
обратный код,
[basic.fundamental]
,
[expr.unary.op]
,
[dcl.enum]
подписали величину,
[basic.fundamental]
,
[dcl.enum]
дополнение до двух,
[basic.fundamental]
,
[conv.integral]
,
[dcl.enum]
,
[ratio.ratio]
,
[atomics.types.int]
знаковый целочисленный тип,
[basic.fundamental]
значимое
[lex.fcon]
похожие типы,
[conv.qual]
простая оболочка вызова,
[func.require]
size
требование последовательности семян,
[rand.req.seedseq]
size_t
,
[expr.sizeof]
умные указатели,
[unique.ptr.special]
исходный файл
[lex.separate]
,
[using.headers]
,
[alt.headers]
символ исходного файла,
см.
character, source file
Космос
белый,
[lex.pptoken]
специальная функция-член,
см.
constructor
,
см.
destructor
,
см.
assignment operator
специализация
шаблон класса,
[temp.names]
частичный шаблон класса
[temp.class.spec]
,
[temp.class.spec]
шаблон,
[temp.spec]
шаблон явный,
[temp.expl.spec]
Технические характеристики
связь,
[dcl.link]
extern
,
[dcl.link]
определяется реализацией,
[dcl.link]
гнездование
[dcl.link]
аргумент шаблона,
[temp.arg.explicit]
технические характеристики
Исключение стандартной библиотеки C,
[res.on.exception.handling]
C ++,
[res.on.exception.handling]
спецификатор,
[dcl.spec]
constexpr
,
[dcl.constexpr]
конструктор
[dcl.constexpr]
,
[dcl.constexpr]
функция
[dcl.constexpr]
,
[dcl.constexpr]
cv-квалификатор,
[dcl.type.cv]
декларация
[dcl.spec]
explicit
,
[dcl.fct.spec]
friend
,
[dcl.friend]
,
[protection.within.classes]
функция
[dcl.fct.spec]
inline
,
[dcl.inline]
static
,
[dcl.stc]
класс хранения,
[dcl.stc]
типа,
см
type specifier
typedef
,
[dcl.typedef]
virtual
,
[dcl.fct.spec]
доступ к спецификатору,
см.
access specifier
сферические гармоники
Y
m
ℓ
,
[sf.cmath.sph_legendre]
<sstream>
,
[sstream.syn]
устойчивый алгоритм,
[defns.stable]
,
[algorithm.stable]
<stack>
,
[stack.syn]
размотка стека,
[except.ctor]
стандарт
структура,
[intro.structure]
среднеквадратичное отклонение
normal_distribution
,
[rand.dist.norm.normal]
стандартный целочисленный тип,
[basic.fundamental]
стандартный целочисленный тип со знаком,
[basic.fundamental]
стандартный беззнаковый целочисленный тип,
[basic.fundamental]
класс типовой верстки,
[class]
структура стандартного макета,
[class]
типовые макеты,
[basic.types]
эталонный союз,
[class]
Начните
программа
[basic.start.dynamic]
запускать
программа
[using.linkage]
,
[replacement.functions]
штат,
[any.class]
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
утверждение,
[stmt.stmt]
break
,
[stmt.jump]
,
[stmt.break]
сложный,
[stmt.block]
continue
,
[stmt.jump]
,
[stmt.cont]
continue
в
for
,
[stmt.for]
декларация
[stmt.dcl]
декларация в
for
,
[stmt.for]
декларация в
if
,
[stmt.stmt]
заявление в
switch
,
[stmt.stmt]
,
[stmt.switch]
декларация в
while
,
[stmt.while]
do
,
[stmt.iter]
,
[stmt.do]
пустой,
[stmt.expr]
выражение,
[stmt.expr]
провалиться,
[dcl.attr.fallthrough]
for
,
[stmt.iter]
,
[stmt.for]
goto
,
[stmt.label]
,
[stmt.jump]
,
[stmt.goto]
if
,
[stmt.select]
,
[stmt.if]
итерация
[stmt.iter]
Прыжок,
[stmt.jump]
с надписью,
[stmt.label]
нулевой,
[stmt.expr]
на основе диапазона
for
,
[stmt.ranged]
выбор
[stmt.select]
switch
,
[stmt.select]
,
[stmt.switch]
,
[stmt.break]
while
,
[stmt.iter]
,
[stmt.while]
static
,
[dcl.stc]
,
[gram.dcl]
уничтожение местных,
[stmt.dcl]
связь
[basic.link]
,
[dcl.stc]
перегрузка и,
[over.load]
статический член данных,
[class.mem]
статическая инициализация,
[basic.start.static]
статический член
[class.mem]
статическая функция-член,
[class.mem]
статическая продолжительность хранения,
[basic.stc.static]
статический тип,
см.
type, static
static_assert
,
[dcl.dcl]
не макрос,
[cassert.syn]
static_cast
,
см
cast, static
<stdarg.h>
,
[cstdarg.syn]
<stdatomic.h>
,
[headers]
,
[diff.mods.to.headers]
<stddef.h>
,
[lex.ccon]
,
[lex.string]
<stdexcept>
,
[std.exceptions]
,
[stdexcept.syn]
<stdio.h>
,
[cstdio.syn]
<stdlib.h>
,
[depr.c.headers]
<stdnoreturn.h>
,
[headers]
,
[diff.mods.to.headers]
класс хранения,
[basic]
срок хранения,
[basic.stc]
,
[basic.stc]
автоматический,
[basic.stc]
,
[basic.stc.auto]
член класса
[basic.stc.inherit]
динамический,
[basic.stc]
,
[basic.stc.dynamic]
,
[expr.new]
локальный объект,
[basic.stc.auto]
статичны,
[basic.stc]
,
[basic.stc.static]
нить,
[basic.stc]
,
[basic.stc.thread]
управление хранилищем,
см.
new
,
delete
транслировать
произвольно-позиционный,
[defns.arbitrary.stream]
репозиционный,
[defns.repositional.stream]
<streambuf>
,
[streambuf.syn]
строгая безопасность указателя,
[basic.stc.dynamic.safety]
<string>
,
[string.syn]
нить
отчетливый,
[lex.string]
байт с завершающим нулем,
[byte.strings]
тип символа с завершающим нулем,
[defns.ntcts]
многобайтовый с завершающим нулем,
[multibyte.strings]
sizeof
,
[lex.string]
тип,
[lex.string]
строковый литерал,
см.
literal, string
<string.h>
,
[cstring.syn]
<string_view>
,
[string.view.synop]
нанизать,
см.
#
operator
сильно бывает раньше,
[intro.races]
<strstream>
,
[depr.str.strstreams]
struct
class
против,
[class]
типовая планировка,
[class]
структурный тег,
см.
class name
структурированная привязка,
[dcl.struct.bind]
объявление структурированной привязки
[dcl.dcl]
,
[dcl.struct.bind]
student_t_distribution
функция плотности вероятности,
[rand.dist.norm.t]
подвыражение,
[defns.regex.regular.expression]
подвыражение,
[intro.execution]
субнормальное число,
см.
number, subnormal
субобъект,
смотри также
object model
,
[intro.object]
,
[intro.object]
индексирующий оператор
перегружен,
[over.sub]
правило подпоследовательности
перегрузка,
[over.ics.rank]
subtract_with_carry_engine
нести,
[rand.eng.sub]
алгоритм генерации,
[rand.eng.sub]
штат,
[rand.eng.sub]
текстовое представление,
[rand.eng.sub]
алгоритм перехода,
[rand.eng.sub]
вычитание
указатель, определяемый реализацией,
[expr.add]
оператор вычитания,
см.
operator, subtraction
суффикс
e
,
[lex.fcon]
,
[lex.fcon]
F
,
[lex.fcon]
,
[lex.fcon]
L
,
[lex.icon]
,
[lex.icon]
,
[lex.fcon]
,
[lex.fcon]
p
,
[lex.fcon]
,
[lex.fcon]
U
,
[lex.icon]
,
[lex.icon]
резюме
совместимость с ISO C,
[diff.iso]
совместимость с ISO C ++ 2003,
[diff.cpp03]
совместимость с ISO C ++ 2011,
[diff.cpp11]
совместимость с ISO C ++ 2014,
[diff.cpp14]
синтаксис,
[gram]
заменяемый,
[swappable.requirements]
заменяется на,
[swappable.requirements]
switch
и обработчик,
[except]
и попробуйте заблокировать,
[except]
синхронизировать с,
[intro.races]
синоним,
[namespace.alias]
введите имя как,
[dcl.typedef]
синтаксис
член класса
[expr.ref]
<system_error>
,
[system_error.syn]
целевой объект,
[func.def]
шаблон
[temp]
,
[temp]
класс,
[temp.class]
значение,
[temp]
функция
[temp.fct.spec]
эквивалент,
[temp.over.link]
функционально эквивалентен,
[temp.over.link]
частичный заказ,
[temp.func.order]
функция-член,
[temp.mem.func]
начальный,
[temp.class.spec]
статический член данных,
[temp]
Переменная,
[temp]
создание экземпляра шаблона,
[temp.spec]
Имя Шаблона
связь,
[temp]
параметр шаблона,
[basic.def]
пакет параметров шаблона,
[temp.variadic]
область параметров шаблона,
[basic.scope.temp]
template-argument
дефолт,
[temp.param]
шаблонный объект,
[temp]
временный,
[class.temporary]
конструктор для,
[class.temporary]
уничтожение,
[class.temporary]
деструктор для,
[class.temporary]
устранение,
[class.temporary]
,
[class.copy.elision]
генерация, определяемая реализацией,
[class.temporary]
порядок уничтожения,
[class.temporary]
terminate
,
[except.terminate]
называется,
[expr.throw]
,
[except.throw]
,
[except.spec]
,
[except.terminate]
прекращение
программа
[basic.start.main]
,
[basic.start.term]
терминология
указатель,
[basic.compound]
текстовое представление
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
<tgmath.h>
,
[diff.mods.to.headers]
this
,
[expr.prim.this]
,
[class.this]
тип,
[class.this]
this
указатель,
см.
this
<thread>
,
[thread.syn]
нить,
[intro.multithread]
поток исполнения,
[intro.multithread]
продолжительность хранения потока,
[basic.stc.thread]
thread_local
,
[dcl.stc]
,
[gram.dcl]
потоки
несколько,
[intro.multithread]
<threads.h>
,
[headers]
,
[diff.mods.to.headers]
throw
,
[expr.throw]
бросать,
смотри
exception handling, throwing
<time.h>
,
[ctime.syn]
типы синхронизированных мьютексов,
[thread.timedmutex.requirements]
жетон
[lex.token]
альтернатива
[lex.digraph]
предварительная обработка,
[lex.pptoken]
отслеживаемый объект-указатель
[basic.stc.dynamic.safety]
,
[res.on.pointer.storage]
черты,
[defns.traits]
передать право собственности,
[unique.ptr]
transform
признаки регулярного выражения
[re.req]
,
[re.grammar]
transform_primary
признаки регулярного выражения
[re.req]
,
[re.grammar]
Трансформация
[meta.rqmts]
алгоритм перехода
discard_block_engine
,
[rand.adapt.disc]
independent_bits_engine
,
[rand.adapt.ibits]
linear_congruential_engine
,
[rand.eng.lcong]
mersenne_twister_engine
,
[rand.eng.mers]
shuffle_order_engine
,
[rand.adapt.shuf]
subtract_with_carry_engine
,
[rand.eng.sub]
translate
признаки регулярного выражения
[re.req]
,
[re.grammar]
translate_nocase
признаки регулярного выражения
[re.req]
,
[re.grammar]
перевод
фазы,
[lex.phases]
отдельно,
см.
compilation, separate
единица перевода,
[lex.separate]
,
[basic.link]
имя и,
[basic]
последовательность триграфа,
[diff.cpp14.lex]
тривиальный класс,
[class]
тривиальный тип класса,
[expr.new]
тривиальный тип,
[expr.new]
тривиальные типы,
[basic.types]
тривиально копируемый класс,
[class]
тривиально копируемые типы,
[basic.types]
усечение
[conv.fpint]
try
,
[except]
попробуйте заблокировать,
посмотрите
exception handling, try block
<tuple>
,
[tuple.syn]
tuple
и
pair
,
[pairs.general]
типа,
[basic]
,
[basic.types]
выделено,
[expr.new]
арифметика,
[basic.fundamental]
продвинутый,
[over.built]
множество,
[basic.compound]
битовая маска
[bitmask.types]
,
[bitmask.types]
Логическое,
[basic.fundamental]
char
,
[basic.fundamental]
char16_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
char32_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
персонаж,
[basic.fundamental]
контейнер персонажа,
[defns.character.container]
класс и,
[class]
сложный,
[basic.compound]
const
,
[dcl.type]
CV-комбинированный,
[expr]
cv-неквалифицированный,
[basic.type.qualifier]
место назначения,
[dcl.init]
double
,
[basic.fundamental]
динамический,
[defns.dynamic.type]
,
[defns.dynamic.type.prvalue]
перечислительные,
[basic.compound]
,
[enumerated.types]
,
[bitmask.types]
пример неполного,
[basic.types]
расширенное целое число,
[basic.fundamental]
расширенное целое число со знаком,
[basic.fundamental]
расширенное целое число без знака,
[basic.fundamental]
float
,
[basic.fundamental]
плавающая запятая,
[basic.fundamental]
функция
[basic.compound]
,
[dcl.fct]
фундаментальный
[basic.fundamental]
определяется реализацией
sizeof
,
[basic.fundamental]
неполный,
[basic.def]
,
[basic.def.odr]
,
[basic.scope.pdecl]
,
[basic.types]
,
[conv.lval]
,
[expr.sub]
,
[expr.call]
,
[expr.type.conv]
,
[expr.ref]
,
[expr.dynamic.cast]
,
[expr.unary.op]
,
[expr.sizeof]
,
[expr.new]
,
[expr.delete]
,
[expr.ass]
,
[class.derived]
не полностью определенный объект,
[basic.types]
int
,
[basic.fundamental]
интеграл,
[basic.fundamental]
продвинутый,
[over.built]
long
,
[basic.fundamental]
long double
,
[basic.fundamental]
long long
,
[basic.fundamental]
узкий персонаж,
[basic.fundamental]
чрезмерно выровненный,
[basic.align]
POD,
[basic.types]
указатель,
[basic.compound]
полиморфный,
[class.virtual]
справочный,
[defns.referenceable]
short
,
[basic.fundamental]
signed char
,
[basic.fundamental]
целое со знаком,
[basic.fundamental]
аналогично,
см.
similar types
стандартное целое число,
[basic.fundamental]
стандартное целое число со знаком,
[basic.fundamental]
стандартное целое число без знака,
[basic.fundamental]
статический
[defns.static.type]
тривиально копируемый,
[basic.types]
лежащий в основе
char16_t
,
[basic.fundamental]
,
[conv.prom]
char32_t
,
[basic.fundamental]
,
[conv.prom]
перечисление
[conv.prom]
,
[dcl.enum]
фиксированный,
[dcl.enum]
wchar_t
,
[basic.fundamental]
,
[conv.prom]
unsigned
,
[basic.fundamental]
unsigned char
,
[basic.fundamental]
unsigned int
,
[basic.fundamental]
беззнаковое целое,
[basic.fundamental]
unsigned long
,
[basic.fundamental]
unsigned long long
,
[basic.fundamental]
unsigned short
,
[basic.fundamental]
void
,
[basic.fundamental]
volatile
,
[dcl.type]
wchar_t
,
[lex.ccon]
,
[lex.string]
,
[basic.fundamental]
,
[conv.rank]
проверка типа
аргумент
[expr.call]
преобразование типов, явное,
см.
casting
тип генератора,
см.
template
имя типа,
[dcl.name]
вложенный,
[class.nested.type]
объем,
[class.nested.type]
введите каламбур,
[expr.reinterpret.cast]
спецификатор типа
auto
,
[dcl.type.simple]
,
[dcl.spec.auto]
bool
,
[dcl.type.simple]
char
,
[dcl.type.simple]
char16_t
,
[dcl.type.simple]
char32_t
,
[dcl.type.simple]
const
,
[dcl.type.cv]
decltype
,
[dcl.type.simple]
double
,
[dcl.type.simple]
развернутый,
[basic.lookup.elab]
,
[dcl.type.elab]
enum
,
[dcl.type.elab]
float
,
[dcl.type.simple]
int
,
[dcl.type.simple]
long
,
[dcl.type.simple]
short
,
[dcl.type.simple]
signed
,
[dcl.type.simple]
просто,
[dcl.type.simple]
unsigned
,
[dcl.type.simple]
void
,
[dcl.type.simple]
volatile
,
[dcl.type.cv]
wchar_t
,
[dcl.type.simple]
type-name
,
[dcl.type.simple]
type_info
,
[expr.typeid]
<type_traits>
,
[meta.type.synop]
,
[depr.meta.types]
typedef
функция
[dcl.fct]
перегрузка и,
[over.load]
typeid
,
[expr.typeid]
строительство и,
[class.cdtor]
разрушение и,
[class.cdtor]
<typeindex>
,
[type.index.synopsis]
<typeinfo>
,
[typeinfo.syn]
typename
,
[dcl.type.elab]
типы
определяется реализацией,
[type.descriptions.general]
<uchar.h>
,
[cuchar.syn]
унарная складка,
[expr.prim.fold]
унарная левая складка,
[expr.prim.fold]
унарный оператор
интерпретация,
[over.unary]
перегружен,
[over.unary]
унарная правая складка,
[expr.prim.fold]
UnaryTypeTrait,
[meta.rqmts]
разблокировать
[defns.unblock]
неопределен,
[defns.required.behavior]
,
[defns.reserved.function]
,
[reserved.names]
,
[alt.headers]
,
[res.on.arguments]
,
[valarray.comparison]
,
[class.gslice.overview]
,
[indirect.array.assign]
,
[indirect.array.comp.assign]
,
[fpos.operations]
неопределенное поведение,
см.
behavior, undefined
базовый тип,
см.
type, underlying
неоцененный операнд,
[expr]
Требуемый набор Unicode,
[cpp.predefined]
равномерные распределения,
[rand.dist.uni]
однородный генератор случайных битов
требования,
[rand.req.urng]
uniform_int_distribution
дискретная функция вероятности,
[rand.dist.uni.int]
uniform_real_distribution
функция плотности вероятности,
[rand.dist.uni.real]
union
,
[basic.compound]
,
[class.union]
анонимный
[class.union.anon]
class
против,
[class]
глобальный анонимный,
[class.union.anon]
типовая планировка,
[class]
профсоюзный класс,
[class.union.anon]
уникальный указатель,
[unique.ptr]
Ед. изм
перевод
[using.headers]
,
[macro.names]
универсальное имя персонажа,
[lex.phases]
безымянное битовое поле,
[class.bit]
неупорядоченные ассоциативные контейнеры,
[unord.req]
сложность,
[unord.req]
функция равенства,
[unord.req]
эквивалентные ключи,
[unord.req]
,
[unord.multimap.overview]
,
[unord.multiset.overview]
безопасность исключений,
[unord.req.except]
хеш-функция,
[unord.req]
аннулирование итератора,
[unord.req]
итераторы,
[unord.req]
отсутствие функций сравнения,
[unord.req]
требования
[unord.req]
,
[unord.req.except]
уникальные ключи,
[unord.req]
,
[unord.map.overview]
,
[unord.set.overview]
<unordered_map>
,
[unord.map.syn]
unordered_map
доступ к элементу,
[unord.map.elem]
уникальные ключи,
[unord.map.overview]
unordered_multimap
эквивалентные ключи,
[unord.multimap.overview]
unordered_multiset
эквивалентные ключи,
[unord.multiset.overview]
<unordered_set>
,
[unord.set.syn]
unordered_set
уникальные ключи,
[unord.set.overview]
непоследовательный,
[intro.execution]
unsigned
typedef
а также,
[dcl.spec]
беззнаковый целочисленный тип,
[basic.fundamental]
неопределенные,
[new.delete.single]
,
[type.info]
,
[partial.sort]
,
[stringbuf.virtuals]
,
[depr.strstreambuf.cons]
,
[depr.strstreambuf.virtuals]
неопределенное поведение,
см.
behavior, unspecified
раскручивание
куча,
[except.ctor]
прописные буквы
[lex.name]
,
[character.seq]
вверх по течению,
[mem.res.monotonic.buffer]
распределитель восходящего потока,
[mem.res.pool.overview]
определяемый пользователем литерал,
см.
literal, user-defined
перегружен,
[over.literal]
предоставляется пользователем,
[dcl.fct.def.default]
конструкция использует-распределитель,
[allocator.uses.construction]
объявление об использовании,
[namespace.udecl]
директива using,
[namespace.udir]
обычные арифметические преобразования,
см.
conversion, usual arithmetic
обычная функция освобождения памяти,
[basic.stc.dynamic.deallocation]
Символьный литерал UTF-8,
[lex.ccon]
Строковый литерал UTF-8,
[lex.string]
<utility>
,
[utility]
<valarray>
,
[valarray.syn]
действительный,
[basic.scope.declarative]
действительное, но неуказанное состояние,
[defns.valid]
ценить,
[basic.types]
позвонить,
[expr.call]
денормализованный,
см.
number, subnormal
неопределенный,
[dcl.init]
указатель на нулевой член,
[conv.mem]
нулевой указатель
[basic.compound]
,
[conv.ptr]
неопределенный непредставимый интеграл,
[conv.fpint]
ценностная категория,
[basic.lval]
вычисление значения,
[intro.execution]
,
[intro.races]
,
[expr.post.incr]
,
[expr.new]
,
[expr.log.and]
,
[expr.log.or]
,
[expr.cond]
,
[expr.ass]
,
[expr.comma]
,
[class.temporary]
представление значения,
[basic.types]
инициализация значения,
[dcl.init]
Переменная,
[basic]
неопределенный неинициализированный,
[dcl.init]
шаблон переменных
значение,
[temp]
<variant>
,
[variant.syn]
вариантный член,
[class.union.anon]
<vector>
,
[vector.syn]
векторизация-небезопасная,
[algorithms.parallel.exec]
виртуальный базовый класс,
см.
base class, virtual
виртуальная функция,
[class.virtual]
чистый,
[class.abstract]
,
[class.abstract]
вызов виртуальной функции,
[class.virtual]
конструктор и,
[class.cdtor]
деструктор и,
[class.cdtor]
неопределенный чистый,
[class.abstract]
видимость,
[basic.scope.hiding]
видимый,
[basic.scope.hiding]
void&
,
[dcl.ref]
void*
тип,
[basic.compound]
volatile
,
[basic.type.qualifier]
конструктор и
[class.this]
,,
[class.ctor]
деструктор и
[class.this]
,
[class.dtor]
определяется реализацией,
[dcl.type.cv]
перегрузка и,
[over.load]
летучие,
[basic.type.qualifier]
функция ожидания,
[futures.state]
<wchar.h>
,
[cwchar.syn]
wchar_t
,
см
type,
wchar_t
<wctype.h>
,
[cwctype.syn]
слабый тип результата,
[depr.weak.result_type]
слабо параллельные гарантии продвижения вперед,
[intro.progress]
weibull_distribution
функция плотности вероятности,
[rand.dist.pois.weibull]
веса
discrete_distribution
,
[rand.dist.samp.discrete]
piecewise_constant_distribution
,
[rand.dist.samp.pconst]
веса на границах
piecewise_linear_distribution
,
[rand.dist.samp.plinear]
грамотно сформированная программа,
см.
program, well-formed
белое пространство
[lex.token]
широкий строковый литерал,
[lex.string]
широкий характер,
[lex.ccon]
нулевой,
[lex.charset]
литерал с широкими символами,
[lex.ccon]
набор расширенных символов
базовое исполнение,
[lex.charset]
исполнение,
[lex.charset]
записываемый,
[iterator.requirements.general]
X(X&)
,
см
constructor, copy
xvalue,
[basic.lval]
Y
m
ℓ
(сферические ассоциированные функции Лежандра),
[sf.cmath.sph_legendre]
нуль
деление на неопределенное,
[expr]
остаток не определен,
[expr]
неопределенное деление на,
[expr.mul]
нулевая инициализация,
[dcl.init]
дзета-функции
ζ
,
[sf.cmath.riemann_zeta]