Создано 24.03.2017 на основе стандарта C ++ draft LaTeX sources пользователем cxxdraft-htmlgen. Это не публикация ISO.

Contents

List of Tables [tab][tab]

1 Альтернативные токены 2 Допустимые диапазоны символов 3 Диапазоны символов, изначально запрещенные (объединение символов) 4 Идентификаторы со специальным значением 5 Ключевые слова 6 Альтернативные представления 7 Типы целочисленных литералов 8 Escape-последовательности 9 Конкатенации строковых литералов 10 Отношения между и 11 и типы, которые они задают 12 Взаимосвязь между оператором и обозначением вызова функции 13 Преобразования 14 Значение сворачивания пустых последовательностей 15 Категории библиотек 16 Заголовки библиотеки C ++ 17 Заголовки библиотеки C ++ 18 Имена приложений K стандарта C 19 Заголовки C ++ для автономных реализаций 20 требований 21 требований 22 требований 23 требований 24 требования (в дополнение к ) 25 требований 26 требований (в дополнение к ) 27 требований 28 требований 29 требований 30 Описательные определения переменных 31 Требования к распределителю 32 Сводка библиотеки языкаой поддержки 33 Сводка библиотеки диагностики 34 Сводка библиотеки общих утилит 35 эффектов 36 эффектов 37 эффектов 38 эффект s 39 эффектов 40 Предикаты категории первичного типа 41 Предикаты категории составного типа 42 Предикаты свойств типа 43 Запросы свойств типа 44 Предикаты отношений типов 45 Постоянно изменчивые модификации 46 Модификации ссылок 47 Модификации знаков 48 Модификации массивов 49 Модификации указателей 50 Другие преобразования 51 Выражения, используемые для выполнения арифметика соотношения 52 Требования к часам 53 Сводка библиотеки строк 54 Требования к характеристикам персонажей 55 эффекты 56 эффекты 57 и эффекты 58 эффекты 59 эффекты 60 эффекты 61 и эффекты 62 эффекты 63 результата 64 эффекта 65 эффектов 66 результатов 67 Дополнительные перегрузки сравнения 68 Сводка библиотеки локалей 69 Категория локали фасеты 70 Требуемые специализации 71 значения результатов 72 значения результатов 73 Целочисленные преобразования 74 Модификатор длины 75 Целочисленные преобразования 76 Преобразования с плавающей запятой 77 Модификатор длины 78 Числовые преобразования 79 Заполнение заполнения 80 эффектов 81 Потенциальные гонки данных 82 Сводка библиотеки контейнеров 83 Требования к контейнерам 84 Re гибкие требования к контейнерам 85 Необязательные операции с контейнерами 86 Требования к контейнерам с учетом распределителя 87 Требования к контейнерам последовательности (в дополнение к контейнеру) 88 Операции с дополнительными контейнерами последовательности 89 Типы контейнеров с совместимыми узлами 90 Требования к ассоциативным контейнерам (в дополнение к контейнеру) 91 Требования к неупорядоченным ассоциативным контейнерам ( в дополнение к контейнеру) 92 Сводка библиотеки итераторов 93 Взаимосвязи между категориями итераторов 94 Требования к итератору 95 Требования к итератору ввода (в дополнение к Iterator) 96 Требования к итератору вывода (в дополнение к Iterator) 97 Требования к итератору вперед (в дополнение к итератору ввода) 98 Двунаправленный Требования к итератору (в дополнение к прямому итератору) 99 Требования к итератору с произвольным доступом (в дополнение к двунаправленному итератору) 100 Сводка библиотеки алгоритмов 101 Сводка библиотеки числовых значений 102 Требования к начальной последовательности 103 Требования к унифицированному генератору случайных битов 104 Требования к механизму случайных чисел 105 Rand Требования к распределению номеров 106 Сводка библиотеки ввода / вывода 107 эффектов 108 констант 109 эффектов 110 эффектов 111 эффектов 112 Требования к типу позиции 113 эффектов 114 эффектов 115 позиционирования 116 значений 117 Режимы открытия файлов 118 эффектов 119 эффектов 120 эффектов 121 эффектов 122 Enum 123 Enum class 124 Enum class 125 Enum class 126 Enum class 127 Enum class 128 Сводка библиотеки регулярных выражений 129 Требования к классу свойств регулярных выражений 130 влияют на 131 эффект при получении совпадения с последовательностью контейнера символов . 132 значения в локали C 133 Имена классов символов и соответствующие маски 134 эффекты оператора присваивания 135 Эффекты алгоритма 136 Эффекты алгоритма 137 Сводка библиотеки Atomics 138 Вычисления атомарной арифметики 139 Вычисления атомарных указателей 140 Сводка библиотеки поддержки потоков 141 Заголовки C 142 эффектов 143 эффекта 144 эффекты 145 позиционирование 146 значений[tab:alternative.tokens]
[tab:charname.allowed]
[tab:charname.disallowed]
[tab:identifiers.special]
[tab:keywords]
[tab:alternative.representations]
[tab:lex.type.integer.literal]
[tab:escape.sequences]
[tab:lex.string.concat]
const volatile[tab:relations.on.const.and.volatile]
simple-type-specifiers [tab:simple.type.specifiers]
[tab:over.rel.op.func]
[tab:over.conversions]
[tab:fold.empty]
[tab:library.categories]
[tab:cpp.library.headers]
[tab:cpp.c.headers]
[tab:c.annex.k.names]
[tab:cpp.headers.freestanding]
EqualityComparable [tab:equalitycomparable]
LessThanComparable [tab:lessthancomparable]
DefaultConstructible [tab:defaultconstructible]
MoveConstructible [tab:moveconstructible]
CopyConstructible MoveConstructible[tab:copyconstructible]
MoveAssignable [tab:moveassignable]
CopyAssignable MoveAssignable[tab:copyassignable]
Destructible [tab:destructible]
NullablePointer [tab:nullablepointer]
Hash [tab:hash]
[tab:desc.var.def]
[tab:utilities.allocator.requirements]
[tab:lang.sup.lib.summary]
[tab:diagnostics.lib.summary]
[tab:util.lib.summary]
optional​::​operator=(const optional&) [tab:optional.assign.copy]
optional​::​operator=(optional&&) [tab:optional.assign.move]
optional​::​operator=(const optional<U>&) [tab:optional.assign.copy.templ]
optional​::​operator=(optional<U>&&) [tab:optional.assign.move.templ]
optional​::​swap(optional&) [tab:optional.swap]
[tab:type-traits.primary]
[tab:type-traits.composite]
[tab:type-traits.properties]
[tab:type-traits.properties.queries]
[tab:type-traits.relationship]
[tab:type-traits.const-volatile]
[tab:type-traits.reference]
[tab:type-traits.sign]
[tab:type-traits.array]
[tab:type-traits.pointer]
[tab:type-traits.other]
[tab:ratio.arithmetic]
[tab:time.clock]
[tab:strings.lib.summary]
[tab:char.traits.require]
basic_­string(const Allocator&) [tab:strings.ctr.1]
basic_­string(const basic_­string&) [tab:strings.ctr.cpy]
basic_­string(const basic_­string&, size_­type, const Allocator&)
basic_­string(const basic_­string&, size_­type, size_­type, const Allocator&) [tab:strings.ctr.2]
basic_­string(const charT*, size_­type, const Allocator&) [tab:strings.ctr.3]
basic_­string(const charT*, const Allocator&) [tab:strings.ctr.4]
basic_­string(size_­t, charT, const Allocator&) [tab:strings.ctr.5]
basic_­string(const basic_­string&, const Allocator&)
basic_­string(basic_­string&&, const Allocator&) [tab:strings.ctr.6]
operator=(const basic_­string&) [tab:strings.op=]
compare() [tab:strings.compare]
basic_­string_­view(const charT*) [tab:string.view.ctr.2]
basic_­string_­view(const charT*, size_­type) [tab:string.view.ctr.3]
compare() [tab:string.view.compare]
basic_­string_­view [tab:string.view.comparison.overloads]
[tab:localization.lib.summary]
[tab:localization.category.facets]
[tab:localization.required.specializations]
do_­in/do_­out [tab:localization.convert.result.values.out.in]
do_­unshift [tab:localization.convert.result.values.unshift]
[tab:localization.integer.conversions.in]
[tab:localization.length.modifier.in]
[tab:localization.integer.conversions.out]
[tab:localization.fp.conversions.out]
[tab:localization.length.modifier.out]
[tab:localization.numeric.conversions]
[tab:localization.fill.padding]
do_­get_­date [tab:lib.locale.time.get.virtuals.dogetdate]
setlocale [tab:setlocale.data.races]
[tab:containers.lib.summary]
[tab:containers.container.requirements]
[tab:containers.reversible.requirements]
[tab:containers.optional.operations]
[tab:containers.allocatoraware]
[tab:containers.sequence.requirements]
[tab:containers.sequence.optional]
[tab:containers.node.compat]
[tab:containers.associative.requirements]
[tab:HashRequirements]
[tab:iterators.lib.summary]
[tab:iterators.relations]
[tab:iterator.requirements]
[tab:iterator.input.requirements]
[tab:iterator.output.requirements]
[tab:iterator.forward.requirements]
[tab:iterator.bidirectional.requirements]
[tab:iterator.random.access.requirements]
[tab:algorithms.summary]
[tab:numerics.lib.summary]
[tab:SeedSequence]
[tab:UniformRandomBitGenerator]
[tab:RandomEngine]
[tab:RandomDistribution]
[tab:iostreams.lib.summary]
fmtflags [tab:iostreams.fmtflags.effects]
fmtflags [tab:iostreams.fmtflags.constants]
iostate [tab:iostreams.iostate.effects]
openmode [tab:iostreams.openmode.effects]
seekdir [tab:iostreams.seekdir.effects]
[tab:iostreams.position.requirements]
basic_­ios​::​init() [tab:iostreams.basicios.init.effects]
basic_­ios​::​copyfmt() [tab:iostreams.copyfmt.effects]
seekoff [tab:iostreams.seekoff.positioning]
newoff [tab:iostreams.newoff.values]
[tab:iostreams.file.open.modes]
seekoff [tab:iostreams.seekoff.effects]
filesystem_­error(const string&, error_­code) [tab:filesystem_error.1]
filesystem_­error(const string&, const path&, error_­code) [tab:filesystem_error.2]
filesystem_­error(const string&, const path&, const path&, error_­code) [tab:filesystem_error.3]
path​::​format[tab:enum.path.format]
file_­type[tab:fs.enum.file_type]
copy_­options[tab:fs.enum.copy_options]
perms[tab:fs.enum.perms]
perm_­options[tab:enum.perm_options]
directory_­options[tab:fs.enum.directory_options]
[tab:re.lib.summary]
[tab:re:RegexpTraits]
syntax_­option_­type [tab:re:syntaxoption]
regex_­constants​::​match_­flag_­type [first, last)[tab:re:matchflag]
error_­type [tab:re:errortype]
ctype [tab:re.traits.classnames]
match_­results [tab:re:results:assign]
regex_­match [tab:re:alg:match]
regex_­search [tab:re:alg:search]
[tab:atomics.lib.summary]
[tab:atomic.arithmetic.computations]
[tab:atomic.pointer.computations]
[tab:thread.lib.summary]
[tab:future.c.headers]
strstreambuf(streamsize) [tab:future.strstreambuf.effects]
strstreambuf(void* (*)(size_­t), void (*)(void*)) [tab:future.strstreambuf1.effects]
strstreambuf(charT*, streamsize, charT*) [tab:future.strstreambuf2.effects]
seekoff [tab:future.seekoff.positioning]
newoff [tab:future.newoff.values]

List of Figures [fig][fig]

1 Таксономия категорий выражений 2 Направленный ациклический граф 3 Не виртуальная база 4 Виртуальная база 5 Виртуальная и не виртуальная база 6 Поиск имени 7 Типы положения, смещения и размера потока [ненормативные][fig:categories]
[fig:dag]
[fig:nonvirt]
[fig:virt]
[fig:virtnonvirt]
[fig:name]
[fig:streampos]

2 Normative references [intro.refs][intro.refs]

3 Terms and definitions [intro.defs][intro.defs]

4 General principles [intro][intro]

4.1 Implementation compliance [intro.compliance]

4.2 Structure of this document [intro.structure]

4.3 Syntax notation [syntax]

4.4 The C++ memory model [intro.memory]

4.5 The C++ object model [intro.object]

4.6 Program execution [intro.execution]

4.7 Multi-threaded executions and data races [intro.multithread]

4.7.1 Data races [intro.races]

4.7.2 Forward progress [intro.progress]

4.8 Acknowledgments [intro.ack]

5 Lexical conventions [lex][lex]

5.1 Separate translation [lex.separate]

5.2 Phases of translation [lex.phases]

5.3 Character sets [lex.charset]

5.4 Preprocessing tokens [lex.pptoken]

5.5 Alternative tokens [lex.digraph]

5.8 Header names [lex.header]

5.9 Preprocessing numbers [lex.ppnumber]

5.10 Identifiers [lex.name]

5.11 Keywords [lex.key]

5.12 Operators and punctuators [lex.operators]

5.13 Literals [lex.literal]

5.13.1 Kinds of literals [lex.literal.kinds]

5.13.2 Integer literals [lex.icon]

5.13.3 Character literals [lex.ccon]

5.13.4 Floating literals [lex.fcon]

5.13.5 String literals [lex.string]

5.13.6 Boolean literals [lex.bool]

5.13.7 Pointer literals [lex.nullptr]

5.13.8 User-defined literals [lex.ext]

6 Basic concepts [basic][basic]

6.1 Declarations and definitions [basic.def]

6.2 One-definition rule [basic.def.odr]

6.3 Scope [basic.scope]

6.3.1 Declarative regions and scopes [basic.scope.declarative]

6.3.2 Point of declaration [basic.scope.pdecl]

6.3.4 Function prototype scope [basic.scope.proto]

6.3.5 Function scope [basic.funscope]

6.3.8 Enumeration scope [basic.scope.enum]

6.3.9 Template parameter scope [basic.scope.temp]

6.4 Name lookup [basic.lookup]

6.4.1 Unqualified name lookup [basic.lookup.unqual]

6.4.2 Argument-dependent name lookup [basic.lookup.argdep]

6.4.3 Qualified name lookup [basic.lookup.qual]

6.4.3.1 Class members [class.qual]

6.4.3.2 Namespace members [namespace.qual]

6.4.4 Elaborated type specifiers [basic.lookup.elab]

6.4.5 Class member access [basic.lookup.classref]

6.4.6 Using-directives and namespace aliases [basic.lookup.udir]

6.6 Start and termination [basic.start]

6.6.2 Static initialization [basic.start.static]

6.6.3 Dynamic initialization of non-local variables [basic.start.dynamic]

6.7 Storage duration [basic.stc]

6.7.1 Static storage duration [basic.stc.static]

6.7.2 Thread storage duration [basic.stc.thread]

6.7.3 Automatic storage duration [basic.stc.auto]

6.7.4 Dynamic storage duration [basic.stc.dynamic]

6.7.4.3 Safely-derived pointers [basic.stc.dynamic.safety]

6.7.5 Duration of subobjects [basic.stc.inherit]

6.8 Object lifetime [basic.life]

6.10 Lvalues and rvalues [basic.lval]

7 Standard conversions [conv][conv]

7.1 Lvalue-to-rvalue conversion [conv.lval]

7.2 Array-to-pointer conversion [conv.array]

7.3 Function-to-pointer conversion [conv.func]

7.4 Temporary materialization conversion [conv.rval]

7.5 Qualification conversions [conv.qual]

7.6 Integral promotions [conv.prom]

7.7 Floating-point promotion [conv.fpprom]

7.8 Integral conversions [conv.integral]

7.9 Floating-point conversions [conv.double]

7.10 Floating-integral conversions [conv.fpint]

7.11 Pointer conversions [conv.ptr]

7.12 Pointer to member conversions [conv.mem]

7.13 Function pointer conversions [conv.fctptr]

7.14 Boolean conversions [conv.bool]

7.15 Integer conversion rank [conv.rank]

8 Expressions [expr][expr]

8.2 Postfix expressions [expr.post]

8.2.1 Subscripting [expr.sub]

8.2.2 Function call [expr.call]

8.2.3 Explicit type conversion (functional notation) [expr.type.conv]

8.2.4 Pseudo destructor call [expr.pseudo]

8.2.5 Class member access [expr.ref]

8.2.6 Increment and decrement [expr.post.incr]

8.2.8 Type identification [expr.typeid]

8.3 Unary expressions [expr.unary]

8.3.1 Unary operators [expr.unary.op]

8.3.2 Increment and decrement [expr.pre.incr]

8.3.7 noexcept operator [expr.unary.noexcept]

8.4 Explicit type conversion (cast notation) [expr.cast]

8.5 Pointer-to-member operators [expr.mptr.oper]

8.6 Multiplicative operators [expr.mul]

8.7 Additive operators [expr.add]

8.8 Shift operators [expr.shift]

8.9 Relational operators [expr.rel]

8.10 Equality operators [expr.eq]

8.11 Bitwise AND operator [expr.bit.and]

8.12 Bitwise exclusive OR operator [expr.xor]

8.13 Bitwise inclusive OR operator [expr.or]

8.14 Logical AND operator [expr.log.and]

8.15 Logical OR operator [expr.log.or]

8.16 Conditional operator [expr.cond]

8.17 Throwing an exception [expr.throw]

8.18 Assignment and compound assignment operators [expr.ass]

8.19 Comma operator [expr.comma]

8.20 Constant expressions [expr.const]

9 Statements [stmt.stmt][stmt.stmt]

9.1 Labeled statement [stmt.label]

9.2 Expression statement [stmt.expr]

9.3 Compound statement or block [stmt.block]

9.4 Selection statements [stmt.select]

9.4.1 The if statement [stmt.if]

9.4.2 The switch statement [stmt.switch]

9.5 Iteration statements [stmt.iter]

9.5.1 The while statement [stmt.while]

9.5.2 The do statement [stmt.do]

9.5.3 The for statement [stmt.for]

9.5.4 The range-based for statement [stmt.ranged]

9.6 Jump statements [stmt.jump]

9.6.1 The break statement [stmt.break]

9.6.2 The continue statement [stmt.cont]

9.6.3 The return statement [stmt.return]

9.6.4 The goto statement [stmt.goto]

9.7 Declaration statement [stmt.dcl]

9.8 Ambiguity resolution [stmt.ambig]

10 Declarations [dcl.dcl][dcl.dcl]

10.1 Specifiers [dcl.spec]

10.1.1 Storage class specifiers [dcl.stc]

10.1.2 Function specifiers [dcl.fct.spec]

10.1.3 The typedef specifier [dcl.typedef]

10.1.4 The friend specifier [dcl.friend]

10.1.5 The constexpr specifier [dcl.constexpr]

10.1.6 The inline specifier [dcl.inline]

10.1.7 Type specifiers [dcl.type]

10.1.7.1 The cv-qualifiers [dcl.type.cv]

10.1.7.2 Simple type specifiers [dcl.type.simple]

10.1.7.3 Elaborated type specifiers [dcl.type.elab]

10.1.7.4 The auto specifier [dcl.spec.auto]

10.1.7.4.1 Placeholder type deduction [dcl.type.auto.deduct]

10.1.7.5 Deduced class template specialization types [dcl.type.class.deduct]

10.2 Enumeration declarations [dcl.enum]

10.3 Namespaces [basic.namespace]

10.3.1 Namespace definition [namespace.def]

10.3.1.1 Unnamed namespaces [namespace.unnamed]

10.3.1.2 Namespace member definitions [namespace.memdef]

10.3.2 Namespace alias [namespace.alias]

10.3.3 The using declaration [namespace.udecl]

10.3.4 Using directive [namespace.udir]

10.4 The asm declaration [dcl.asm]

10.6 Attributes [dcl.attr]

10.6.1 Attribute syntax and semantics [dcl.attr.grammar]

10.6.2 Alignment specifier [dcl.align]

10.6.3 Carries dependency attribute [dcl.attr.depend]

10.6.4 Deprecated attribute [dcl.attr.deprecated]

10.6.5 Fallthrough attribute [dcl.attr.fallthrough]

10.6.6 Maybe unused attribute [dcl.attr.unused]

10.6.7 Nodiscard attribute [dcl.attr.nodiscard]

10.6.8 Noreturn attribute [dcl.attr.noreturn]

11 Declarators [dcl.decl][dcl.decl]

11.1 Type names [dcl.name]

11.2 Ambiguity resolution [dcl.ambig.res]

11.3 Meaning of declarators [dcl.meaning]

11.3.1 Pointers [dcl.ptr]

11.3.2 References [dcl.ref]

11.3.3 Pointers to members [dcl.mptr]

11.3.5 Functions [dcl.fct]

11.3.6 Default arguments [dcl.fct.default]

11.4 Function definitions [dcl.fct.def]

11.4.2 Explicitly-defaulted functions [dcl.fct.def.default]

11.4.3 Deleted definitions [dcl.fct.def.delete]

11.5 Structured binding declarations [dcl.struct.bind]

11.6 Initializers [dcl.init]

11.6.2 Character arrays [dcl.init.string]

11.6.4 List-initialization [dcl.init.list]

12 Classes [class][class]

12.1 Class names [class.name]

12.2 Class members [class.mem]

12.2.1 Member functions [class.mfct]

12.2.2 Non-static member functions [class.mfct.non-static]

12.2.2.1 The this pointer [class.this]

12.2.3 Static members [class.static]

12.2.3.1 Static member functions [class.static.mfct]

12.2.3.2 Static data members [class.static.data]

12.2.4 Bit-fields [class.bit]

12.2.5 Nested class declarations [class.nest]

12.2.6 Nested type names [class.nested.type]

12.4 Local class declarations [class.local]

13 Derived classes [class.derived][class.derived]

13.1 Multiple base classes [class.mi]

13.2 Member name lookup [class.member.lookup]

13.3 Virtual functions [class.virtual]

13.4 Abstract classes [class.abstract]

14 Member access control [class.access][class.access]

14.1 Access specifiers [class.access.spec]

14.2 Accessibility of base classes and base class members [class.access.base]

14.4 Protected member access [class.protected]

14.5 Access to virtual functions [class.access.virt]

14.6 Multiple access [class.paths]

14.7 Nested classes [class.access.nest]

15 Special member functions [special][special]

15.1 Constructors [class.ctor]

15.2 Temporary objects [class.temporary]

15.3 Conversions [class.conv]

15.3.1 Conversion by constructor [class.conv.ctor]

15.3.2 Conversion functions [class.conv.fct]

15.4 Destructors [class.dtor]

15.5 Free store [class.free]

15.6 Initialization [class.init]

15.6.1 Explicit initialization [class.expl.init]

15.6.2 Initializing bases and members [class.base.init]

15.6.3 Initialization by inherited constructor [class.inhctor.init]

15.7 Construction and destruction [class.cdtor]

15.8 Copying and moving class objects [class.copy]

15.8.1 Copy/move constructors [class.copy.ctor]

15.8.2 Copy/move assignment operator [class.copy.assign]

15.8.3 Copy/move elision [class.copy.elision]

16 Overloading [over][over]

16.1 Overloadable declarations [over.load]

16.2 Declaration matching [over.dcl]

16.3 Overload resolution [over.match]

16.3.1 Candidate functions and argument lists [over.match.funcs]

16.3.1.1 Function call syntax [over.match.call]

16.3.1.1.1 Call to named function [over.call.func]

16.3.1.1.2 Call to object of class type [over.call.object]

16.3.1.2 Operators in expressions [over.match.oper]

16.3.1.3 Initialization by constructor [over.match.ctor]

16.3.1.4 Copy-initialization of class by user-defined conversion [over.match.copy]

16.3.1.5 Initialization by conversion function [over.match.conv]

16.3.1.6 Initialization by conversion function for direct reference binding [over.match.ref]

16.3.1.7 Initialization by list-initialization [over.match.list]

16.3.1.8 Class template argument deduction [over.match.class.deduct]

16.3.2 Viable functions [over.match.viable]

16.3.3 Best viable function [over.match.best]

16.3.3.1 Implicit conversion sequences [over.best.ics]

16.3.3.1.1 Standard conversion sequences [over.ics.scs]

16.3.3.1.2 User-defined conversion sequences [over.ics.user]

16.3.3.1.3 Ellipsis conversion sequences [over.ics.ellipsis]

16.3.3.1.4 Reference binding [over.ics.ref]

16.3.3.1.5 List-initialization sequence [over.ics.list]

16.3.3.2 Ranking implicit conversion sequences [over.ics.rank]

16.4 Address of overloaded function [over.over]

16.5 Overloaded operators [over.oper]

16.5.1 Unary operators [over.unary]

16.5.2 Binary operators [over.binary]

16.5.3 Assignment [over.ass]

16.5.4 Function call [over.call]

16.5.5 Subscripting [over.sub]

16.5.6 Class member access [over.ref]

16.5.7 Increment and decrement [over.inc]

16.5.8 User-defined literals [over.literal]

16.6 Built-in operators [over.built]

17 Templates [temp][temp]

17.1 Template parameters [temp.param]

17.2 Names of template specializations [temp.names]

17.3 Template arguments [temp.arg]

17.3.1 Template type arguments [temp.arg.type]

17.3.2 Template non-type arguments [temp.arg.nontype]

17.3.3 Template template arguments [temp.arg.template]

17.4 Type equivalence [temp.type]

17.5 Template declarations [temp.decls]

17.5.1 Class templates [temp.class]

17.5.1.1 Member functions of class templates [temp.mem.func]

17.5.1.2 Member classes of class templates [temp.mem.class]

17.5.1.3 Static data members of class templates [temp.static]

17.5.1.4 Enumeration members of class templates [temp.mem.enum]

17.5.2 Member templates [temp.mem]

17.5.3 Variadic templates [temp.variadic]

17.5.5 Class template partial specializations [temp.class.spec]

17.5.5.1 Matching of class template partial specializations [temp.class.spec.match]

17.5.5.2 Partial ordering of class template specializations [temp.class.order]

17.5.5.3 Members of class template specializations [temp.class.spec.mfunc]

17.5.6 Function templates [temp.fct]

17.5.6.2 Partial ordering of function templates [temp.func.order]

17.5.7 Alias templates [temp.alias]

17.6 Name resolution [temp.res]

17.6.1 Locally declared names [temp.local]

17.6.2 Dependent names [temp.dep]

17.6.2.1 Dependent types [temp.dep.type]

17.6.2.2 Type-dependent expressions [temp.dep.expr]

17.6.2.3 Value-dependent expressions [temp.dep.constexpr]

17.6.2.4 Dependent template arguments [temp.dep.temp]

17.6.3 Non-dependent names [temp.nondep]

17.6.4 Dependent name resolution [temp.dep.res]

17.6.4.1 Point of instantiation [temp.point]

17.6.4.2 Candidate functions [temp.dep.candidate]

17.6.5 Friend names declared within a class template [temp.inject]

17.7 Template instantiation and specialization [temp.spec]

17.7.1 Implicit instantiation [temp.inst]

17.7.2 Explicit instantiation [temp.explicit]

17.7.3 Explicit specialization [temp.expl.spec]

17.8 Function template specializations [temp.fct.spec]

17.8.1 Explicit template argument specification [temp.arg.explicit]

17.8.2 Template argument deduction [temp.deduct]

17.8.2.1 Deducing template arguments from a function call [temp.deduct.call]

17.8.2.2 Deducing template arguments taking the address of a function template [temp.deduct.funcaddr]

17.8.2.3 Deducing conversion function template arguments [temp.deduct.conv]

17.8.2.4 Deducing template arguments during partial ordering [temp.deduct.partial]

17.8.2.5 Deducing template arguments from a type [temp.deduct.type]

17.8.2.6 Deducing template arguments from a function declaration [temp.deduct.decl]

17.8.3 Overload resolution [temp.over]

17.9 Deduction guides [temp.deduct.guide]

18 Exception handling [except][except]

18.1 Throwing an exception [except.throw]

18.2 Constructors and destructors [except.ctor]

18.3 Handling an exception [except.handle]

18.4 Exception specifications [except.spec]

18.5 Special functions [except.special]

18.5.1 The std​::​terminate() function [except.terminate]

18.5.2 The std​::​uncaught_­exceptions() function [except.uncaught]

19 Preprocessing directives [cpp][cpp]

19.1 Conditional inclusion [cpp.cond]

19.2 Source file inclusion [cpp.include]

19.3 Macro replacement [cpp.replace]

19.3.1 Argument substitution [cpp.subst]

19.3.2 The # operator [cpp.stringize]

19.3.3 The ## operator [cpp.concat]

19.3.4 Rescanning and further replacement [cpp.rescan]

19.3.5 Scope of macro definitions [cpp.scope]

19.4 Line control [cpp.line]

19.5 Error directive [cpp.error]

19.6 Pragma directive [cpp.pragma]

19.7 Null directive [cpp.null]

19.8 Predefined macro names [cpp.predefined]

19.9 Pragma operator [cpp.pragma.op]

20 Library introduction [library][library]

20.2 The C standard library [library.c]

20.3 Definitions [definitions]

20.4 Method of description (Informative) [description]

20.5 Library-wide requirements [requirements]

20.5.1 Library contents and organization [organization]

20.5.1.1 Library contents [contents]

20.5.1.3 Freestanding implementations [compliance]

20.5.3 Requirements on types and expressions [utility.requirements]

20.5.3.1 Template argument requirements [utility.arg.requirements]

20.5.3.2 Swappable requirements [swappable.requirements]

20.5.3.3 NullablePointer requirements [nullablepointer.requirements]

20.5.3.4 Hash requirements [hash.requirements]

20.5.3.5 Allocator requirements [allocator.requirements]

20.5.3.5.1 Allocator completeness requirements [allocator.requirements.completeness]

20.5.4 Constraints on programs [constraints]

20.5.4.2 Namespace use [namespace.constraints]

20.5.4.2.3 Namespaces for future standardization [namespace.future]

20.5.4.3 Reserved names [reserved.names]

20.5.4.3.3 External linkage [extern.names]

20.5.4.3.5 User-defined literal suffixes [usrlit.suffix]

20.5.4.5 Derived classes [derived.classes]

20.5.4.6 Replacement functions [replacement.functions]

20.5.4.7 Handler functions [handler.functions]

20.5.4.9 Function arguments [res.on.arguments]

20.5.4.10 Library object access [res.on.objects]

20.5.4.11 Requires paragraph [res.on.required]

20.5.5 Conforming implementations [conforming]

20.5.5.3 Restrictions on macro definitions [res.on.macro.definitions]

20.5.5.4 Non-member functions [global.functions]

20.5.5.5 Member functions [member.functions]

20.5.5.6 Constexpr functions and constructors [constexpr.functions]

20.5.5.7 Requirements for stable algorithms [algorithm.stable]

20.5.5.9 Data race avoidance [res.on.data.races]

20.5.5.10 Protection within classes [protection.within.classes]

20.5.5.11 Derived classes [derivation]

20.5.5.12 Restrictions on exception handling [res.on.exception.handling]

20.5.5.13 Restrictions on storage of pointers [res.on.pointer.storage]

20.5.5.14 Value of error codes [value.error.codes]

20.5.5.15 Moved-from state of library types [lib.types.movedfrom]

21 Language support library [language.support][language.support]

21.2 Common definitions [support.types]

21.2.1 Header <cstddef> synopsis [cstddef.syn]

21.2.2 Header <cstdlib> synopsis [cstdlib.syn]

21.2.4 Sizes, alignments, and offsets [support.types.layout]

21.2.5 byte type operations [support.types.byteops]

21.3 Implementation properties [support.limits]

21.3.2 Header <limits> synopsis [limits.syn]

21.3.3 Floating-point type properties [fp.style]

21.3.3.1 Type float_­round_­style [round.style]

21.3.3.2 Type float_­denorm_­style [denorm.style]

21.3.4 Class template numeric_­limits [numeric.limits]

21.3.4.1 numeric_­limits members [numeric.limits.members]

21.3.4.2 numeric_­limits specializations [numeric.special]

21.3.5 Header <climits> synopsis [climits.syn]

21.3.6 Header <cfloat> synopsis [cfloat.syn]

21.4 Integer types [cstdint]

21.4.1 Header <cstdint> synopsis [cstdint.syn]

21.5 Start and termination [support.start.term]

21.6 Dynamic memory management [support.dynamic]

21.6.1 Header <new> synopsis [new.syn]

21.6.2 Storage allocation and deallocation [new.delete]

21.6.2.1 Single-object forms [new.delete.single]

21.6.2.3 Non-allocating forms [new.delete.placement]

21.6.3 Storage allocation errors [alloc.errors]

21.6.3.1 Class bad_­alloc [bad.alloc]

21.6.3.2 Class bad_­array_­new_­length [new.badlength]

21.6.3.3 Type new_­handler [new.handler]

21.6.3.4 set_­new_­handler [set.new.handler]

21.6.3.5 get_­new_­handler [get.new.handler]

21.6.4 Pointer optimization barrier [ptr.launder]

21.6.5 Hardware interference size [hardware.interference]

21.7 Type identification [support.rtti]

21.7.1 Header <typeinfo> synopsis [typeinfo.syn]

21.7.2 Class type_­info [type.info]

21.7.3 Class bad_­cast [bad.cast]

21.7.4 Class bad_­typeid [bad.typeid]

21.8 Exception handling [support.exception]

21.8.1 Header <exception> synopsis [exception.syn]

21.8.2 Class exception [exception]

21.8.3 Class bad_­exception [bad.exception]

21.8.4 Abnormal termination [exception.terminate]

21.8.4.1 Type terminate_­handler [terminate.handler]

21.8.4.2 set_­terminate [set.terminate]

21.8.4.3 get_­terminate [get.terminate]

21.8.5 uncaught_­exceptions [uncaught.exceptions]

21.8.6 Exception propagation [propagation]

21.8.7 nested_­exception [except.nested]

21.9 Initializer lists [support.initlist]

21.9.1 Header <initializer_­list> synopsis [initializer_list.syn]

21.9.2 Initializer list constructors [support.initlist.cons]

21.9.3 Initializer list access [support.initlist.access]

21.9.4 Initializer list range access [support.initlist.range]

21.10 Other runtime support [support.runtime]

21.10.1 Header <cstdarg> synopsis [cstdarg.syn]

21.10.2 Header <csetjmp> synopsis [csetjmp.syn]

21.10.3 Header <csignal> synopsis [csignal.syn]

21.10.4 Signal handlers [support.signal]

22 Diagnostics library [diagnostics][diagnostics]

22.2 Exception classes [std.exceptions]

22.2.1 Header <stdexcept> synopsis [stdexcept.syn]

22.2.2 Class logic_­error [logic.error]

22.2.3 Class domain_­error [domain.error]

22.2.4 Class invalid_­argument [invalid.argument]

22.2.5 Class length_­error [length.error]

22.2.6 Class out_­of_­range [out.of.range]

22.2.7 Class runtime_­error [runtime.error]

22.2.8 Class range_­error [range.error]

22.2.9 Class overflow_­error [overflow.error]

22.2.10 Class underflow_­error [underflow.error]

22.3 Assertions [assertions]

22.3.1 Header <cassert> synopsis [cassert.syn]

22.3.2 The assert macro [assertions.assert]

22.4 Error numbers [errno]

22.4.1 Header <cerrno> synopsis [cerrno.syn]

22.5 System error support [syserr]

22.5.1 Header <system_­error> synopsis [system_error.syn]

22.5.2 Class error_­category [syserr.errcat]

22.5.2.1 Class error_­category overview [syserr.errcat.overview]

22.5.2.2 Class error_­category virtual members [syserr.errcat.virtuals]

22.5.2.3 Class error_­category non-virtual members [syserr.errcat.nonvirtuals]

22.5.2.4 Program defined classes derived from error_­category [syserr.errcat.derived]

22.5.2.5 Error category objects [syserr.errcat.objects]

22.5.3 Class error_­code [syserr.errcode]

22.5.3.1 Class error_­code overview [syserr.errcode.overview]

22.5.3.2 Class error_­code constructors [syserr.errcode.constructors]

22.5.3.3 Class error_­code modifiers [syserr.errcode.modifiers]

22.5.3.4 Class error_­code observers [syserr.errcode.observers]

22.5.3.5 Class error_­code non-member functions [syserr.errcode.nonmembers]

22.5.4 Class error_­condition [syserr.errcondition]

22.5.4.1 Class error_­condition overview [syserr.errcondition.overview]

22.5.4.2 Class error_­condition constructors [syserr.errcondition.constructors]

22.5.4.3 Class error_­condition modifiers [syserr.errcondition.modifiers]

22.5.4.4 Class error_­condition observers [syserr.errcondition.observers]

22.5.4.5 Class error_­condition non-member functions [syserr.errcondition.nonmembers]

22.5.5 Comparison functions [syserr.compare]

22.5.6 System error hash support [syserr.hash]

22.5.7 Class system_­error [syserr.syserr]

22.5.7.1 Class system_­error overview [syserr.syserr.overview]

22.5.7.2 Class system_­error members [syserr.syserr.members]

23 General utilities library [utilities][utilities]

23.2 Utility components [utility]

23.2.1 Header <utility> synopsis [utility.syn]

23.2.5 Forward/move helpers [forward]

23.2.6 Function template as_­const [utility.as_const]

23.2.7 Function template declval [declval]

23.2.8 Primitive numeric output conversion [utility.to.chars]

23.2.9 Primitive numeric input conversion [utility.from.chars]

23.3 Compile-time integer sequences [intseq]

23.3.2 Class template integer_­sequence [intseq.intseq]

23.3.3 Alias template make_­integer_­sequence [intseq.make]

23.4 Pairs [pairs]

23.4.2 Class template pair [pairs.pair]

23.4.3 Specialized algorithms [pairs.spec]

23.4.4 Tuple-like access to pair [pair.astuple]

23.4.5 Piecewise construction [pair.piecewise]

23.5 Tuples [tuple]

23.5.2 Header <tuple> synopsis [tuple.syn]

23.5.3 Class template tuple [tuple.tuple]

23.5.3.1 Construction [tuple.cnstr]

23.5.3.4 Tuple creation functions [tuple.creation]

23.5.3.5 Calling a function with a tuple of arguments [tuple.apply]

23.5.3.6 Tuple helper classes [tuple.helper]

23.5.3.7 Element access [tuple.elem]

23.5.3.8 Relational operators [tuple.rel]

23.5.3.10 Tuple specialized algorithms [tuple.special]

23.6 Optional objects [optional]

23.6.2 Header <optional> synopsis [optional.syn]

23.6.4 No-value state indicator [optional.nullopt]

23.6.5 Class bad_­optional_­access [optional.bad.access]

23.6.6 Relational operators [optional.relops]

23.6.7 Comparison with nullopt [optional.nullops]

23.6.8 Comparison with T [optional.comp_with_t]

23.6.9 Specialized algorithms [optional.specalg]

23.7 Variants [variant]

23.7.2 Header <variant> synopsis [variant.syn]

23.7.4 variant helper classes [variant.helper]

23.7.5 Value access [variant.get]

23.7.6 Relational operators [variant.relops]

23.7.8 Class monostate [variant.monostate]

23.7.9 monostate relational operators [variant.monostate.relops]

23.7.10 Specialized algorithms [variant.specalg]

23.7.11 Class bad_­variant_­access [variant.bad.access]

23.7.12 Hash support [variant.hash]

23.7.13 Allocator-related traits [variant.traits]

23.8 Storage for any type [any]

23.8.1 Header <any> synopsis [any.synop]

23.8.2 Class bad_­any_­cast [any.bad_any_cast]

23.8.3 Class any [any.class]

23.8.3.1 Construction and destruction [any.cons]

23.8.4 Non-member functions [any.nonmembers]

23.9 Bitsets [bitset]

23.9.1 Header <bitset> synopsis [bitset.syn]

23.9.2 Class template bitset [template.bitset]

23.9.2.1 bitset constructors [bitset.cons]

23.9.2.2 bitset members [bitset.members]

23.9.3 bitset hash support [bitset.hash]

23.9.4 bitset operators [bitset.operators]

23.10 Memory [memory]

23.10.2 Header <memory> synopsis [memory.syn]

23.10.3 Pointer traits [pointer.traits]

23.10.3.1 Pointer traits member types [pointer.traits.types]

23.10.3.2 Pointer traits member functions [pointer.traits.functions]

23.10.6 Allocator argument tag [allocator.tag]

23.10.7 uses_­allocator [allocator.uses]

23.10.7.1 uses_­allocator trait [allocator.uses.trait]

23.10.7.2 Uses-allocator construction [allocator.uses.construction]

23.10.8 Allocator traits [allocator.traits]

23.10.8.1 Allocator traits member types [allocator.traits.types]

23.10.8.2 Allocator traits static member functions [allocator.traits.members]

23.10.9 The default allocator [default.allocator]

23.10.9.1 allocator members [allocator.members]

23.10.9.2 allocator globals [allocator.globals]

23.10.10 Specialized algorithms [specialized.algorithms]

23.10.10.2 uninitialized_­default_­construct [uninitialized.construct.default]

23.10.10.3 uninitialized_­value_­construct [uninitialized.construct.value]

23.10.10.4 uninitialized_­copy [uninitialized.copy]

23.10.10.5 uninitialized_­move [uninitialized.move]

23.10.10.6 uninitialized_­fill [uninitialized.fill]

23.10.11 C library memory allocation [c.malloc]

23.11 Smart pointers [smartptr]

23.11.1 Class template unique_­ptr [unique.ptr]

23.11.1.2 unique_­ptr for single objects [unique.ptr.single]

23.11.1.2.1 unique_­ptr constructors [unique.ptr.single.ctor]

23.11.1.2.2 unique_­ptr destructor [unique.ptr.single.dtor]

23.11.1.2.3 unique_­ptr assignment [unique.ptr.single.asgn]

23.11.1.3 unique_­ptr for array objects with a runtime length [unique.ptr.runtime]

23.11.1.3.1 unique_­ptr constructors [unique.ptr.runtime.ctor]

23.11.1.3.2 unique_­ptr assignment [unique.ptr.runtime.asgn]

23.11.1.4 unique_­ptr creation [unique.ptr.create]

23.11.1.5 unique_­ptr specialized algorithms [unique.ptr.special]

23.11.2 Shared-ownership pointers [util.smartptr]

23.11.2.1 Class bad_­weak_­ptr [util.smartptr.weak.bad]

23.11.2.3 Class template weak_­ptr [util.smartptr.weak]

23.11.2.3.1 weak_­ptr constructors [util.smartptr.weak.const]

23.11.2.3.6 weak_­ptr specialized algorithms [util.smartptr.weak.spec]

23.11.2.4 Class template owner_­less [util.smartptr.ownerless]

23.11.2.5 Class template enable_­shared_­from_­this [util.smartptr.enab]

23.11.2.6 shared_­ptr atomic access [util.smartptr.shared.atomic]

23.11.2.7 Smart pointer hash support [util.smartptr.hash]

23.12 Memory resources [mem.res]

23.12.1 Header <memory_­resource> synopsis [mem.res.syn]

23.12.2 Class memory_­resource [mem.res.class]

23.12.2.1 memory_­resource public member functions [mem.res.public]

23.12.2.2 memory_­resource private virtual member functions [mem.res.private]

23.12.2.3 memory_­resource equality [mem.res.eq]

23.12.3 Class template polymorphic_­allocator [mem.poly.allocator.class]

23.12.3.1 polymorphic_­allocator constructors [mem.poly.allocator.ctor]

23.12.3.2 polymorphic_­allocator member functions [mem.poly.allocator.mem]

23.12.3.3 polymorphic_­allocator equality [mem.poly.allocator.eq]

23.12.4 Access to program-wide memory_­resource objects [mem.res.global]

23.12.5 Pool resource classes [mem.res.pool]

23.12.5.1 Classes synchronized_­pool_­resource and unsynchronized_­pool_­resource [mem.res.pool.overview]

23.12.5.2 pool_­options data members [mem.res.pool.options]

23.12.5.3 Pool resource constructors and destructors [mem.res.pool.ctor]

23.12.5.4 Pool resource members [mem.res.pool.mem]

23.12.6 Class monotonic_­buffer_­resource [mem.res.monotonic.buffer]

23.12.6.1 monotonic_­buffer_­resource constructor and destructor [mem.res.monotonic.buffer.ctor]

23.12.6.2 monotonic_­buffer_­resource members [mem.res.monotonic.buffer.mem]

23.13 Class template scoped_­allocator_­adaptor [allocator.adaptor]

23.13.1 Header <scoped_­allocator> synopsis [allocator.adaptor.syn]

23.13.2 Scoped allocator adaptor member types [allocator.adaptor.types]

23.13.3 Scoped allocator adaptor constructors [allocator.adaptor.cnstr]

23.13.4 Scoped allocator adaptor members [allocator.adaptor.members]

23.13.5 Scoped allocator operators [scoped.adaptor.operators]

23.14 Function objects [function.objects]

23.14.1 Header <functional> synopsis [functional.syn]

23.14.2 Definitions [func.def]

23.14.3 Requirements [func.require]

23.14.4 Function template invoke [func.invoke]

23.14.5 Class template reference_­wrapper [refwrap]

23.14.5.1 reference_­wrapper construct/copy/destroy [refwrap.const]

23.14.5.2 reference_­wrapper assignment [refwrap.assign]

23.14.5.3 reference_­wrapper access [refwrap.access]

23.14.5.4 reference_­wrapper invocation [refwrap.invoke]

23.14.5.5 reference_­wrapper helper functions [refwrap.helpers]

23.14.7 Comparisons [comparisons]

23.14.7.1 Class template equal_­to [comparisons.equal_to]

23.14.7.2 Class template not_­equal_­to [comparisons.not_equal_to]

23.14.7.3 Class template greater [comparisons.greater]

23.14.7.4 Class template less [comparisons.less]

23.14.7.5 Class template greater_­equal [comparisons.greater_equal]

23.14.7.6 Class template less_­equal [comparisons.less_equal]

23.14.8 Logical operations [logical.operations]

23.14.8.1 Class template logical_­and [logical.operations.and]

23.14.8.2 Class template logical_­or [logical.operations.or]

23.14.8.3 Class template logical_­not [logical.operations.not]

23.14.9 Bitwise operations [bitwise.operations]

23.14.9.1 Class template bit_­and [bitwise.operations.and]

23.14.9.2 Class template bit_­or [bitwise.operations.or]

23.14.9.3 Class template bit_­xor [bitwise.operations.xor]

23.14.9.4 Class template bit_­not [bitwise.operations.not]

23.14.10 Function template not_­fn [func.not_fn]

23.14.11 Function object binders [func.bind]

23.14.11.1 Class template is_­bind_­expression [func.bind.isbind]

23.14.11.2 Class template is_­placeholder [func.bind.isplace]

23.14.11.3 Function template bind [func.bind.bind]

23.14.12 Function template mem_­fn [func.memfn]

23.14.13 Polymorphic function wrappers [func.wrap]

23.14.13.1 Class bad_­function_­call [func.wrap.badcall]

23.14.13.1.1 bad_­function_­call constructor [func.wrap.badcall.const]

23.14.13.2 Class template function [func.wrap.func]

23.14.13.2.1 function construct/copy/destroy [func.wrap.func.con]

23.14.13.2.5 function target access [func.wrap.func.targ]

23.14.13.2.6 null pointer comparison functions [func.wrap.func.nullptr]

23.14.13.2.7 specialized algorithms [func.wrap.func.alg]

23.14.14 Searchers [func.search]

23.14.14.1 Class template default_­searcher [func.search.default]

23.14.14.2 Class template boyer_­moore_­searcher [func.search.bm]

23.14.14.3 Class template boyer_­moore_­horspool_­searcher [func.search.bmh]

23.14.15 Class template hash [unord.hash]

23.15 Metaprogramming and type traits [meta]

23.15.1 Requirements [meta.rqmts]

23.15.2 Header <type_­traits> synopsis [meta.type.synop]

23.15.3 Helper classes [meta.help]

23.15.4 Unary type traits [meta.unary]

23.15.4.1 Primary type categories [meta.unary.cat]

23.15.4.2 Composite type traits [meta.unary.comp]

23.15.5 Type property queries [meta.unary.prop.query]

23.15.6 Relationships between types [meta.rel]

23.15.7 Transformations between types [meta.trans]

23.15.7.1 Const-volatile modifications [meta.trans.cv]

23.15.7.2 Reference modifications [meta.trans.ref]

23.15.7.3 Sign modifications [meta.trans.sign]

23.15.7.4 Array modifications [meta.trans.arr]

23.15.7.5 Pointer modifications [meta.trans.ptr]

23.15.7.6 Other transformations [meta.trans.other]

23.15.8 Logical operator traits [meta.logical]

23.16 Compile-time rational arithmetic [ratio]

23.16.2 Header <ratio> synopsis [ratio.syn]

23.16.3 Class template ratio [ratio.ratio]

23.16.4 Arithmetic on ratios [ratio.arithmetic]

23.16.5 Comparison of ratios [ratio.comparison]

23.16.6 SI types for ratio [ratio.si]

23.17 Time utilities [time]

23.17.2 Header <chrono> synopsis [time.syn]

23.17.3 Clock requirements [time.clock.req]

23.17.4 Time-related traits [time.traits]

23.17.4.1 treat_­as_­floating_­point [time.traits.is_fp]

23.17.4.3 Specializations of common_­type [time.traits.specializations]

23.17.5 Class template duration [time.duration]

23.17.5.1 duration constructors [time.duration.cons]

23.17.5.4 duration special values [time.duration.special]

23.17.5.5 duration non-member arithmetic [time.duration.nonmember]

23.17.5.8 Suffixes for duration literals [time.duration.literals]

23.17.5.9 duration algorithms [time.duration.alg]

23.17.6 Class template time_­point [time.point]

23.17.6.1 time_­point constructors [time.point.cons]

23.17.6.2 time_­point observer [time.point.observer]

23.17.6.3 time_­point arithmetic [time.point.arithmetic]

23.17.6.4 time_­point special values [time.point.special]

23.17.6.5 time_­point non-member arithmetic [time.point.nonmember]

23.17.6.6 time_­point comparisons [time.point.comparisons]

23.17.6.7 time_­point_­cast [time.point.cast]

23.17.7 Clocks [time.clock]

23.17.7.1 Class system_­clock [time.clock.system]

23.17.7.2 Class steady_­clock [time.clock.steady]

23.17.7.3 Class high_­resolution_­clock [time.clock.hires]

23.17.8 Header <ctime> synopsis [ctime.syn]

23.18 Class type_­index [type.index]

23.18.1 Header <typeindex> synopsis [type.index.synopsis]

23.18.2 type_­index overview [type.index.overview]

23.18.3 type_­index members [type.index.members]

23.19 Execution policies [execpol]

23.19.2 Header <execution> synopsis [execution.syn]

23.19.3 Execution policy type trait [execpol.type]

23.19.4 Sequenced execution policy [execpol.seq]

23.19.5 Parallel execution policy [execpol.par]

23.19.6 Parallel and unsequenced execution policy [execpol.parunseq]

23.19.7 Execution policy objects [execpol.objects]

24 Strings library [strings][strings]

24.2 Character traits [char.traits]

24.2.1 Character traits requirements [char.traits.require]

24.2.3 char_­traits specializations [char.traits.specializations]

24.2.3.1 struct char_­traits<char> [char.traits.specializations.char]

24.2.3.2 struct char_­traits<char16_­t> [char.traits.specializations.char16_t]

24.2.3.3 struct char_­traits<char32_­t> [char.traits.specializations.char32_t]

24.2.3.4 struct char_­traits<wchar_­t> [char.traits.specializations.wchar.t]

24.3 String classes [string.classes]

24.3.1 Header <string> synopsis [string.syn]

24.3.2 Class template basic_­string [basic.string]

24.3.2.1 basic_­string general requirements [string.require]

24.3.2.2 basic_­string constructors and assignment operators [string.cons]

24.3.2.3 basic_­string iterator support [string.iterators]

24.3.2.4 basic_­string capacity [string.capacity]

24.3.2.5 basic_­string element access [string.access]

24.3.2.6 basic_­string modifiers [string.modifiers]

24.3.2.6.1 basic_­string​::​operator+= [string.op+=]

24.3.2.6.2 basic_­string​::​append [string.append]

24.3.2.6.3 basic_­string​::​assign [string.assign]

24.3.2.6.4 basic_­string​::​insert [string.insert]

24.3.2.6.5 basic_­string​::​erase [string.erase]

24.3.2.6.6 basic_­string​::​replace [string.replace]

24.3.2.6.7 basic_­string​::​copy [string.copy]

24.3.2.6.8 basic_­string​::​swap [string.swap]

24.3.2.7 basic_­string string operations [string.ops]

24.3.2.7.1 basic_­string accessors [string.accessors]

24.3.2.7.2 basic_­string​::​find [string.find]

24.3.2.7.3 basic_­string​::​rfind [string.rfind]

24.3.2.7.4 basic_­string​::​find_­first_­of [string.find.first.of]

24.3.2.7.5 basic_­string​::​find_­last_­of [string.find.last.of]

24.3.2.7.6 basic_­string​::​find_­first_­not_­of [string.find.first.not.of]

24.3.2.7.7 basic_­string​::​find_­last_­not_­of [string.find.last.not.of]

24.3.2.7.8 basic_­string​::​substr [string.substr]

24.3.2.7.9 basic_­string​::​compare [string.compare]

24.3.3 basic_­string non-member functions [string.nonmembers]

24.3.3.9 Inserters and extractors [string.io]

24.3.4 Numeric conversions [string.conversions]

24.3.6 Suffix for basic_­string literals [basic.string.literals]

24.4 String view classes [string.view]

24.4.1 Header <string_­view> synopsis [string.view.synop]

24.4.2 Class template basic_­string_­view [string.view.template]

24.4.2.1 Construction and assignment [string.view.cons]

24.4.2.6 String operations [string.view.ops]

24.4.3 Non-member comparison functions [string.view.comparison]

24.4.4 Inserters and extractors [string.view.io]

24.4.6 Suffix for basic_­string_­view literals [string.view.literals]

24.5 Null-terminated sequence utilities [c.strings]

24.5.1 Header <cctype> synopsis [cctype.syn]

24.5.2 Header <cwctype> synopsis [cwctype.syn]

24.5.3 Header <cstring> synopsis [cstring.syn]

24.5.4 Header <cwchar> synopsis [cwchar.syn]

24.5.5 Header <cuchar> synopsis [cuchar.syn]

24.5.6 Multibyte / wide string and character conversion functions [c.mb.wcs]

25 Localization library [localization][localization]

25.2 Header <locale> synopsis [locale.syn]

25.3 Locales [locales]

25.3.1 Class locale [locale]

25.3.1.1 locale types [locale.types]

25.3.1.1.1 Type locale​::​category [locale.category]

25.3.1.1.2 Class locale​::​facet [locale.facet]

25.3.1.1.3 Class locale​::​id [locale.id]

25.3.1.2 locale constructors and destructor [locale.cons]

25.3.1.3 locale members [locale.members]

25.3.1.4 locale operators [locale.operators]

25.3.1.5 locale static members [locale.statics]

25.3.3 Convenience interfaces [locale.convenience]

25.3.3.1 Character classification [classification]

25.3.3.2 Conversions [conversions]

25.3.3.2.1 Character conversions [conversions.character]

25.4 Standard locale categories [locale.categories]

25.4.1 The ctype category [category.ctype]

25.4.1.1 Class template ctype [locale.ctype]

25.4.1.1.2 ctype virtual functions [locale.ctype.virtuals]

25.4.1.2 Class template ctype_­byname [locale.ctype.byname]

25.4.1.3 ctype specializations [facet.ctype.special]

25.4.1.3.1 ctype<char> destructor [facet.ctype.char.dtor]

25.4.1.3.3 ctype<char> static members [facet.ctype.char.statics]

25.4.1.3.4 ctype<char> virtual functions [facet.ctype.char.virtuals]

25.4.1.4 Class template codecvt [locale.codecvt]

25.4.1.4.2 codecvt virtual functions [locale.codecvt.virtuals]

25.4.1.5 Class template codecvt_­byname [locale.codecvt.byname]

25.4.2 The numeric category [category.numeric]

25.4.2.1 Class template num_­get [locale.num.get]

25.4.2.1.2 num_­get virtual functions [facet.num.get.virtuals]

25.4.2.2 Class template num_­put [locale.nm.put]

25.4.2.2.2 num_­put virtual functions [facet.num.put.virtuals]

25.4.3 The numeric punctuation facet [facet.numpunct]

25.4.3.1 Class template numpunct [locale.numpunct]

25.4.3.1.2 numpunct virtual functions [facet.numpunct.virtuals]

25.4.3.2 Class template numpunct_­byname [locale.numpunct.byname]

25.4.4 The collate category [category.collate]

25.4.4.1 Class template collate [locale.collate]

25.4.4.1.2 collate virtual functions [locale.collate.virtuals]

25.4.4.2 Class template collate_­byname [locale.collate.byname]

25.4.5 The time category [category.time]

25.4.5.1 Class template time_­get [locale.time.get]

25.4.5.1.2 time_­get virtual functions [locale.time.get.virtuals]

25.4.5.2 Class template time_­get_­byname [locale.time.get.byname]

25.4.5.3 Class template time_­put [locale.time.put]

25.4.5.3.2 time_­put virtual functions [locale.time.put.virtuals]

25.4.5.4 Class template time_­put_­byname [locale.time.put.byname]

25.4.6 The monetary category [category.monetary]

25.4.6.1 Class template money_­get [locale.money.get]

25.4.6.1.2 money_­get virtual functions [locale.money.get.virtuals]

25.4.6.2 Class template money_­put [locale.money.put]

25.4.6.2.2 money_­put virtual functions [locale.money.put.virtuals]

25.4.6.3 Class template moneypunct [locale.moneypunct]

25.4.6.3.2 moneypunct virtual functions [locale.moneypunct.virtuals]

25.4.6.4 Class template moneypunct_­byname [locale.moneypunct.byname]

25.4.7 The message retrieval category [category.messages]

25.4.7.1 Class template messages [locale.messages]

25.4.7.1.2 messages virtual functions [locale.messages.virtuals]

25.4.7.2 Class template messages_­byname [locale.messages.byname]

25.4.8 Program-defined facets [facets.examples]

25.5 C library locales [c.locales]

25.5.1 Header <clocale> synopsis [clocale.syn]

26 Containers library [containers][containers]

26.2 Container requirements [container.requirements]

26.2.1 General container requirements [container.requirements.general]

26.2.3 Sequence containers [sequence.reqmts]

26.2.4 Node handles [container.node]

26.2.4.1 node_­handle overview [container.node.overview]

26.2.4.2 node_­handle constructors, copy, and assignment [container.node.cons]

26.2.4.3 node_­handle destructor [container.node.dtor]

26.2.4.4 node_­handle observers [container.node.observers]

26.2.4.5 node_­handle modifiers [container.node.modifiers]

26.2.6 Associative containers [associative.reqmts]

26.2.6.1 Exception safety guarantees [associative.reqmts.except]

26.2.7 Unordered associative containers [unord.req]

26.2.7.1 Exception safety guarantees [unord.req.except]

26.3 Sequence containers [sequences]

26.3.2 Header <array> synopsis [array.syn]

26.3.3 Header <deque> synopsis [deque.syn]

26.3.4 Header <forward_­list> synopsis [forward_list.syn]

26.3.5 Header <list> synopsis [list.syn]

26.3.6 Header <vector> synopsis [vector.syn]

26.3.7 Class template array [array]

26.3.7.1 Class template array overview [array.overview]

26.3.7.2 array constructors, copy, and assignment [array.cons]

26.3.7.3 array specialized algorithms [array.special]

26.3.7.4 array​::​size [array.size]

26.3.7.5 array​::​data [array.data]

26.3.7.6 array​::​fill [array.fill]

26.3.7.7 array​::​swap [array.swap]

26.3.7.8 Zero sized arrays [array.zero]

26.3.7.9 Tuple interface to class template array [array.tuple]

26.3.8 Class template deque [deque]

26.3.8.1 Class template deque overview [deque.overview]

26.3.8.2 deque constructors, copy, and assignment [deque.cons]

26.3.8.3 deque capacity [deque.capacity]

26.3.8.4 deque modifiers [deque.modifiers]

26.3.8.5 deque specialized algorithms [deque.special]

26.3.9 Class template forward_­list [forwardlist]

26.3.9.1 Class template forward_­list overview [forwardlist.overview]

26.3.9.2 forward_­list constructors, copy, assignment [forwardlist.cons]

26.3.9.3 forward_­list iterators [forwardlist.iter]

26.3.9.4 forward_­list element access [forwardlist.access]

26.3.9.5 forward_­list modifiers [forwardlist.modifiers]

26.3.9.6 forward_­list operations [forwardlist.ops]

26.3.9.7 forward_­list specialized algorithms [forwardlist.spec]

26.3.10 Class template list [list]

26.3.10.1 Class template list overview [list.overview]

26.3.10.2 list constructors, copy, and assignment [list.cons]

26.3.10.5 list operations [list.ops]

26.3.10.6 list specialized algorithms [list.special]

26.3.11 Class template vector [vector]

26.3.11.1 Class template vector overview [vector.overview]

26.3.11.2 vector constructors, copy, and assignment [vector.cons]

26.3.11.5 vector modifiers [vector.modifiers]

26.3.11.6 vector specialized algorithms [vector.special]

26.3.12 Class vector<bool> [vector.bool]

26.4 Associative containers [associative]

26.4.2 Header <map> synopsis [associative.map.syn]

26.4.3 Header <set> synopsis [associative.set.syn]

26.4.4 Class template map [map]

26.4.4.1 Class template map overview [map.overview]

26.4.4.2 map constructors, copy, and assignment [map.cons]

26.4.4.3 map element access [map.access]

26.4.4.5 map specialized algorithms [map.special]

26.4.5 Class template multimap [multimap]

26.4.5.1 Class template multimap overview [multimap.overview]

26.4.5.2 multimap constructors [multimap.cons]

26.4.5.3 multimap modifiers [multimap.modifiers]

26.4.5.4 multimap specialized algorithms [multimap.special]

26.4.6 Class template set [set]

26.4.6.1 Class template set overview [set.overview]

26.4.6.2 set constructors, copy, and assignment [set.cons]

26.4.6.3 set specialized algorithms [set.special]

26.4.7 Class template multiset [multiset]

26.4.7.1 Class template multiset overview [multiset.overview]

26.4.7.2 multiset constructors [multiset.cons]

26.4.7.3 multiset specialized algorithms [multiset.special]

26.5 Unordered associative containers [unord]

26.5.2 Header <unordered_­map> synopsis [unord.map.syn]

26.5.3 Header <unordered_­set> synopsis [unord.set.syn]

26.5.4 Class template unordered_­map [unord.map]

26.5.4.1 Class template unordered_­map overview [unord.map.overview]

26.5.4.2 unordered_­map constructors [unord.map.cnstr]

26.5.4.3 unordered_­map element access [unord.map.elem]

26.5.4.4 unordered_­map modifiers [unord.map.modifiers]

26.5.4.5 unordered_­map swap [unord.map.swap]

26.5.5 Class template unordered_­multimap [unord.multimap]

26.5.5.1 Class template unordered_­multimap overview [unord.multimap.overview]

26.5.5.2 unordered_­multimap constructors [unord.multimap.cnstr]

26.5.5.3 unordered_­multimap modifiers [unord.multimap.modifiers]

26.5.5.4 unordered_­multimap swap [unord.multimap.swap]

26.5.6 Class template unordered_­set [unord.set]

26.5.6.1 Class template unordered_­set overview [unord.set.overview]

26.5.6.2 unordered_­set constructors [unord.set.cnstr]

26.5.6.3 unordered_­set swap [unord.set.swap]

26.5.7 Class template unordered_­multiset [unord.multiset]

26.5.7.1 Class template unordered_­multiset overview [unord.multiset.overview]

26.5.7.2 unordered_­multiset constructors [unord.multiset.cnstr]

26.5.7.3 unordered_­multiset swap [unord.multiset.swap]

26.6 Container adaptors [container.adaptors]

26.6.2 Header <queue> synopsis [queue.syn]

26.6.3 Header <stack> synopsis [stack.syn]

26.6.4 Class template queue [queue]

26.6.4.1 queue definition [queue.defn]

26.6.4.2 queue constructors [queue.cons]

26.6.4.3 queue constructors with allocators [queue.cons.alloc]

26.6.4.4 queue operators [queue.ops]

26.6.4.5 queue specialized algorithms [queue.special]

26.6.5 Class template priority_­queue [priority.queue]

26.6.5.1 priority_­queue constructors [priqueue.cons]

26.6.5.2 priority_­queue constructors with allocators [priqueue.cons.alloc]

26.6.5.3 priority_­queue members [priqueue.members]

26.6.5.4 priority_­queue specialized algorithms [priqueue.special]

26.6.6 Class template stack [stack]

26.6.6.1 stack definition [stack.defn]

26.6.6.2 stack constructors [stack.cons]

26.6.6.3 stack constructors with allocators [stack.cons.alloc]

26.6.6.4 stack operators [stack.ops]

26.6.6.5 stack specialized algorithms [stack.special]

27 Iterators library [iterators][iterators]

27.3 Header <iterator> synopsis [iterator.synopsis]

27.4 Iterator primitives [iterator.primitives]

27.4.1 Iterator traits [iterator.traits]

27.4.2 Standard iterator tags [std.iterator.tags]

27.4.3 Iterator operations [iterator.operations]

27.5 Iterator adaptors [predef.iterators]

27.5.2 Insert iterators [insert.iterators]

27.5.2.1 Class template back_­insert_­iterator [back.insert.iterator]

27.5.2.2 back_­insert_­iterator operations [back.insert.iter.ops]

27.5.2.2.1 back_­insert_­iterator constructor [back.insert.iter.cons]

27.5.2.2.2 back_­insert_­iterator​::​operator= [back.insert.iter.op=]

27.5.2.2.3 back_­insert_­iterator​::​operator* [back.insert.iter.op*]

27.5.2.2.4 back_­insert_­iterator​::​operator++ [back.insert.iter.op++]

27.5.2.2.5 back_­inserter [back.inserter]

27.5.2.3 Class template front_­insert_­iterator [front.insert.iterator]

27.5.2.4 front_­insert_­iterator operations [front.insert.iter.ops]

27.5.2.4.1 front_­insert_­iterator constructor [front.insert.iter.cons]

27.5.2.4.2 front_­insert_­iterator​::​operator= [front.insert.iter.op=]

27.5.2.4.3 front_­insert_­iterator​::​operator* [front.insert.iter.op*]

27.5.2.4.4 front_­insert_­iterator​::​operator++ [front.insert.iter.op++]

27.5.2.4.5 front_­inserter [front.inserter]

27.5.2.5 Class template insert_­iterator [insert.iterator]

27.5.2.6 insert_­iterator operations [insert.iter.ops]

27.5.2.6.1 insert_­iterator constructor [insert.iter.cons]

27.5.2.6.2 insert_­iterator​::​operator= [insert.iter.op=]

27.5.2.6.3 insert_­iterator​::​operator* [insert.iter.op*]

27.5.2.6.4 insert_­iterator​::​operator++ [insert.iter.op++]

27.5.3 Move iterators [move.iterators]

27.5.3.1 Class template move_­iterator [move.iterator]

27.5.3.2 move_­iterator requirements [move.iter.requirements]

27.5.3.3 move_­iterator operations [move.iter.ops]

27.5.3.3.1 move_­iterator constructors [move.iter.op.const]

27.5.3.3.2 move_­iterator​::​operator= [move.iter.op=]

27.5.3.3.3 move_­iterator conversion [move.iter.op.conv]

27.5.3.3.4 move_­iterator​::​operator* [move.iter.op.star]

27.5.3.3.5 move_­iterator​::​operator-> [move.iter.op.ref]

27.5.3.3.6 move_­iterator​::​operator++ [move.iter.op.incr]

27.5.3.3.7 move_­iterator​::​operator-- [move.iter.op.decr]

27.5.3.3.8 move_­iterator​::​operator+ [move.iter.op.+]

27.5.3.3.9 move_­iterator​::​operator+= [move.iter.op.+=]

27.5.3.3.10 move_­iterator​::​operator- [move.iter.op.-]

27.5.3.3.11 move_­iterator​::​operator-= [move.iter.op.-=]

27.5.3.3.12 move_­iterator​::​operator[] [move.iter.op.index]

27.5.3.3.13 move_­iterator comparisons [move.iter.op.comp]

27.5.3.3.14 move_­iterator non-member functions [move.iter.nonmember]

27.6 Stream iterators [stream.iterators]

27.6.1 Class template istream_­iterator [istream.iterator]

27.6.1.1 istream_­iterator constructors and destructor [istream.iterator.cons]

27.6.1.2 istream_­iterator operations [istream.iterator.ops]

27.6.2 Class template ostream_­iterator [ostream.iterator]

27.6.2.1 ostream_­iterator constructors and destructor [ostream.iterator.cons.des]

27.6.2.2 ostream_­iterator operations [ostream.iterator.ops]

27.6.3 Class template istreambuf_­iterator [istreambuf.iterator]

27.6.3.1 Class template istreambuf_­iterator​::​proxy [istreambuf.iterator.proxy]

27.6.3.2 istreambuf_­iterator constructors [istreambuf.iterator.cons]

27.6.3.3 istreambuf_­iterator operations [istreambuf.iterator.ops]

27.6.4 Class template ostreambuf_­iterator [ostreambuf.iterator]

27.6.4.1 ostreambuf_­iterator constructors [ostreambuf.iter.cons]

27.6.4.2 ostreambuf_­iterator operations [ostreambuf.iter.ops]

27.7 Range access [iterator.range]

27.8 Container access [iterator.container]

28 Algorithms library [algorithms][algorithms]

28.2 Header <algorithm> synopsis [algorithm.syn]

28.3 Algorithms requirements [algorithms.requirements]

28.4 Parallel algorithms [algorithms.parallel]

28.4.1 Terms and definitions [algorithms.parallel.defns]

28.4.2 Requirements on user-provided function objects [algorithms.parallel.user]

28.4.3 Effect of execution policies on algorithm execution [algorithms.parallel.exec]

28.4.4 Parallel algorithm exceptions [algorithms.parallel.exceptions]

28.4.5 ExecutionPolicy algorithm overloads [algorithms.parallel.overloads]

28.7 Sorting and related operations [alg.sorting]

28.7.1 Sorting [alg.sort]

28.7.1.2 stable_­sort [stable.sort]

28.7.1.3 partial_­sort [partial.sort]

28.7.1.4 partial_­sort_­copy [partial.sort.copy]

28.7.1.5 is_­sorted [is.sorted]

28.7.3 Binary search [alg.binary.search]

28.7.3.1 lower_­bound [lower.bound]

28.7.3.2 upper_­bound [upper.bound]

28.7.3.3 equal_­range [equal.range]

28.7.3.4 binary_­search [binary.search]

28.7.6 Set operations on sorted structures [alg.set.operations]

28.7.6.2 set_­union [set.union]

28.7.6.3 set_­intersection [set.intersection]

28.7.6.4 set_­difference [set.difference]

28.7.6.5 set_­symmetric_­difference [set.symmetric.difference]

28.7.8 Minimum and maximum [alg.min.max]

28.7.9 Bounded value [alg.clamp]

28.7.10 Lexicographical comparison [alg.lex.comparison]

28.7.11 Permutation generators [alg.permutation.generators]

28.8 C library algorithms [alg.c.library]

29 Numerics library [numerics][numerics]

29.3 Numeric type requirements [numeric.requirements]

29.4 The floating-point environment [cfenv]

29.4.1 Header <cfenv> synopsis [cfenv.syn]

29.5 Complex numbers [complex.numbers]

29.5.1 Header <complex> synopsis [complex.syn]

29.5.2 Class template complex [complex]

29.5.3 complex specializations [complex.special]

29.5.4 complex member functions [complex.members]

29.5.5 complex member operators [complex.member.ops]

29.5.6 complex non-member operations [complex.ops]

29.5.7 complex value operations [complex.value.ops]

29.5.8 complex transcendentals [complex.transcendentals]

29.5.9 Additional overloads [cmplx.over]

29.5.10 Suffixes for complex number literals [complex.literals]

29.6 Random number generation [rand]

29.6.1 Requirements [rand.req]

29.6.1.1 General requirements [rand.req.genl]

29.6.1.2 Seed sequence requirements [rand.req.seedseq]

29.6.1.3 Uniform random bit generator requirements [rand.req.urng]

29.6.1.4 Random number engine requirements [rand.req.eng]

29.6.1.5 Random number engine adaptor requirements [rand.req.adapt]

29.6.1.6 Random number distribution requirements [rand.req.dist]

29.6.2 Header <random> synopsis [rand.synopsis]

29.6.3 Random number engine class templates [rand.eng]

29.6.3.1 Class template linear_­congruential_­engine [rand.eng.lcong]

29.6.3.2 Class template mersenne_­twister_­engine [rand.eng.mers]

29.6.3.3 Class template subtract_­with_­carry_­engine [rand.eng.sub]

29.6.4 Random number engine adaptor class templates [rand.adapt]

29.6.4.2 Class template discard_­block_­engine [rand.adapt.disc]

29.6.4.3 Class template independent_­bits_­engine [rand.adapt.ibits]

29.6.4.4 Class template shuffle_­order_­engine [rand.adapt.shuf]

29.6.5 Engines and engine adaptors with predefined parameters [rand.predef]

29.6.6 Class random_­device [rand.device]

29.6.7 Utilities [rand.util]

29.6.7.1 Class seed_­seq [rand.util.seedseq]

29.6.7.2 Function template generate_­canonical [rand.util.canonical]

29.6.8 Random number distribution class templates [rand.dist]

29.6.8.2 Uniform distributions [rand.dist.uni]

29.6.8.2.1 Class template uniform_­int_­distribution [rand.dist.uni.int]

29.6.8.2.2 Class template uniform_­real_­distribution [rand.dist.uni.real]

29.6.8.3 Bernoulli distributions [rand.dist.bern]

29.6.8.3.1 Class bernoulli_­distribution [rand.dist.bern.bernoulli]

29.6.8.3.2 Class template binomial_­distribution [rand.dist.bern.bin]

29.6.8.3.3 Class template geometric_­distribution [rand.dist.bern.geo]

29.6.8.3.4 Class template negative_­binomial_­distribution [rand.dist.bern.negbin]

29.6.8.4 Poisson distributions [rand.dist.pois]

29.6.8.4.1 Class template poisson_­distribution [rand.dist.pois.poisson]

29.6.8.4.2 Class template exponential_­distribution [rand.dist.pois.exp]

29.6.8.4.3 Class template gamma_­distribution [rand.dist.pois.gamma]

29.6.8.4.4 Class template weibull_­distribution [rand.dist.pois.weibull]

29.6.8.4.5 Class template extreme_­value_­distribution [rand.dist.pois.extreme]

29.6.8.5 Normal distributions [rand.dist.norm]

29.6.8.5.1 Class template normal_­distribution [rand.dist.norm.normal]

29.6.8.5.2 Class template lognormal_­distribution [rand.dist.norm.lognormal]

29.6.8.5.3 Class template chi_­squared_­distribution [rand.dist.norm.chisq]

29.6.8.5.4 Class template cauchy_­distribution [rand.dist.norm.cauchy]

29.6.8.5.5 Class template fisher_­f_­distribution [rand.dist.norm.f]

29.6.8.5.6 Class template student_­t_­distribution [rand.dist.norm.t]

29.6.8.6 Sampling distributions [rand.dist.samp]

29.6.8.6.1 Class template discrete_­distribution [rand.dist.samp.discrete]

29.6.8.6.2 Class template piecewise_­constant_­distribution [rand.dist.samp.pconst]

29.6.8.6.3 Class template piecewise_­linear_­distribution [rand.dist.samp.plinear]

29.6.9 Low-quality random number generation [c.math.rand]

29.7 Numeric arrays [numarray]

29.7.1 Header <valarray> synopsis [valarray.syn]

29.7.2 Class template valarray [template.valarray]

29.7.2.1 Class template valarray overview [template.valarray.overview]

29.7.2.2 valarray constructors [valarray.cons]

29.7.2.3 valarray assignment [valarray.assign]

29.7.2.4 valarray element access [valarray.access]

29.7.2.5 valarray subset operations [valarray.sub]

29.7.2.6 valarray unary operators [valarray.unary]

29.7.2.7 valarray compound assignment [valarray.cassign]

29.7.2.8 valarray member functions [valarray.members]

29.7.3 valarray non-member operations [valarray.nonmembers]

29.7.3.1 valarray binary operators [valarray.binary]

29.7.3.2 valarray logical operators [valarray.comparison]

29.7.3.3 valarray transcendentals [valarray.transcend]

29.7.3.4 valarray specialized algorithms [valarray.special]

29.7.4 Class slice [class.slice]

29.7.4.1 Class slice overview [class.slice.overview]

29.7.4.2 slice constructors [cons.slice]

29.7.4.3 slice access functions [slice.access]

29.7.5 Class template slice_­array [template.slice.array]

29.7.5.1 Class template slice_­array overview [template.slice.array.overview]

29.7.5.2 slice_­array assignment [slice.arr.assign]

29.7.5.3 slice_­array compound assignment [slice.arr.comp.assign]

29.7.5.4 slice_­array fill function [slice.arr.fill]

29.7.6 The gslice class [class.gslice]

29.7.6.1 The gslice class overview [class.gslice.overview]

29.7.6.2 gslice constructors [gslice.cons]

29.7.6.3 gslice access functions [gslice.access]

29.7.7 Class template gslice_­array [template.gslice.array]

29.7.7.1 Class template gslice_­array overview [template.gslice.array.overview]

29.7.7.2 gslice_­array assignment [gslice.array.assign]

29.7.7.3 gslice_­array compound assignment [gslice.array.comp.assign]

29.7.7.4 gslice_­array fill function [gslice.array.fill]

29.7.8 Class template mask_­array [template.mask.array]

29.7.8.1 Class template mask_­array overview [template.mask.array.overview]

29.7.8.2 mask_­array assignment [mask.array.assign]

29.7.8.3 mask_­array compound assignment [mask.array.comp.assign]

29.7.8.4 mask_­array fill function [mask.array.fill]

29.7.9 Class template indirect_­array [template.indirect.array]

29.7.9.1 Class template indirect_­array overview [template.indirect.array.overview]

29.7.9.2 indirect_­array assignment [indirect.array.assign]

29.7.9.3 indirect_­array compound assignment [indirect.array.comp.assign]

29.7.9.4 indirect_­array fill function [indirect.array.fill]

29.7.10 valarray range access [valarray.range]

29.8 Generalized numeric operations [numeric.ops]

29.8.1 Header <numeric> synopsis [numeric.ops.overview]

29.8.2 Accumulate [accumulate]

29.8.4 Inner product [inner.product]

29.8.5 Transform reduce [transform.reduce]

29.8.6 Partial sum [partial.sum]

29.8.7 Exclusive scan [exclusive.scan]

29.8.8 Inclusive scan [inclusive.scan]

29.8.9 Transform exclusive scan [transform.exclusive.scan]

29.8.10 Transform inclusive scan [transform.inclusive.scan]

29.8.11 Adjacent difference [adjacent.difference]

29.8.13 Greatest common divisor [numeric.ops.gcd]

29.8.14 Least common multiple [numeric.ops.lcm]

29.9 Mathematical functions for floating-point types [c.math]

29.9.1 Header <cmath> synopsis [cmath.syn]

29.9.2 Absolute values [c.math.abs]

29.9.3 Three-dimensional hypotenuse [c.math.hypot3]

29.9.4 Classification / comparison functions [c.math.fpclass]

29.9.5 Mathematical special functions [sf.cmath]

29.9.5.1 Associated Laguerre polynomials [sf.cmath.assoc_laguerre]

29.9.5.2 Associated Legendre functions [sf.cmath.assoc_legendre]

29.9.5.4 Complete elliptic integral of the first kind [sf.cmath.comp_ellint_1]

29.9.5.5 Complete elliptic integral of the second kind [sf.cmath.comp_ellint_2]

29.9.5.6 Complete elliptic integral of the third kind [sf.cmath.comp_ellint_3]

29.9.5.7 Regular modified cylindrical Bessel functions [sf.cmath.cyl_bessel_i]

29.9.5.8 Cylindrical Bessel functions of the first kind [sf.cmath.cyl_bessel_j]

29.9.5.9 Irregular modified cylindrical Bessel functions [sf.cmath.cyl_bessel_k]

29.9.5.10 Cylindrical Neumann functions [sf.cmath.cyl_neumann]

29.9.5.11 Incomplete elliptic integral of the first kind [sf.cmath.ellint_1]

29.9.5.12 Incomplete elliptic integral of the second kind [sf.cmath.ellint_2]

29.9.5.13 Incomplete elliptic integral of the third kind [sf.cmath.ellint_3]

29.9.5.14 Exponential integral [sf.cmath.expint]

29.9.5.15 Hermite polynomials [sf.cmath.hermite]

29.9.5.16 Laguerre polynomials [sf.cmath.laguerre]

29.9.5.17 Legendre polynomials [sf.cmath.legendre]

29.9.5.18 Riemann zeta function [sf.cmath.riemann_zeta]

29.9.5.19 Spherical Bessel functions of the first kind [sf.cmath.sph_bessel]

29.9.5.20 Spherical associated Legendre functions [sf.cmath.sph_legendre]

29.9.5.21 Spherical Neumann functions [sf.cmath.sph_neumann]

30 Input/output library [input.output][input.output]

30.2 Iostreams requirements [iostreams.requirements]

30.2.2 Positioning type limitations [iostreams.limits.pos]

30.3 Forward declarations [iostream.forward]

30.3.1 Header <iosfwd> synopsis [iosfwd.syn]

30.4 Standard iostream objects [iostream.objects]

30.4.1 Header <iostream> synopsis [iostream.syn]

30.4.3 Narrow stream objects [narrow.stream.objects]

30.4.4 Wide stream objects [wide.stream.objects]

30.5 Iostreams base classes [iostreams.base]

30.5.1 Header <ios> synopsis [ios.syn]

30.5.3 Class ios_­base [ios.base]

30.5.3.1 Types [ios.types]

30.5.3.1.1 Class ios_­base​::​failure [ios::failure]

30.5.3.1.2 Type ios_­base​::​fmtflags [ios::fmtflags]

30.5.3.1.3 Type ios_­base​::​iostate [ios::iostate]

30.5.3.1.4 Type ios_­base​::​openmode [ios::openmode]

30.5.3.1.5 Type ios_­base​::​seekdir [ios::seekdir]

30.5.3.1.6 Class ios_­base​::​Init [ios::Init]

30.5.3.2 ios_­base state functions [fmtflags.state]

30.5.3.3 ios_­base functions [ios.base.locales]

30.5.3.4 ios_­base static members [ios.members.static]

30.5.3.5 ios_­base storage functions [ios.base.storage]

30.5.3.6 ios_­base callbacks [ios.base.callback]

30.5.3.7 ios_­base constructors/destructor [ios.base.cons]

30.5.4 Class template fpos [fpos]

30.5.4.2 fpos requirements [fpos.operations]

30.5.5 Class template basic_­ios [ios]

30.5.5.2 basic_­ios constructors [basic.ios.cons]

30.5.5.3 Member functions [basic.ios.members]

30.5.5.4 basic_­ios flags functions [iostate.flags]

30.5.6 ios_­base manipulators [std.ios.manip]

30.5.6.1 fmtflags manipulators [fmtflags.manip]

30.5.6.2 adjustfield manipulators [adjustfield.manip]

30.5.6.3 basefield manipulators [basefield.manip]

30.5.6.4 floatfield manipulators [floatfield.manip]

30.5.6.5 Error reporting [error.reporting]

30.6 Stream buffers [stream.buffers]

30.6.1 Header <streambuf> synopsis [streambuf.syn]

30.6.2 Stream buffer requirements [streambuf.reqts]

30.6.3 Class template basic_­streambuf [streambuf]

30.6.3.1 basic_­streambuf constructors [streambuf.cons]

30.6.3.2 basic_­streambuf public member functions [streambuf.members]

30.6.3.2.2 Buffer management and positioning [streambuf.buffer]

30.6.3.3 basic_­streambuf protected member functions [streambuf.protected]

30.7 Formatting and manipulators [iostream.format]

30.7.1 Header <istream> synopsis [istream.syn]

30.7.2 Header <ostream> synopsis [ostream.syn]

30.7.3 Header <iomanip> synopsis [iomanip.syn]

30.7.4 Input streams [input.streams]

30.7.4.1 Class template basic_­istream [istream]

30.7.4.1.1 basic_­istream constructors [istream.cons]

30.7.4.1.2 Class basic_­istream assign and swap [istream.assign]

30.7.4.1.3 Class basic_­istream​::​sentry [istream::sentry]

30.7.4.2 Formatted input functions [istream.formatted]

30.7.4.2.3 basic_­istream​::​operator>> [istream.extractors]

30.7.4.3 Unformatted input functions [istream.unformatted]

30.7.4.4 Standard basic_­istream manipulators [istream.manip]

30.7.4.5 Rvalue stream extraction [istream.rvalue]

30.7.4.6 Class template basic_­iostream [iostreamclass]

30.7.4.6.1 basic_­iostream constructors [iostream.cons]

30.7.4.6.2 basic_­iostream destructor [iostream.dest]

30.7.4.6.3 basic_­iostream assign and swap [iostream.assign]

30.7.5 Output streams [output.streams]

30.7.5.1 Class template basic_­ostream [ostream]

30.7.5.1.1 basic_­ostream constructors [ostream.cons]

30.7.5.1.2 Class basic_­ostream assign and swap [ostream.assign]

30.7.5.1.3 Class basic_­ostream​::​sentry [ostream::sentry]

30.7.5.1.4 basic_­ostream seek members [ostream.seeks]

30.7.5.2 Formatted output functions [ostream.formatted]

30.7.5.2.3 basic_­ostream​::​operator<< [ostream.inserters]

30.7.5.2.4 Character inserter function templates [ostream.inserters.character]

30.7.5.3 Unformatted output functions [ostream.unformatted]

30.7.5.4 Standard basic_­ostream manipulators [ostream.manip]

30.7.5.5 Rvalue stream insertion [ostream.rvalue]

30.7.6 Standard manipulators [std.manip]

30.7.7 Extended manipulators [ext.manip]

30.7.8 Quoted manipulators [quoted.manip]

30.8 String-based streams [string.streams]

30.8.1 Header <sstream> synopsis [sstream.syn]

30.8.2 Class template basic_­stringbuf [stringbuf]

30.8.2.1 basic_­stringbuf constructors [stringbuf.cons]

30.8.2.3 Member functions [stringbuf.members]

30.8.2.4 Overridden virtual functions [stringbuf.virtuals]

30.8.3 Class template basic_­istringstream [istringstream]

30.8.3.1 basic_­istringstream constructors [istringstream.cons]

30.8.4 Class template basic_­ostringstream [ostringstream]

30.8.4.1 basic_­ostringstream constructors [ostringstream.cons]

30.8.5 Class template basic_­stringstream [stringstream]

30.8.5.1 basic_­stringstream constructors [stringstream.cons]

30.9 File-based streams [file.streams]

30.9.1 Header <fstream> synopsis [fstream.syn]

30.9.2 Class template basic_­filebuf [filebuf]

30.9.2.1 basic_­filebuf constructors [filebuf.cons]

30.9.2.2 Assign and swap [filebuf.assign]

30.9.2.3 Member functions [filebuf.members]

30.9.2.4 Overridden virtual functions [filebuf.virtuals]

30.9.3 Class template basic_­ifstream [ifstream]

30.9.3.1 basic_­ifstream constructors [ifstream.cons]

30.9.3.2 Assign and swap [ifstream.assign]

30.9.3.3 Member functions [ifstream.members]

30.9.4 Class template basic_­ofstream [ofstream]

30.9.4.1 basic_­ofstream constructors [ofstream.cons]

30.9.4.2 Assign and swap [ofstream.assign]

30.9.4.3 Member functions [ofstream.members]

30.9.5 Class template basic_­fstream [fstream]

30.9.5.1 basic_­fstream constructors [fstream.cons]

30.9.5.2 Assign and swap [fstream.assign]

30.9.5.3 Member functions [fstream.members]

30.10 File systems [filesystems]

30.10.2 Conformance [fs.conformance]

30.10.2.1 POSIX conformance [fs.conform.9945]

30.10.2.2 Operating system dependent behavior conformance [fs.conform.os]

30.10.2.3 File system race behavior [fs.race.behavior]

30.10.3 Normative references [fs.norm.ref]

30.10.4 Terms and definitions [fs.definitions]

30.10.24 Requirements [fs.req]

30.10.24.1 Namespaces and headers [fs.req.namespace]

30.10.25 Header <filesystem> synopsis [fs.filesystem.syn]

30.10.26 Error reporting [fs.err.report]

30.10.27 Class path [fs.class.path]

30.10.27.1 Generic pathname format [fs.path.generic]

30.10.27.2 path conversions [fs.path.cvt]

30.10.27.2.1 path argument format conversions [fs.path.fmt.cvt]

30.10.27.2.2 path type and encoding conversions [fs.path.type.cvt]

30.10.27.3 path requirements [fs.path.req]

30.10.27.5 path iterators [fs.path.itr]

30.10.27.6 path non-member functions [fs.path.nonmember]

30.10.27.6.1 path inserter and extractor [fs.path.io]

30.10.27.6.2 path factory functions [fs.path.factory]

30.10.28 Class filesystem_­error [fs.class.filesystem_error]

30.10.28.1 filesystem_­error members [filesystem_error.members]

30.10.29 Enumerations [fs.enum]

30.10.29.1 Enum path​::​format [fs.enum.path.format]

30.10.29.2 Enum class file_­type [fs.enum.file_type]

30.10.29.3 Enum class copy_­options [fs.enum.copy.opts]

30.10.29.4 Enum class perms [fs.enum.perms]

30.10.29.5 Enum class perm_­options [fs.enum.perm.opts]

30.10.29.6 Enum class directory_­options [fs.enum.dir.opts]

30.10.30 Class file_­status [fs.class.file_status]

30.10.30.1 file_­status constructors [fs.file_status.cons]

30.10.30.2 file_­status observers [fs.file_status.obs]

30.10.30.3 file_­status modifiers [fs.file_status.mods]

30.10.31 Class directory_­entry [fs.class.directory_entry]

30.10.31.1 directory_­entry constructors [fs.dir.entry.cons]

30.10.31.2 directory_­entry modifiers [fs.dir.entry.mods]

30.10.31.3 directory_­entry observers [fs.dir.entry.obs]

30.10.32 Class directory_­iterator [fs.class.directory_iterator]

30.10.32.1 directory_­iterator members [fs.dir.itr.members]

30.10.32.2 directory_­iterator non-member functions [fs.dir.itr.nonmembers]

30.10.33 Class recursive_­directory_­iterator [fs.class.rec.dir.itr]

30.10.33.1 recursive_­directory_­iterator members [fs.rec.dir.itr.members]

30.10.33.2 recursive_­directory_­iterator non-member functions [fs.rec.dir.itr.nonmembers]

30.10.34 Filesystem operation functions [fs.op.funcs]

30.10.34.8 Create directory symlink [fs.op.create_dir_symlk]

30.10.34.38 Temporary directory path [fs.op.temp_dir_path]

30.11 C library files [c.files]

30.11.1 Header <cstdio> synopsis [cstdio.syn]

30.11.2 Header <cinttypes> synopsis [cinttypes.syn]

31 Regular expressions library [re][re]

31.2 Definitions [re.def]

31.3 Requirements [re.req]

31.4 Header <regex> synopsis [re.syn]

31.5 Namespace std​::​regex_­constants [re.const]

31.5.1 Bitmask type syntax_­option_­type [re.synopt]

31.5.2 Bitmask type match_­flag_­type [re.matchflag]

31.5.3 Implementation-defined error_­type [re.err]

31.6 Class regex_­error [re.badexp]

31.7 Class template regex_­traits [re.traits]

31.8 Class template basic_­regex [re.regex]

31.8.1 basic_­regex constants [re.regex.const]

31.8.2 basic_­regex constructors [re.regex.construct]

31.8.3 basic_­regex assign [re.regex.assign]

31.8.4 basic_­regex constant operations [re.regex.operations]

31.8.5 basic_­regex locale [re.regex.locale]

31.8.6 basic_­regex swap [re.regex.swap]

31.8.7 basic_­regex non-member functions [re.regex.nonmemb]

31.8.7.1 basic_­regex non-member swap [re.regex.nmswap]

31.9 Class template sub_­match [re.submatch]

31.9.1 sub_­match members [re.submatch.members]

31.9.2 sub_­match non-member operators [re.submatch.op]

31.10 Class template match_­results [re.results]

31.10.1 match_­results constructors [re.results.const]

31.10.2 match_­results state [re.results.state]

31.10.3 match_­results size [re.results.size]

31.10.4 match_­results element access [re.results.acc]

31.10.5 match_­results formatting [re.results.form]

31.10.6 match_­results allocator [re.results.all]

31.10.7 match_­results swap [re.results.swap]

31.10.8 match_­results non-member functions [re.results.nonmember]

31.11 Regular expression algorithms [re.alg]

31.11.1 Exceptions [re.except]

31.11.2 regex_­match [re.alg.match]

31.11.3 regex_­search [re.alg.search]

31.11.4 regex_­replace [re.alg.replace]

31.12 Regular expression iterators [re.iter]

31.12.1 Class template regex_­iterator [re.regiter]

31.12.1.1 regex_­iterator constructors [re.regiter.cnstr]

31.12.1.2 regex_­iterator comparisons [re.regiter.comp]

31.12.1.3 regex_­iterator indirection [re.regiter.deref]

31.12.1.4 regex_­iterator increment [re.regiter.incr]

31.12.2 Class template regex_­token_­iterator [re.tokiter]

31.12.2.1 regex_­token_­iterator constructors [re.tokiter.cnstr]

31.12.2.2 regex_­token_­iterator comparisons [re.tokiter.comp]

31.12.2.3 regex_­token_­iterator indirection [re.tokiter.deref]

31.12.2.4 regex_­token_­iterator increment [re.tokiter.incr]

31.13 Modified ECMAScript regular expression grammar [re.grammar]

32 Atomic operations library [atomics][atomics]

32.2 Header <atomic> synopsis [atomics.syn]

32.3 Type aliases [atomics.alias]

32.4 Order and consistency [atomics.order]

32.5 Lock-free property [atomics.lockfree]

32.6 Class template atomic [atomics.types.generic]

32.6.1 Operations on atomic types [atomics.types.operations]

32.6.2 Specializations for integers [atomics.types.int]

32.6.3 Partial specialization for pointers [atomics.types.pointer]

32.6.4 Member operators common to integers and pointers to objects [atomics.types.memop]

32.7 Non-member functions [atomics.nonmembers]

32.8 Flag type and operations [atomics.flag]

33 Thread support library [thread][thread]

33.2 Requirements [thread.req]

33.2.1 Template parameter names [thread.req.paramname]

33.2.4 Timing specifications [thread.req.timing]

33.2.5 Requirements for Lockable types [thread.req.lockable]

33.2.5.2 BasicLockable requirements [thread.req.lockable.basic]

33.2.5.3 Lockable requirements [thread.req.lockable.req]

33.2.5.4 TimedLockable requirements [thread.req.lockable.timed]

33.3 Threads [thread.threads]

33.3.1 Header <thread> synopsis [thread.syn]

33.3.2 Class thread [thread.thread.class]

33.3.2.1 Class thread​::​id [thread.thread.id]

33.3.2.2 thread constructors [thread.thread.constr]

33.3.2.6 thread static members [thread.thread.static]

33.3.2.7 thread specialized algorithms [thread.thread.algorithm]

33.3.3 Namespace this_­thread [thread.thread.this]

33.4 Mutual exclusion [thread.mutex]

33.4.1 Header <mutex> synopsis [mutex.syn]

33.4.2 Header <shared_­mutex> synopsis [shared_mutex.syn]

33.4.4 Locks [thread.lock]

33.4.4.1 Class template lock_­guard [thread.lock.guard]

33.4.4.2 Class template scoped_­lock [thread.lock.scoped]

33.4.4.3 Class template unique_­lock [thread.lock.unique]

33.4.4.3.1 unique_­lock constructors, destructor, and assignment [thread.lock.unique.cons]

33.4.4.3.3 unique_­lock modifiers [thread.lock.unique.mod]

33.4.4.3.4 unique_­lock observers [thread.lock.unique.obs]

33.4.4.4 Class template shared_­lock [thread.lock.shared]

33.4.4.4.1 shared_­lock constructors, destructor, and assignment [thread.lock.shared.cons]

33.4.4.4.3 shared_­lock modifiers [thread.lock.shared.mod]

33.4.4.4.4 shared_­lock observers [thread.lock.shared.obs]

33.4.5 Generic locking algorithms [thread.lock.algorithm]

33.4.6 Call once [thread.once]

33.4.6.1 Struct once_­flag [thread.once.onceflag]

33.4.6.2 Function call_­once [thread.once.callonce]

33.5 Condition variables [thread.condition]

33.5.1 Header <condition_­variable> synopsis [condition_variable.syn]

33.5.3 Class condition_­variable [thread.condition.condvar]

33.5.4 Class condition_­variable_­any [thread.condition.condvarany]

33.6 Futures [futures]

33.6.2 Header <future> synopsis [future.syn]

33.6.3 Error handling [futures.errors]

33.6.4 Class future_­error [futures.future_error]

33.6.5 Shared state [futures.state]

33.6.6 Class template promise [futures.promise]

33.6.7 Class template future [futures.unique_future]

33.6.8 Class template shared_­future [futures.shared_future]

33.6.9 Function template async [futures.async]

33.6.10 Class template packaged_­task [futures.task]

33.6.10.1 packaged_­task member functions [futures.task.members]

33.6.10.2 packaged_­task globals [futures.task.nonmembers]

Annex A (informative) Grammar summary [gram][gram]

A.1 Keywords [gram.key]

A.2 Lexical conventions [gram.lex]

A.3 Basic concepts [gram.basic]

A.4 Expressions [gram.expr]

A.5 Statements [gram.stmt]

A.6 Declarations [gram.dcl]

A.7 Declarators [gram.decl]

A.9 Derived classes [gram.derived]

A.10 Special member functions [gram.special]

A.11 Overloading [gram.over]

A.12 Templates [gram.temp]

A.13 Exception handling [gram.except]

A.14 Preprocessing directives [gram.cpp]

Annex C (informative) Compatibility [diff][diff]

C.1 C++ and ISO C [diff.iso]

C.1.1 Clause [lex]: lexical conventions [diff.lex]

C.1.2 Clause [basic]: basic concepts [diff.basic]

C.1.3 Clause [conv]: standard conversions [diff.conv]

C.1.4 Clause [expr]: expressions [diff.expr]

C.1.5 Clause [stmt.stmt]: statements [diff.stat]

C.1.6 Clause [dcl.dcl]: declarations [diff.dcl]

C.1.7 Clause [dcl.decl]: declarators [diff.decl]

C.1.8 Clause [class]: classes [diff.class]

C.1.9 Clause [special]: special member functions [diff.special]

C.1.10 Clause [cpp]: preprocessing directives [diff.cpp]

C.2 C++ and ISO C++ 2003 [diff.cpp03]

C.2.1 Clause [lex]: lexical conventions [diff.cpp03.lex]

C.2.2 Clause [conv]: standard conversions [diff.cpp03.conv]

C.2.3 Clause [expr]: expressions [diff.cpp03.expr]

C.2.4 Clause [dcl.dcl]: declarations [diff.cpp03.dcl.dcl]

C.2.6 Clause [special]: special member functions [diff.cpp03.special]

C.2.7 Clause [temp]: templates [diff.cpp03.temp]

C.2.8 Clause [library]: library introduction [diff.cpp03.library]

C.2.9 Clause [language.support]: language support library [diff.cpp03.language.support]

C.2.10 Clause [diagnostics]: diagnostics library [diff.cpp03.diagnostics]

C.2.11 Clause [utilities]: general utilities library [diff.cpp03.utilities]

C.2.12 Clause [strings]: strings library [diff.cpp03.strings]

C.2.13 Clause [containers]: containers library [diff.cpp03.containers]

C.2.14 Clause [algorithms]: algorithms library [diff.cpp03.algorithms]

C.2.15 Clause [numerics]: numerics library [diff.cpp03.numerics]

C.2.16 Clause [input.output]: input/output library [diff.cpp03.input.output]

C.3 C++ and ISO C++ 2011 [diff.cpp11]

C.3.1 Clause [lex]: lexical conventions [diff.cpp11.lex]

C.3.2 Clause [basic]: basic concepts [diff.cpp11.basic]

C.3.3 Clause [expr]: expressions [diff.cpp11.expr]

C.3.4 Clause [dcl.dcl]: declarations [diff.cpp11.dcl.dcl]

C.3.6 Clause [library]: library introduction [diff.cpp11.library]

C.3.7 Clause [input.output]: input/output library [diff.cpp11.input.output]

C.4 C++ and ISO C++ 2014 [diff.cpp14]

C.4.1 Clause [lex]: lexical conventions [diff.cpp14.lex]

C.4.2 Clause [expr]: expressions [diff.cpp14.expr]

C.4.3 Clause [dcl.dcl]: declarations [diff.cpp14.dcl.dcl]

C.4.4 Clause [dcl.decl]: declarators [diff.cpp14.decl]

C.4.5 Clause [special]: special member functions [diff.cpp14.special]

C.4.6 Clause [temp]: templates [diff.cpp14.temp]

C.4.7 Clause [except]: exception handling [diff.cpp14.except]

C.4.8 Clause [library]: library introduction [diff.cpp14.library]

C.4.9 Clause [utilities]: general utilities library [diff.cpp14.utilities]

C.4.10 Clause [strings]: strings library [diff.cpp14.string]

C.4.11 Clause [containers]: containers library [diff.cpp14.containers]

C.4.12 Annex [depr]: compatibility features [diff.cpp14.depr]

C.5 C standard library [diff.library]

C.5.1 Modifications to headers [diff.mods.to.headers]

C.5.2 Modifications to definitions [diff.mods.to.definitions]

C.5.2.1 Types char16_­t and char32_­t [diff.char16]

C.5.2.2 Type wchar_­t [diff.wchar.t]

C.5.2.5 Header <stdalign.h> [diff.header.stdalign.h]

C.5.2.6 Header <stdbool.h> [diff.header.stdbool.h]

C.5.2.7 Macro NULL [diff.null]

C.5.3 Modifications to declarations [diff.mods.to.declarations]

C.5.4 Modifications to behavior [diff.mods.to.behavior]

C.5.4.1 Macro offsetof(type, member-designator) [diff.offsetof]

C.5.4.2 Memory allocation functions [diff.malloc]

Annex D (normative) Compatibility features [depr][depr]

D.1 Redeclaration of static constexpr data members [depr.static_constexpr]

D.2 Implicit declaration of copy functions [depr.impldec]

D.3 Deprecated exception specifications [depr.except.spec]

D.4 C++standard library headers [depr.cpp.headers]

D.4.1 Header <ccomplex> synopsis [depr.ccomplex.syn]

D.4.2 Header <cstdalign> synopsis [depr.cstdalign.syn]

D.4.3 Header <cstdbool> synopsis [depr.cstdbool.syn]

D.4.4 Header <ctgmath> synopsis [depr.ctgmath.syn]

D.5 C standard library headers [depr.c.headers]

D.6 char* streams [depr.str.strstreams]

D.6.1 Class strstreambuf [depr.strstreambuf]

D.6.1.1 strstreambuf constructors [depr.strstreambuf.cons]

D.6.1.3 strstreambuf overridden virtual functions [depr.strstreambuf.virtuals]

D.6.2 Class istrstream [depr.istrstream]

D.6.2.1 istrstream constructors [depr.istrstream.cons]

D.6.3 Class ostrstream [depr.ostrstream]

D.6.3.1 ostrstream constructors [depr.ostrstream.cons]

D.6.4 Class strstream [depr.strstream]

D.6.4.1 strstream constructors [depr.strstream.cons]

D.6.4.2 strstream destructor [depr.strstream.dest]

D.6.4.3 strstream operations [depr.strstream.oper]

D.7 uncaught_­exception [depr.uncaught]

D.8 Old adaptable function bindings [depr.func.adaptor.binding]

D.8.1 Weak result types [depr.weak.result_type]

D.8.2 Typedefs to support function binders [depr.func.adaptor.typedefs]

D.9 The default allocator [depr.default.allocator]

D.10 Raw storage iterator [depr.storage.iterator]

D.11 Temporary buffers [depr.temporary.buffer]

D.12 Deprecated type traits [depr.meta.types]

D.13 Deprecated iterator primitives [depr.iterator.primitives]

D.14 Deprecated shared_­ptr observers [depr.util.smartptr.shared.obs]

D.15 Deprecated standard code conversion facets [depr.locale.stdcvt]

D.15.1 Header <codecvt> synopsis [depr.codecvt.syn]

D.16 Deprecated convenience conversion interfaces [depr.conversions]

D.16.1 Class template wstring_­convert [depr.conversions.string]

D.16.2 Class template wbuffer_­convert [depr.conversions.buffer]

Index

Index of library names

Index of implementation-defined behavior