Generated on 2017-06-20 from the C++ standard's draft LaTeX sources by cxxdraft-htmlgen. This is not an ISO publication.
For historical versions of the document, see Tim Song's cppwp page.

Contents

List of Tables [tab][tab]

1Alternative tokens[tab:alternative.tokens]
2Ranges of characters allowed[tab:charname.allowed]
3Ranges of characters disallowed initially (combining characters)[tab:charname.disallowed]
4Identifiers with special meaning[tab:identifiers.special]
5Keywords[tab:keywords]
6Alternative representations[tab:alternative.representations]
7Types of integer literals[tab:lex.type.integer.literal]
8Escape sequences[tab:escape.sequences]
9String literal concatenations[tab:lex.string.concat]
10Relations on const and volatile[tab:relations.on.const.and.volatile]
11simple-type-specifiers and the types they specify[tab:simple.type.specifiers]
12Relationship between operator and function call notation[tab:over.rel.op.func]
13Conversions[tab:over.conversions]
14Value of folding empty sequences[tab:fold.empty]
15Library categories[tab:library.categories]
16C++ library headers[tab:cpp.library.headers]
17C++ headers for C library facilities[tab:cpp.c.headers]
18C standard Annex K names[tab:c.annex.k.names]
19C++ headers for freestanding implementations[tab:cpp.headers.freestanding]
20EqualityComparable requirements[tab:equalitycomparable]
21LessThanComparable requirements[tab:lessthancomparable]
22DefaultConstructible requirements[tab:defaultconstructible]
23MoveConstructible requirements[tab:moveconstructible]
24CopyConstructible requirements (in addition to MoveConstructible)[tab:copyconstructible]
25MoveAssignable requirements[tab:moveassignable]
26CopyAssignable requirements (in addition to MoveAssignable)[tab:copyassignable]
27Destructible requirements[tab:destructible]
28NullablePointer requirements[tab:nullablepointer]
29Hash requirements[tab:hash]
30Descriptive variable definitions[tab:desc.var.def]
31Allocator requirements[tab:utilities.allocator.requirements]
32Language support library summary[tab:lang.sup.lib.summary]
33Diagnostics library summary[tab:diagnostics.lib.summary]
34General utilities library summary[tab:util.lib.summary]
35optional​::​operator=(const optional&) effects[tab:optional.assign.copy]
36optional​::​operator=(optional&&) effects[tab:optional.assign.move]
37optional​::​operator=(const optional<U>&) effects[tab:optional.assign.copy.templ]
38optional​::​operator=(optional<U>&&) effects[tab:optional.assign.move.templ]
39optional​::​swap(optional&) effects[tab:optional.swap]
40Primary type category predicates[tab:type-traits.primary]
41Composite type category predicates[tab:type-traits.composite]
42Type property predicates[tab:type-traits.properties]
43Type property queries[tab:type-traits.properties.queries]
44Type relationship predicates[tab:type-traits.relationship]
45Const-volatile modifications[tab:type-traits.const-volatile]
46Reference modifications[tab:type-traits.reference]
47Sign modifications[tab:type-traits.sign]
48Array modifications[tab:type-traits.array]
49Pointer modifications[tab:type-traits.pointer]
50Other transformations[tab:type-traits.other]
51Expressions used to perform ratio arithmetic[tab:ratio.arithmetic]
52Clock requirements[tab:time.clock]
53Strings library summary[tab:strings.lib.summary]
54Character traits requirements[tab:char.traits.require]
55basic_­string(const Allocator&) effects[tab:strings.ctr.1]
56basic_­string(const basic_­string&) effects[tab:strings.ctr.cpy]
57basic_­string(const basic_­string&, size_­type, const Allocator&) and
basic_­string(const basic_­string&, size_­type, size_­type, const Allocator&) effects[tab:strings.ctr.2]
58basic_­string(const charT*, size_­type, const Allocator&) effects[tab:strings.ctr.3]
59basic_­string(const charT*, const Allocator&) effects[tab:strings.ctr.4]
60basic_­string(size_­t, charT, const Allocator&) effects[tab:strings.ctr.5]
61basic_­string(const basic_­string&, const Allocator&)
and basic_­string(basic_­string&&, const Allocator&) effects[tab:strings.ctr.6]
62operator=(const basic_­string&) effects[tab:strings.op=]
63compare() results[tab:strings.compare]
64basic_­string_­view(const charT*) effects[tab:string.view.ctr.2]
65basic_­string_­view(const charT*, size_­type) effects[tab:string.view.ctr.3]
66compare() results[tab:string.view.compare]
67Additional basic_­string_­view comparison overloads[tab:string.view.comparison.overloads]
68Localization library summary[tab:localization.lib.summary]
69Locale category facets[tab:localization.category.facets]
70Required specializations[tab:localization.required.specializations]
71do_­in/do_­out result values[tab:localization.convert.result.values.out.in]
72do_­unshift result values[tab:localization.convert.result.values.unshift]
73Integer conversions[tab:localization.integer.conversions.in]
74Length modifier[tab:localization.length.modifier.in]
75Integer conversions[tab:localization.integer.conversions.out]
76Floating-point conversions[tab:localization.fp.conversions.out]
77Length modifier[tab:localization.length.modifier.out]
78Numeric conversions[tab:localization.numeric.conversions]
79Fill padding[tab:localization.fill.padding]
80do_­get_­date effects[tab:lib.locale.time.get.virtuals.dogetdate]
81Potential setlocale data races[tab:setlocale.data.races]
82Containers library summary[tab:containers.lib.summary]
83Container requirements[tab:containers.container.requirements]
84Reversible container requirements[tab:containers.reversible.requirements]
85Optional container operations[tab:containers.optional.operations]
86Allocator-aware container requirements[tab:containers.allocatoraware]
87Sequence container requirements (in addition to container)[tab:containers.sequence.requirements]
88Optional sequence container operations[tab:containers.sequence.optional]
89Container types with compatible nodes[tab:containers.node.compat]
90Associative container requirements (in addition to container)[tab:containers.associative.requirements]
91Unordered associative container requirements (in addition to container)[tab:HashRequirements]
92Iterators library summary[tab:iterators.lib.summary]
93Relations among iterator categories[tab:iterators.relations]
94Iterator requirements[tab:iterator.requirements]
95Input iterator requirements (in addition to Iterator)[tab:iterator.input.requirements]
96Output iterator requirements (in addition to Iterator)[tab:iterator.output.requirements]
97Forward iterator requirements (in addition to input iterator)[tab:iterator.forward.requirements]
98Bidirectional iterator requirements (in addition to forward iterator)[tab:iterator.bidirectional.requirements]
99Random access iterator requirements (in addition to bidirectional iterator)[tab:iterator.random.access.requirements]
100Algorithms library summary[tab:algorithms.summary]
101Numerics library summary[tab:numerics.lib.summary]
102Seed sequence requirements[tab:SeedSequence]
103Uniform random bit generator requirements[tab:UniformRandomBitGenerator]
104Random number engine requirements[tab:RandomEngine]
105Random number distribution requirements[tab:RandomDistribution]
106Input/output library summary[tab:iostreams.lib.summary]
107fmtflags effects[tab:iostreams.fmtflags.effects]
108fmtflags constants[tab:iostreams.fmtflags.constants]
109iostate effects[tab:iostreams.iostate.effects]
110openmode effects[tab:iostreams.openmode.effects]
111seekdir effects[tab:iostreams.seekdir.effects]
112Position type requirements[tab:iostreams.position.requirements]
113basic_­ios​::​init() effects[tab:iostreams.basicios.init.effects]
114basic_­ios​::​copyfmt() effects[tab:iostreams.copyfmt.effects]
115seekoff positioning[tab:iostreams.seekoff.positioning]
116newoff values[tab:iostreams.newoff.values]
117File open modes[tab:iostreams.file.open.modes]
118seekoff effects[tab:iostreams.seekoff.effects]
119filesystem_­error(const string&, error_­code) effects[tab:filesystem_error.1]
120filesystem_­error(const string&, const path&, error_­code) effects[tab:filesystem_error.2]
121filesystem_­error(const string&, const path&, const path&, error_­code) effects[tab:filesystem_error.3]
122Enum path​::​format[tab:enum.path.format]
123Enum class file_­type[tab:fs.enum.file_type]
124Enum class copy_­options[tab:fs.enum.copy_options]
125Enum class perms[tab:fs.enum.perms]
126Enum class perm_­options[tab:enum.perm_options]
127Enum class directory_­options[tab:fs.enum.directory_options]
128Regular expressions library summary[tab:re.lib.summary]
129Regular expression traits class requirements[tab:re:RegexpTraits]
130syntax_­option_­type effects[tab:re:syntaxoption]
131regex_­constants​::​match_­flag_­type effects when obtaining a match against a character container sequence [first, last).[tab:re:matchflag]
132error_­type values in the C locale[tab:re:errortype]
133Character class names and corresponding ctype masks[tab:re.traits.classnames]
134match_­results assignment operator effects[tab:re:results:assign]
135Effects of regex_­match algorithm[tab:re:alg:match]
136Effects of regex_­search algorithm[tab:re:alg:search]
137Atomics library summary[tab:atomics.lib.summary]
138Atomic arithmetic computations[tab:atomic.arithmetic.computations]
139Atomic pointer computations[tab:atomic.pointer.computations]
140Thread support library summary[tab:thread.lib.summary]
141C headers[tab:future.c.headers]
142strstreambuf(streamsize) effects[tab:future.strstreambuf.effects]
143strstreambuf(void* (*)(size_­t), void (*)(void*)) effects[tab:future.strstreambuf1.effects]
144strstreambuf(charT*, streamsize, charT*) effects[tab:future.strstreambuf2.effects]
145seekoff positioning[tab:future.seekoff.positioning]
146newoff values[tab:future.newoff.values]

List of Figures [fig][fig]

1Expression category taxonomy[fig:categories]
2Directed acyclic graph[fig:dag]
3Non-virtual base[fig:nonvirt]
4Virtual base[fig:virt]
5Virtual and non-virtual base[fig:virtnonvirt]
6Name lookup[fig:name]
7Stream position, offset, and size types [non-normative][fig:streampos]

1 Scope [intro.scope][intro.scope]

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.5 Requirements [fs.req]

30.10.5.1 Namespaces and headers [fs.req.namespace]

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

30.10.7 Error reporting [fs.err.report]

30.10.8 Class path [fs.class.path]

30.10.8.1 Generic pathname format [fs.path.generic]

30.10.8.2 path conversions [fs.path.cvt]

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

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

30.10.8.3 path requirements [fs.path.req]

30.10.8.5 path iterators [fs.path.itr]

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

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

30.10.8.6.2 path factory functions [fs.path.factory]

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

30.10.9.1 filesystem_­error members [filesystem_error.members]

30.10.10 Enumerations [fs.enum]

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

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

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

30.10.10.4 Enum class perms [fs.enum.perms]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

30.10.15 Filesystem operation functions [fs.op.funcs]

30.10.15.8 Create directory symlink [fs.op.create_dir_symlk]

30.10.15.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 B (informative) Implementation quantities [implimits][implimits]

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