Generated on 2017-07-20 from the LaTeX sources of C++ standard working draft N4140 (C++14 + editorial fixes) by cxxdraft-htmlgen.
This is not an ISO publication.

Contents

List of Tables [tab][tab]

1Trigraph sequences[tab:trigraph.sequences]
2Alternative tokens[tab:alternative.tokens]
3Identifiers with special meaning[tab:identifiers.special]
4Keywords[tab:keywords]
5Alternative representations[tab:alternative.representations]
6Types of integer literals[tab:lex.type.integer.literal]
7Escape sequences[tab:escape.sequences]
8String literal concatenations[tab:lex.string.concat]
9Relations on const and volatile[tab:relations.on.const.and.volatile]
10simple-type-specifiers and the types they specify[tab:simple.type.specifiers]
11Relationship between operator and function call notation[tab:over.rel.op.func]
12Conversions[tab:over.conversions]
13Library categories[tab:library.categories]
14C++ library headers[tab:cpp.library.headers]
15C++ headers for C library facilities[tab:cpp.c.headers]
16C++ headers for freestanding implementations[tab:cpp.headers.freestanding]
17EqualityComparable requirements[tab:equalitycomparable]
18LessThanComparable requirements[tab:lessthancomparable]
19DefaultConstructible requirements[tab:defaultconstructible]
20MoveConstructible requirements[tab:moveconstructible]
21CopyConstructible requirements (in addition to MoveConstructible)[tab:copyconstructible]
22MoveAssignable requirements[tab:moveassignable]
23CopyAssignable requirements (in addition to MoveAssignable)[tab:copyassignable]
24Destructible requirements[tab:destructible]
25NullablePointer requirements[tab:nullablepointer]
26Hash requirements[tab:hash]
27Descriptive variable definitions[tab:desc.var.def]
28Allocator requirements[tab:utilities.allocator.requirements]
29Language support library summary[tab:lang.sup.lib.summary]
30Header <cstddef> synopsis[tab:support.hdr.cstddef]
31Header <climits> synopsis[tab:support.hdr.climits]
32Header <cfloat> synopsis[tab:support.hdr.cfloat]
33Header <cstdlib> synopsis[tab:support.hdr.cstdlib]
34Header <csetjmp> synopsis[tab:support.hdr.csetjmp]
35Header <csignal> synopsis[tab:support.hdr.csignal]
36Header <cstdalign> synopsis[tab:support.hdr.cstdalign]
37Header <cstdarg> synopsis[tab:support.hdr.cstdarg]
38Header <cstdbool> synopsis[tab:support.hdr.cstdbool]
39Header <cstdlib> synopsis[tab:support.hdr.cstdlib1]
40Header <ctime> synopsis[tab:support.hdr.ctime]
41Diagnostics library summary[tab:diagnostics.lib.summary]
42Header <cassert> synopsis[tab:diagnostics.hdr.cassert]
43Header <cerrno> synopsis[tab:diagnostics.hdr.cerrno]
44General utilities library summary[tab:util.lib.summary]
45Header <cstdlib> synopsis[tab:util.hdr.cstdlib]
46Header <cstring> synopsis[tab:util.hdr.cstring]
47Primary type category predicates[tab:type-traits.primary]
48Composite type category predicates[tab:type-traits.composite]
49Type property predicates[tab:type-traits.properties]
50Type property queries[tab:type-traits.properties.queries]
51Type relationship predicates[tab:type-traits.relationship]
52Const-volatile modifications[tab:type-traits.const-volatile]
53Reference modifications[tab:type-traits.reference]
54Sign modifications[tab:type-traits.sign]
55Array modifications[tab:type-traits.array]
56Pointer modifications[tab:type-traits.pointer]
57Other transformations[tab:type-traits.other]
58Expressions used to perform ratio arithmetic[tab:ratio.arithmetic]
59Clock requirements[tab:time.clock]
60Header <ctime> synopsis[tab:util.hdr.ctime]
61Strings library summary[tab:strings.lib.summary]
62Character traits requirements[tab:char.traits.require]
63basic_string(const Allocator&) effects[tab:strings.ctr.1]
64basic_string(const basic_string&) effects[tab:strings.ctr.cpy]
65basic_string(const basic_string&, size_type, size_type, const Allocator&) effects[tab:strings.ctr.2]
66basic_string(const charT*, size_type, const Allocator&) effects[tab:strings.ctr.3]
67basic_string(const charT*, const Allocator&) effects[tab:strings.ctr.4]
68basic_string(size_t, charT, const Allocator&) effects[tab:strings.ctr.5]
69basic_string(const basic_string&, const Allocator&) and basic_string(basic_string&&, const Allocator&) effects[tab:strings.ctr.6]
70operator=(const basic_string&) effects[tab:strings.op=]
71operator=(basic_string&&) effects[tab:strings.op=rv]
72compare() results[tab:strings.compare]
73Potential mbstate_t data races[tab:mbstate.data.races]
74Header <cctype> synopsis[tab:strings.hdr.cctype]
75Header <cwctype> synopsis[tab:strings.hdr.cwctype]
76Header <cstring> synopsis[tab:strings.hdr.cstring]
77Header <cwchar> synopsis[tab:strings.hdr.cwchar]
78Header <cstdlib> synopsis[tab:strings.hdr.cstdlib]
79Header <cuchar> synopsis[tab:strings.hdr.cuchar]
80Localization library summary[tab:localization.lib.summary]
81Locale category facets[tab:localization.category.facets]
82Required specializations[tab:localization.required.specializations]
83do_in/do_out result values[tab:localization.convert.result.values.out.in]
84do_unshift result values[tab:localization.convert.result.values.unshift]
85Integer conversions[tab:localization.integer.conversions.in]
86Length modifier[tab:localization.length.modifier.in]
87Integer conversions[tab:localization.integer.conversions.out]
88Floating-point conversions[tab:localization.fp.conversions.out]
89Length modifier[tab:localization.length.modifier.out]
90Numeric conversions[tab:localization.numeric.conversions]
91Fill padding[tab:localization.fill.padding]
92do_get_date effects[tab:lib.locale.time.get.virtuals.dogetdate]
93Header <clocale> synopsis[tab:localization.hdr.clocale]
94Potential setlocale data races[tab:setlocale.data.races]
95Containers library summary[tab:containers.lib.summary]
96Container requirements[tab:containers.container.requirements]
97Reversible container requirements[tab:containers.reversible.requirements]
98Optional container operations[tab:containers.optional.operations]
99Allocator-aware container requirements[tab:containers.allocatoraware]
100Sequence container requirements (in addition to container)[tab:containers.sequence.requirements]
101Optional sequence container operations[tab:containers.sequence.optional]
102Associative container requirements (in addition to container)[tab:containers.associative.requirements]
103Unordered associative container requirements (in addition to container)[tab:HashRequirements]
104Iterators library summary[tab:iterators.lib.summary]
105Relations among iterator categories[tab:iterators.relations]
106Iterator requirements[tab:iterator.requirements]
107Input iterator requirements (in addition to Iterator)[tab:iterator.input.requirements]
108Output iterator requirements (in addition to Iterator)[tab:iterator.output.requirements]
109Forward iterator requirements (in addition to input iterator)[tab:iterator.forward.requirements]
110Bidirectional iterator requirements (in addition to forward iterator)[tab:iterator.bidirectional.requirements]
111Random access iterator requirements (in addition to bidirectional iterator)[tab:iterator.random.access.requirements]
112Algorithms library summary[tab:algorithms.summary]
113Header <cstdlib> synopsis[tab:algorithms.hdr.cstdlib]
114Numerics library summary[tab:numerics.lib.summary]
115Seed sequence requirements[tab:SeedSequence]
116Uniform random number generator requirements[tab:UniformRandomNumberGenerator]
117Random number engine requirements[tab:RandomEngine]
118Random number distribution requirements[tab:RandomDistribution]
119Header <cmath> synopsis[tab:numerics.hdr.cmath]
120Header <cstdlib> synopsis[tab:numerics.hdr.cstdlib]
121Input/output library summary[tab:iostreams.lib.summary]
122fmtflags effects[tab:iostreams.fmtflags.effects]
123fmtflags constants[tab:iostreams.fmtflags.constants]
124iostate effects[tab:iostreams.iostate.effects]
125openmode effects[tab:iostreams.openmode.effects]
126seekdir effects[tab:iostreams.seekdir.effects]
127Position type requirements[tab:iostreams.position.requirements]
128basic_ios::init() effects[tab:iostreams.basicios.init.effects]
129basic_ios::copyfmt() effects[tab:iostreams.copyfmt.effects]
130seekoff positioning[tab:iostreams.seekoff.positioning]
131newoff values[tab:iostreams.newoff.values]
132File open modes[tab:iostreams.file.open.modes]
133seekoff effects[tab:iostreams.seekoff.effects]
134Header <cstdio> synopsis[tab:iostreams.hdr.cstdio]
135Header <cinttypes> synopsis[tab:iostreams.hdr.cinttypes]
136Regular expressions library summary[tab:re.lib.summary]
137Regular expression traits class requirements[tab:re:RegexpTraits]
138syntax_option_type effects[tab:re:syntaxoption]
139regex_constants::match_flag_type effects when obtaining a match against a character container sequence [first,last).[tab:re:matchflag]
140error_type values in the C locale[tab:re:errortype]
141Character class names and corresponding ctype masks[tab:re.traits.classnames]
142match_results assignment operator effects[tab:re:results:assign]
143Effects of regex_match algorithm[tab:re:alg:match]
144Effects of regex_search algorithm[tab:re:alg:search]
145Atomics library summary[tab:atomics.lib.summary]
146atomic integral typedefs[tab:atomics.integral]
147atomic <inttypes.h> typedefs[tab:atomics.typedefs]
148Atomic arithmetic computations[tab:atomic.arithmetic.computations]
149Thread support library summary[tab:thread.lib.summary]
150Standard macros[tab:diff.standard.macros]
151Standard values[tab:diff.standard.values]
152Standard types[tab:diff.standard.types]
153Standard structs[tab:diff.standard.structs]
154Standard functions[tab:diff.standard.functions]
155C headers[tab:future.c.headers]
156strstreambuf(streamsize) effects[tab:future.strstreambuf.effects]
157strstreambuf(void* (*)(size_t), void (*)(void*)) effects[tab:future.strstreambuf1.effects]
158strstreambuf(charT*, streamsize, charT*) effects[tab:future.strstreambuf2.effects]
159seekoff positioning[tab:future.seekoff.positioning]
160newoff 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 General [intro][intro]

1.2 Normative references [intro.refs]

1.4 Implementation compliance [intro.compliance]

1.5 Structure of this International Standard [intro.structure]

1.6 Syntax notation [syntax]

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

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

1.9 Program execution [intro.execution]

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

1.11 Acknowledgments [intro.ack]

2 Lexical conventions [lex][lex]

2.1 Separate translation [lex.separate]

2.2 Phases of translation [lex.phases]

2.3 Character sets [lex.charset]

2.4 Trigraph sequences [lex.trigraph]

2.5 Preprocessing tokens [lex.pptoken]

2.6 Alternative tokens [lex.digraph]

2.7 Tokens [lex.token]

2.8 Comments [lex.comment]

2.9 Header names [lex.header]

2.10 Preprocessing numbers [lex.ppnumber]

2.11 Identifiers [lex.name]

2.12 Keywords [lex.key]

2.13 Operators and punctuators [lex.operators]

2.14 Literals [lex.literal]

2.14.1 Kinds of literals [lex.literal.kinds]

2.14.2 Integer literals [lex.icon]

2.14.3 Character literals [lex.ccon]

2.14.4 Floating literals [lex.fcon]

2.14.5 String literals [lex.string]

2.14.6 Boolean literals [lex.bool]

2.14.7 Pointer literals [lex.nullptr]

2.14.8 User-defined literals [lex.ext]

3 Basic concepts [basic][basic]

3.1 Declarations and definitions [basic.def]

3.2 One definition rule [basic.def.odr]

3.3 Scope [basic.scope]

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

3.3.2 Point of declaration [basic.scope.pdecl]

3.3.4 Function prototype scope [basic.scope.proto]

3.3.5 Function scope [basic.funscope]

3.3.6 Namespace scope [basic.scope.namespace]

3.3.8 Enumeration scope [basic.scope.enum]

3.3.9 Template parameter scope [basic.scope.temp]

3.4 Name lookup [basic.lookup]

3.4.1 Unqualified name lookup [basic.lookup.unqual]

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

3.4.3 Qualified name lookup [basic.lookup.qual]

3.4.3.1 Class members [class.qual]

3.4.3.2 Namespace members [namespace.qual]

3.4.4 Elaborated type specifiers [basic.lookup.elab]

3.4.5 Class member access [basic.lookup.classref]

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

3.6 Start and termination [basic.start]

3.6.1 Main function [basic.start.main]

3.6.2 Initialization of non-local variables [basic.start.init]

3.7 Storage duration [basic.stc]

3.7.1 Static storage duration [basic.stc.static]

3.7.2 Thread storage duration [basic.stc.thread]

3.7.3 Automatic storage duration [basic.stc.auto]

3.7.4 Dynamic storage duration [basic.stc.dynamic]

3.7.4.2 Deallocation functions [basic.stc.dynamic.deallocation]

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

3.7.5 Duration of subobjects [basic.stc.inherit]

3.8 Object lifetime [basic.life]

3.9 Types [basic.types]

3.9.1 Fundamental types [basic.fundamental]

3.9.2 Compound types [basic.compound]

3.10 Lvalues and rvalues [basic.lval]

3.11 Alignment [basic.align]

4 Standard conversions [conv][conv]

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

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

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

4.4 Qualification conversions [conv.qual]

4.5 Integral promotions [conv.prom]

4.6 Floating point promotion [conv.fpprom]

4.7 Integral conversions [conv.integral]

4.8 Floating point conversions [conv.double]

4.9 Floating-integral conversions [conv.fpint]

4.10 Pointer conversions [conv.ptr]

4.11 Pointer to member conversions [conv.mem]

4.12 Boolean conversions [conv.bool]

4.13 Integer conversion rank [conv.rank]

5 Expressions [expr][expr]

5.1 Primary expressions [expr.prim]

5.1.2 Lambda expressions [expr.prim.lambda]

5.2 Postfix expressions [expr.post]

5.2.1 Subscripting [expr.sub]

5.2.2 Function call [expr.call]

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

5.2.4 Pseudo destructor call [expr.pseudo]

5.2.5 Class member access [expr.ref]

5.2.6 Increment and decrement [expr.post.incr]

5.2.7 Dynamic cast [expr.dynamic.cast]

5.2.8 Type identification [expr.typeid]

5.2.10 Reinterpret cast [expr.reinterpret.cast]

5.3 Unary expressions [expr.unary]

5.3.1 Unary operators [expr.unary.op]

5.3.2 Increment and decrement [expr.pre.incr]

5.3.7 noexcept operator [expr.unary.noexcept]

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

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

5.6 Multiplicative operators [expr.mul]

5.7 Additive operators [expr.add]

5.8 Shift operators [expr.shift]

5.9 Relational operators [expr.rel]

5.10 Equality operators [expr.eq]

5.11 Bitwise AND operator [expr.bit.and]

5.12 Bitwise exclusive OR operator [expr.xor]

5.13 Bitwise inclusive OR operator [expr.or]

5.14 Logical AND operator [expr.log.and]

5.15 Logical OR operator [expr.log.or]

5.16 Conditional operator [expr.cond]

5.17 Assignment and compound assignment operators [expr.ass]

5.18 Comma operator [expr.comma]

5.19 Constant expressions [expr.const]

6 Statements [stmt.stmt][stmt.stmt]

6.1 Labeled statement [stmt.label]

6.2 Expression statement [stmt.expr]

6.3 Compound statement or block [stmt.block]

6.4 Selection statements [stmt.select]

6.4.1 The if statement [stmt.if]

6.4.2 The switch statement [stmt.switch]

6.5 Iteration statements [stmt.iter]

6.5.1 The while statement [stmt.while]

6.5.2 The do statement [stmt.do]

6.5.3 The for statement [stmt.for]

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

6.6 Jump statements [stmt.jump]

6.6.1 The break statement [stmt.break]

6.6.2 The continue statement [stmt.cont]

6.6.3 The return statement [stmt.return]

6.6.4 The goto statement [stmt.goto]

6.7 Declaration statement [stmt.dcl]

6.8 Ambiguity resolution [stmt.ambig]

7 Declarations [dcl.dcl][dcl.dcl]

7.1 Specifiers [dcl.spec]

7.1.1 Storage class specifiers [dcl.stc]

7.1.2 Function specifiers [dcl.fct.spec]

7.1.3 The typedef specifier [dcl.typedef]

7.1.4 The friend specifier [dcl.friend]

7.1.5 The constexpr specifier [dcl.constexpr]

7.1.6 Type specifiers [dcl.type]

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

7.1.6.2 Simple type specifiers [dcl.type.simple]

7.1.6.3 Elaborated type specifiers [dcl.type.elab]

7.1.6.4 auto specifier [dcl.spec.auto]

7.2 Enumeration declarations [dcl.enum]

7.3 Namespaces [basic.namespace]

7.3.1 Namespace definition [namespace.def]

7.3.1.1 Unnamed namespaces [namespace.unnamed]

7.3.1.2 Namespace member definitions [namespace.memdef]

7.3.2 Namespace alias [namespace.alias]

7.3.3 The using declaration [namespace.udecl]

7.3.4 Using directive [namespace.udir]

7.4 The asm declaration [dcl.asm]

7.6 Attributes [dcl.attr]

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

7.6.2 Alignment specifier [dcl.align]

7.6.3 Noreturn attribute [dcl.attr.noreturn]

7.6.4 Carries dependency attribute [dcl.attr.depend]

7.6.5 Deprecated attribute [dcl.attr.deprecated]

8 Declarators [dcl.decl][dcl.decl]

8.1 Type names [dcl.name]

8.2 Ambiguity resolution [dcl.ambig.res]

8.3 Meaning of declarators [dcl.meaning]

8.3.1 Pointers [dcl.ptr]

8.3.2 References [dcl.ref]

8.3.3 Pointers to members [dcl.mptr]

8.3.5 Functions [dcl.fct]

8.3.6 Default arguments [dcl.fct.default]

8.4 Function definitions [dcl.fct.def]

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

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

8.5 Initializers [dcl.init]

8.5.1 Aggregates [dcl.init.aggr]

8.5.2 Character arrays [dcl.init.string]

8.5.3 References [dcl.init.ref]

8.5.4 List-initialization [dcl.init.list]

9 Classes [class][class]

9.1 Class names [class.name]

9.2 Class members [class.mem]

9.3 Member functions [class.mfct]

9.3.1 Nonstatic member functions [class.mfct.non-static]

9.3.2 The this pointer [class.this]

9.4 Static members [class.static]

9.4.1 Static member functions [class.static.mfct]

9.4.2 Static data members [class.static.data]

9.6 Bit-fields [class.bit]

9.7 Nested class declarations [class.nest]

9.8 Local class declarations [class.local]

9.9 Nested type names [class.nested.type]

10 Derived classes [class.derived][class.derived]

10.1 Multiple base classes [class.mi]

10.2 Member name lookup [class.member.lookup]

10.3 Virtual functions [class.virtual]

10.4 Abstract classes [class.abstract]

11 Member access control [class.access][class.access]

11.1 Access specifiers [class.access.spec]

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

11.4 Protected member access [class.protected]

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

11.6 Multiple access [class.paths]

11.7 Nested classes [class.access.nest]

12 Special member functions [special][special]

12.1 Constructors [class.ctor]

12.2 Temporary objects [class.temporary]

12.3 Conversions [class.conv]

12.3.1 Conversion by constructor [class.conv.ctor]

12.3.2 Conversion functions [class.conv.fct]

12.4 Destructors [class.dtor]

12.5 Free store [class.free]

12.6 Initialization [class.init]

12.6.1 Explicit initialization [class.expl.init]

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

12.7 Construction and destruction [class.cdtor]

12.8 Copying and moving class objects [class.copy]

12.9 Inheriting constructors [class.inhctor]

13 Overloading [over][over]

13.1 Overloadable declarations [over.load]

13.2 Declaration matching [over.dcl]

13.3 Overload resolution [over.match]

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

13.3.1.1 Function call syntax [over.match.call]

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

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

13.3.1.2 Operators in expressions [over.match.oper]

13.3.1.3 Initialization by constructor [over.match.ctor]

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

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

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

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

13.3.2 Viable functions [over.match.viable]

13.3.3 Best viable function [over.match.best]

13.3.3.1 Implicit conversion sequences [over.best.ics]

13.3.3.1.1 Standard conversion sequences [over.ics.scs]

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

13.3.3.1.3 Ellipsis conversion sequences [over.ics.ellipsis]

13.3.3.1.4 Reference binding [over.ics.ref]

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

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

13.4 Address of overloaded function [over.over]

13.5 Overloaded operators [over.oper]

13.5.1 Unary operators [over.unary]

13.5.2 Binary operators [over.binary]

13.5.3 Assignment [over.ass]

13.5.4 Function call [over.call]

13.5.5 Subscripting [over.sub]

13.5.6 Class member access [over.ref]

13.5.7 Increment and decrement [over.inc]

13.5.8 User-defined literals [over.literal]

13.6 Built-in operators [over.built]

14 Templates [temp][temp]

14.1 Template parameters [temp.param]

14.2 Names of template specializations [temp.names]

14.3 Template arguments [temp.arg]

14.3.1 Template type arguments [temp.arg.type]

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

14.3.3 Template template arguments [temp.arg.template]

14.4 Type equivalence [temp.type]

14.5 Template declarations [temp.decls]

14.5.1 Class templates [temp.class]

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

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

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

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

14.5.2 Member templates [temp.mem]

14.5.3 Variadic templates [temp.variadic]

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

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

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

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

14.5.6 Function templates [temp.fct]

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

14.5.7 Alias templates [temp.alias]

14.6 Name resolution [temp.res]

14.6.1 Locally declared names [temp.local]

14.6.2 Dependent names [temp.dep]

14.6.2.1 Dependent types [temp.dep.type]

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

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

14.6.2.4 Dependent template arguments [temp.dep.temp]

14.6.3 Non-dependent names [temp.nondep]

14.6.4 Dependent name resolution [temp.dep.res]

14.6.4.1 Point of instantiation [temp.point]

14.6.4.2 Candidate functions [temp.dep.candidate]

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

14.7 Template instantiation and specialization [temp.spec]

14.7.1 Implicit instantiation [temp.inst]

14.7.2 Explicit instantiation [temp.explicit]

14.7.3 Explicit specialization [temp.expl.spec]

14.8 Function template specializations [temp.fct.spec]

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

14.8.2 Template argument deduction [temp.deduct]

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

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

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

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

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

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

14.8.3 Overload resolution [temp.over]

15 Exception handling [except][except]

15.1 Throwing an exception [except.throw]

15.2 Constructors and destructors [except.ctor]

15.3 Handling an exception [except.handle]

15.4 Exception specifications [except.spec]

15.5 Special functions [except.special]

15.5.1 The std::terminate() function [except.terminate]

15.5.2 The std::unexpected() function [except.unexpected]

15.5.3 The std::uncaught_exception() function [except.uncaught]

16 Preprocessing directives [cpp][cpp]

16.1 Conditional inclusion [cpp.cond]

16.2 Source file inclusion [cpp.include]

16.3 Macro replacement [cpp.replace]

16.3.1 Argument substitution [cpp.subst]

16.3.2 The # operator [cpp.stringize]

16.3.3 The ## operator [cpp.concat]

16.3.4 Rescanning and further replacement [cpp.rescan]

16.3.5 Scope of macro definitions [cpp.scope]

16.4 Line control [cpp.line]

16.5 Error directive [cpp.error]

16.6 Pragma directive [cpp.pragma]

16.7 Null directive [cpp.null]

16.8 Predefined macro names [cpp.predefined]

16.9 Pragma operator [cpp.pragma.op]

17 Library introduction [library][library]

17.2 The C standard library [library.c]

17.3 Definitions [definitions]

17.3.1 arbitrary-positional stream [defns.arbitrary.stream]

17.3.3 blocked thread [defns.blocked]

17.3.5 character container type [defns.character.container]

17.3.6 comparison function [defns.comparison]

17.3.11 handler function [defns.handler]

17.3.12 iostream class templates [defns.iostream.templates]

17.3.13 modifier function [defns.modifier]

17.3.14 move construction [defns.move.constr]

17.3.15 move assignment [defns.move.assign]

17.3.16 object state [defns.obj.state]

17.3.18 observer function [defns.observer]

17.3.19 referenceable type [defns.referenceable]

17.3.20 replacement function [defns.replacement]

17.3.21 repositional stream [defns.repositional.stream]

17.3.24 stable algorithm [defns.stable]

17.3.25 traits class [defns.traits]

17.3.27 valid but unspecified state [defns.valid]

17.4 Additional definitions [defns.additional]

17.5 Method of description (Informative) [description]

17.6 Library-wide requirements [requirements]

17.6.1 Library contents and organization [organization]

17.6.1.1 Library contents [contents]

17.6.1.3 Freestanding implementations [compliance]

17.6.3 Requirements on types and expressions [utility.requirements]

17.6.3.1 Template argument requirements [utility.arg.requirements]

17.6.3.2 Swappable requirements [swappable.requirements]

17.6.3.3 NullablePointer requirements [nullablepointer.requirements]

17.6.3.4 Hash requirements [hash.requirements]

17.6.3.5 Allocator requirements [allocator.requirements]

17.6.4 Constraints on programs [constraints]

17.6.4.3 Reserved names [reserved.names]

17.6.4.3.2 Global names [global.names]

17.6.4.3.3 External linkage [extern.names]

17.6.4.3.5 User-defined literal suffixes [usrlit.suffix]

17.6.4.5 Derived classes [derived.classes]

17.6.4.6 Replacement functions [replacement.functions]

17.6.4.7 Handler functions [handler.functions]

17.6.4.8 Other functions [res.on.functions]

17.6.4.9 Function arguments [res.on.arguments]

17.6.4.10 Shared objects and the library [res.on.objects]

17.6.4.11 Requires paragraph [res.on.required]

17.6.5 Conforming implementations [conforming]

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

17.6.5.4 Global and non-member functions [global.functions]

17.6.5.5 Member functions [member.functions]

17.6.5.6 constexpr functions and constructors [constexpr.functions]

17.6.5.7 Requirements for stable algorithms [algorithm.stable]

17.6.5.8 Reentrancy [reentrancy]

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

17.6.5.10 Protection within classes [protection.within.classes]

17.6.5.11 Derived classes [derivation]

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

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

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

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

18 Language support library [language.support][language.support]

18.3 Implementation properties [support.limits]

18.3.2 Numeric limits [limits]

18.3.2.1 Class template numeric_limits [limits.numeric]

18.3.2.2 Header <limits> synopsis [limits.syn]

18.3.2.3 Class template numeric_limits [numeric.limits]

18.3.2.4 numeric_limits members [numeric.limits.members]

18.3.2.5 Type float_round_style [round.style]

18.3.2.6 Type float_denorm_style [denorm.style]

18.3.2.7 numeric_limits specializations [numeric.special]

18.3.3 C library [c.limits]

18.4 Integer types [cstdint]

18.4.1 Header <cstdint> synopsis [cstdint.syn]

18.5 Start and termination [support.start.term]

18.6 Dynamic memory management [support.dynamic]

18.6.1 Storage allocation and deallocation [new.delete]

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

18.6.2 Storage allocation errors [alloc.errors]

18.6.2.1 Class bad_alloc [bad.alloc]

18.6.2.2 Class bad_array_new_length [new.badlength]

18.6.2.3 Type new_handler [new.handler]

18.6.2.4 set_new_handler [set.new.handler]

18.6.2.5 get_new_handler [get.new.handler]

18.7 Type identification [support.rtti]

18.7.1 Class type_info [type.info]

18.7.2 Class bad_cast [bad.cast]

18.7.3 Class bad_typeid [bad.typeid]

18.8 Exception handling [support.exception]

18.8.1 Class exception [exception]

18.8.2 Class bad_exception [bad.exception]

18.8.3 Abnormal termination [exception.terminate]

18.8.3.1 Type terminate_handler [terminate.handler]

18.8.3.2 set_terminate [set.terminate]

18.8.3.3 get_terminate [get.terminate]

18.8.3.4 terminate [terminate]

18.8.4 uncaught_exception [uncaught]

18.8.5 Exception propagation [propagation]

18.8.6 nested_exception [except.nested]

18.9 Initializer lists [support.initlist]

18.9.1 Initializer list constructors [support.initlist.cons]

18.9.2 Initializer list access [support.initlist.access]

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

18.10 Other runtime support [support.runtime]

19 Diagnostics library [diagnostics][diagnostics]

19.2 Exception classes [std.exceptions]

19.2.1 Class logic_error [logic.error]

19.2.2 Class domain_error [domain.error]

19.2.3 Class invalid_argument [invalid.argument]

19.2.4 Class length_error [length.error]

19.2.5 Class out_of_range [out.of.range]

19.2.6 Class runtime_error [runtime.error]

19.2.7 Class range_error [range.error]

19.2.8 Class overflow_error [overflow.error]

19.2.9 Class underflow_error [underflow.error]

19.3 Assertions [assertions]

19.4 Error numbers [errno]

19.5 System error support [syserr]

19.5.1 Class error_category [syserr.errcat]

19.5.1.1 Class error_category overview [syserr.errcat.overview]

19.5.1.2 Class error_category virtual members [syserr.errcat.virtuals]

19.5.1.3 Class error_category non-virtual members [syserr.errcat.nonvirtuals]

19.5.1.4 Program defined classes derived from error_category [syserr.errcat.derived]

19.5.1.5 Error category objects [syserr.errcat.objects]

19.5.2 Class error_code [syserr.errcode]

19.5.2.1 Class error_code overview [syserr.errcode.overview]

19.5.2.2 Class error_code constructors [syserr.errcode.constructors]

19.5.2.3 Class error_code modifiers [syserr.errcode.modifiers]

19.5.2.4 Class error_code observers [syserr.errcode.observers]

19.5.2.5 Class error_code non-member functions [syserr.errcode.nonmembers]

19.5.3 Class error_condition [syserr.errcondition]

19.5.3.1 Class error_condition overview [syserr.errcondition.overview]

19.5.3.2 Class error_condition constructors [syserr.errcondition.constructors]

19.5.3.3 Class error_condition modifiers [syserr.errcondition.modifiers]

19.5.3.4 Class error_condition observers [syserr.errcondition.observers]

19.5.3.5 Class error_condition non-member functions [syserr.errcondition.nonmembers]

19.5.4 Comparison operators [syserr.compare]

19.5.5 System error hash support [syserr.hash]

19.5.6 Class system_error [syserr.syserr]

19.5.6.1 Class system_error overview [syserr.syserr.overview]

19.5.6.2 Class system_error members [syserr.syserr.members]

20 General utilities library [utilities][utilities]

20.2 Utility components [utility]

20.2.1 Operators [operators]

20.2.4 forward/move helpers [forward]

20.2.5 Function template declval [declval]

20.3 Pairs [pairs]

20.3.1 In general [pairs.general]

20.3.2 Class template pair [pairs.pair]

20.3.3 Specialized algorithms [pairs.spec]

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

20.3.5 Piecewise construction [pair.piecewise]

20.4 Tuples [tuple]

20.4.1 In general [tuple.general]

20.4.2 Class template tuple [tuple.tuple]

20.4.2.1 Construction [tuple.cnstr]

20.4.2.4 Tuple creation functions [tuple.creation]

20.4.2.5 Tuple helper classes [tuple.helper]

20.4.2.6 Element access [tuple.elem]

20.4.2.7 Relational operators [tuple.rel]

20.4.2.8 Tuple traits [tuple.traits]

20.4.2.9 Tuple specialized algorithms [tuple.special]

20.5 Compile-time integer sequences [intseq]

20.5.2 Class template integer_sequence [intseq.intseq]

20.5.3 Alias template make_integer_sequence [intseq.make]

20.6 Class template bitset [template.bitset]

20.6.1 bitset constructors [bitset.cons]

20.6.2 bitset members [bitset.members]

20.6.3 bitset hash support [bitset.hash]

20.6.4 bitset operators [bitset.operators]

20.7 Memory [memory]

20.7.2 Header <memory> synopsis [memory.syn]

20.7.3 Pointer traits [pointer.traits]

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

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

20.7.4 Pointer safety [util.dynamic.safety]

20.7.6 Allocator argument tag [allocator.tag]

20.7.7 uses_allocator [allocator.uses]

20.7.7.1 uses_allocator trait [allocator.uses.trait]

20.7.7.2 uses-allocator construction [allocator.uses.construction]

20.7.8 Allocator traits [allocator.traits]

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

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

20.7.9 The default allocator [default.allocator]

20.7.9.1 allocator members [allocator.members]

20.7.9.2 allocator globals [allocator.globals]

20.7.10 Raw storage iterator [storage.iterator]

20.7.11 Temporary buffers [temporary.buffer]

20.7.12 Specialized algorithms [specialized.algorithms]

20.7.12.2 uninitialized_copy [uninitialized.copy]

20.7.12.3 uninitialized_fill [uninitialized.fill]

20.7.12.4 uninitialized_fill_n [uninitialized.fill.n]

20.7.13 C library [c.malloc]

20.8 Smart pointers [smartptr]

20.8.1 Class template unique_ptr [unique.ptr]

20.8.1.2 unique_ptr for single objects [unique.ptr.single]

20.8.1.2.1 unique_ptr constructors [unique.ptr.single.ctor]

20.8.1.2.2 unique_ptr destructor [unique.ptr.single.dtor]

20.8.1.2.3 unique_ptr assignment [unique.ptr.single.asgn]

20.8.1.3 unique_ptr for array objects with a runtime length [unique.ptr.runtime]

20.8.1.3.1 unique_ptr constructors [unique.ptr.runtime.ctor]

20.8.1.4 unique_ptr creation [unique.ptr.create]

20.8.1.5 unique_ptr specialized algorithms [unique.ptr.special]

20.8.2 Shared-ownership pointers [util.smartptr]

20.8.2.1 Class bad_weak_ptr [util.smartptr.weakptr]

20.8.2.3 Class template weak_ptr [util.smartptr.weak]

20.8.2.3.1 weak_ptr constructors [util.smartptr.weak.const]

20.8.2.3.6 weak_ptr specialized algorithms [util.smartptr.weak.spec]

20.8.2.4 Class template owner_less [util.smartptr.ownerless]

20.8.2.5 Class template enable_shared_from_this [util.smartptr.enab]

20.8.2.6 shared_ptr atomic access [util.smartptr.shared.atomic]

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

20.9 Function objects [function.objects]

20.9.1 Definitions [func.def]

20.9.2 Requirements [func.require]

20.9.3 Class template reference_wrapper [refwrap]

20.9.3.1 reference_wrapper construct/copy/destroy [refwrap.const]

20.9.3.2 reference_wrapper assignment [refwrap.assign]

20.9.3.3 reference_wrapper access [refwrap.access]

20.9.3.4 reference_wrapper invocation [refwrap.invoke]

20.9.3.5 reference_wrapper helper functions [refwrap.helpers]

20.9.4 Arithmetic operations [arithmetic.operations]

20.9.5 Comparisons [comparisons]

20.9.6 Logical operations [logical.operations]

20.9.7 Bitwise operations [bitwise.operations]

20.9.8 Negators [negators]

20.9.9 Function object binders [func.bind]

20.9.9.1 Class template is_bind_expression [func.bind.isbind]

20.9.9.2 Class template is_placeholder [func.bind.isplace]

20.9.9.3 Function template bind [func.bind.bind]

20.9.10 Function template mem_fn [func.memfn]

20.9.11 Polymorphic function wrappers [func.wrap]

20.9.11.1 Class bad_function_call [func.wrap.badcall]

20.9.11.1.1 bad_function_call constructor [func.wrap.badcall.const]

20.9.11.2 Class template function [func.wrap.func]

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

20.9.11.2.2 function modifiers [func.wrap.func.mod]

20.9.11.2.3 function capacity [func.wrap.func.cap]

20.9.11.2.4 function invocation [func.wrap.func.inv]

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

20.9.11.2.6 null pointer comparison operators [func.wrap.func.nullptr]

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

20.9.12 Class template hash [unord.hash]

20.10 Metaprogramming and type traits [meta]

20.10.1 Requirements [meta.rqmts]

20.10.2 Header <type_traits> synopsis [meta.type.synop]

20.10.3 Helper classes [meta.help]

20.10.4 Unary type traits [meta.unary]

20.10.4.1 Primary type categories [meta.unary.cat]

20.10.4.2 Composite type traits [meta.unary.comp]

20.10.4.3 Type properties [meta.unary.prop]

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

20.10.6 Relationships between types [meta.rel]

20.10.7 Transformations between types [meta.trans]

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

20.10.7.2 Reference modifications [meta.trans.ref]

20.10.7.3 Sign modifications [meta.trans.sign]

20.10.7.4 Array modifications [meta.trans.arr]

20.10.7.5 Pointer modifications [meta.trans.ptr]

20.10.7.6 Other transformations [meta.trans.other]

20.11 Compile-time rational arithmetic [ratio]

20.11.2 Header <ratio> synopsis [ratio.syn]

20.11.3 Class template ratio [ratio.ratio]

20.11.4 Arithmetic on ratios [ratio.arithmetic]

20.11.5 Comparison of ratios [ratio.comparison]

20.11.6 SI types for ratio [ratio.si]

20.12 Time utilities [time]

20.12.1 In general [time.general]

20.12.2 Header <chrono> synopsis [time.syn]

20.12.3 Clock requirements [time.clock.req]

20.12.4 Time-related traits [time.traits]

20.12.4.1 treat_as_floating_point [time.traits.is_fp]

20.12.4.3 Specializations of common_type [time.traits.specializations]

20.12.5 Class template duration [time.duration]

20.12.5.1 duration constructors [time.duration.cons]

20.12.5.4 duration special values [time.duration.special]

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

20.12.5.6 duration comparisons [time.duration.comparisons]

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

20.12.6 Class template time_point [time.point]

20.12.6.1 time_point constructors [time.point.cons]

20.12.6.2 time_point observer [time.point.observer]

20.12.6.3 time_point arithmetic [time.point.arithmetic]

20.12.6.4 time_point special values [time.point.special]

20.12.6.5 time_point non-member arithmetic [time.point.nonmember]

20.12.6.6 time_point comparisons [time.point.comparisons]

20.12.6.7 time_point_cast [time.point.cast]

20.12.7 Clocks [time.clock]

20.12.7.1 Class system_clock [time.clock.system]

20.12.7.2 Class steady_clock [time.clock.steady]

20.12.7.3 Class high_resolution_clock [time.clock.hires]

20.12.8 Date and time functions [date.time]

20.13 Class template scoped_allocator_adaptor [allocator.adaptor]

20.13.1 Header <scoped_allocator> synopsis [allocator.adaptor.syn]

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

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

20.13.4 Scoped allocator adaptor members [allocator.adaptor.members]

20.13.5 Scoped allocator operators [scoped.adaptor.operators]

20.14 Class type_index [type.index]

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

20.14.2 type_index overview [type.index.overview]

20.14.3 type_index members [type.index.members]

20.14.4 Hash support [type.index.hash]

21 Strings library [strings][strings]

21.2 Character traits [char.traits]

21.2.1 Character traits requirements [char.traits.require]

21.2.2 traits typedefs [char.traits.typedefs]

21.2.3 char_traits specializations [char.traits.specializations]

21.2.3.1 struct char_traits<char> [char.traits.specializations.char]

21.2.3.2 struct char_traits<char16_t> [char.traits.specializations.char16_t]

21.2.3.3 struct char_traits<char32_t> [char.traits.specializations.char32_t]

21.2.3.4 struct char_traits<wchar_t> [char.traits.specializations.wchar.t]

21.3 String classes [string.classes]

21.4 Class template basic_string [basic.string]

21.4.1 basic_string general requirements [string.require]

21.4.2 basic_string constructors and assignment operators [string.cons]

21.4.3 basic_string iterator support [string.iterators]

21.4.4 basic_string capacity [string.capacity]

21.4.5 basic_string element access [string.access]

21.4.6 basic_string modifiers [string.modifiers]

21.4.6.1 basic_string::operator+= [string::op+=]

21.4.6.2 basic_string::append [string::append]

21.4.6.3 basic_string::assign [string::assign]

21.4.6.4 basic_string::insert [string::insert]

21.4.6.5 basic_string::erase [string::erase]

21.4.6.6 basic_string::replace [string::replace]

21.4.6.7 basic_string::copy [string::copy]

21.4.6.8 basic_string::swap [string::swap]

21.4.7 basic_string string operations [string.ops]

21.4.7.1 basic_string accessors [string.accessors]

21.4.7.2 basic_string::find [string::find]

21.4.7.3 basic_string::rfind [string::rfind]

21.4.7.4 basic_string::find_first_of [string::find.first.of]

21.4.7.5 basic_string::find_last_of [string::find.last.of]

21.4.7.6 basic_string::find_first_not_of [string::find.first.not.of]

21.4.7.7 basic_string::find_last_not_of [string::find.last.not.of]

21.4.7.8 basic_string::substr [string::substr]

21.4.7.9 basic_string::compare [string::compare]

21.4.8 basic_string non-member functions [string.nonmembers]

21.4.8.9 Inserters and extractors [string.io]

21.5 Numeric conversions [string.conversions]

21.6 Hash support [basic.string.hash]

21.7 Suffix for basic_string literals [basic.string.literals]

21.8 Null-terminated sequence utilities [c.strings]

22 Localization library [localization][localization]

22.2 Header <locale> synopsis [locale.syn]

22.3 Locales [locales]

22.3.1 Class locale [locale]

22.3.1.1 locale types [locale.types]

22.3.1.1.1 Type locale::category [locale.category]

22.3.1.1.2 Class locale::facet [locale.facet]

22.3.1.1.3 Class locale::id [locale.id]

22.3.1.2 locale constructors and destructor [locale.cons]

22.3.1.3 locale members [locale.members]

22.3.1.4 locale operators [locale.operators]

22.3.1.5 locale static members [locale.statics]

22.3.3 Convenience interfaces [locale.convenience]

22.3.3.1 Character classification [classification]

22.3.3.2 Conversions [conversions]

22.3.3.2.1 Character conversions [conversions.character]

22.3.3.2.2 string conversions [conversions.string]

22.3.3.2.3 Buffer conversions [conversions.buffer]

22.4 Standard locale categories [locale.categories]

22.4.1 The ctype category [category.ctype]

22.4.1.1 Class template ctype [locale.ctype]

22.4.1.1.2 ctype virtual functions [locale.ctype.virtuals]

22.4.1.2 Class template ctype_byname [locale.ctype.byname]

22.4.1.3 ctype specializations [facet.ctype.special]

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

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

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

22.4.1.4 Class template codecvt [locale.codecvt]

22.4.1.4.2 codecvt virtual functions [locale.codecvt.virtuals]

22.4.1.5 Class template codecvt_byname [locale.codecvt.byname]

22.4.2 The numeric category [category.numeric]

22.4.2.1 Class template num_get [locale.num.get]

22.4.2.1.2 num_get virtual functions [facet.num.get.virtuals]

22.4.2.2 Class template num_put [locale.nm.put]

22.4.2.2.2 num_put virtual functions [facet.num.put.virtuals]

22.4.3 The numeric punctuation facet [facet.numpunct]

22.4.3.1 Class template numpunct [locale.numpunct]

22.4.3.1.2 numpunct virtual functions [facet.numpunct.virtuals]

22.4.3.2 Class template numpunct_byname [locale.numpunct.byname]

22.4.4 The collate category [category.collate]

22.4.4.1 Class template collate [locale.collate]

22.4.4.1.2 collate virtual functions [locale.collate.virtuals]

22.4.4.2 Class template collate_byname [locale.collate.byname]

22.4.5 The time category [category.time]

22.4.5.1 Class template time_get [locale.time.get]

22.4.5.1.2 time_get virtual functions [locale.time.get.virtuals]

22.4.5.2 Class template time_get_byname [locale.time.get.byname]

22.4.5.3 Class template time_put [locale.time.put]

22.4.5.3.2 time_put virtual functions [locale.time.put.virtuals]

22.4.5.4 Class template time_put_byname [locale.time.put.byname]

22.4.6 The monetary category [category.monetary]

22.4.6.1 Class template money_get [locale.money.get]

22.4.6.1.2 money_get virtual functions [locale.money.get.virtuals]

22.4.6.2 Class template money_put [locale.money.put]

22.4.6.2.2 money_put virtual functions [locale.money.put.virtuals]

22.4.6.3 Class template moneypunct [locale.moneypunct]

22.4.6.3.2 moneypunct virtual functions [locale.moneypunct.virtuals]

22.4.6.4 Class template moneypunct_byname [locale.moneypunct.byname]

22.4.7 The message retrieval category [category.messages]

22.4.7.1 Class template messages [locale.messages]

22.4.7.1.2 messages virtual functions [locale.messages.virtuals]

22.4.7.2 Class template messages_byname [locale.messages.byname]

22.4.8 Program-defined facets [facets.examples]

22.5 Standard code conversion facets [locale.stdcvt]

22.6 C library locales [c.locales]

23 Containers library [containers][containers]

23.2 Container requirements [container.requirements]

23.2.1 General container requirements [container.requirements.general]

23.2.3 Sequence containers [sequence.reqmts]

23.2.4 Associative containers [associative.reqmts]

23.2.4.1 Exception safety guarantees [associative.reqmts.except]

23.2.5 Unordered associative containers [unord.req]

23.2.5.1 Exception safety guarantees [unord.req.except]

23.3 Sequence containers [sequences]

23.3.2 Class template array [array]

23.3.2.1 Class template array overview [array.overview]

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

23.3.2.3 array specialized algorithms [array.special]

23.3.2.4 array::size [array.size]

23.3.2.5 array::data [array.data]

23.3.2.6 array::fill [array.fill]

23.3.2.7 array::swap [array.swap]

23.3.2.8 Zero sized arrays [array.zero]

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

23.3.3 Class template deque [deque]

23.3.3.1 Class template deque overview [deque.overview]

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

23.3.3.3 deque capacity [deque.capacity]

23.3.3.4 deque modifiers [deque.modifiers]

23.3.3.5 deque specialized algorithms [deque.special]

23.3.4 Class template forward_list [forwardlist]

23.3.4.1 Class template forward_list overview [forwardlist.overview]

23.3.4.2 forward_list constructors, copy, assignment [forwardlist.cons]

23.3.4.3 forward_list iterators [forwardlist.iter]

23.3.4.4 forward_list element access [forwardlist.access]

23.3.4.5 forward_list modifiers [forwardlist.modifiers]

23.3.4.6 forward_list operations [forwardlist.ops]

23.3.4.7 forward_list specialized algorithms [forwardlist.spec]

23.3.5 Class template list [list]

23.3.5.1 Class template list overview [list.overview]

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

23.3.5.3 list capacity [list.capacity]

23.3.5.4 list modifiers [list.modifiers]

23.3.5.5 list operations [list.ops]

23.3.5.6 list specialized algorithms [list.special]

23.3.6 Class template vector [vector]

23.3.6.1 Class template vector overview [vector.overview]

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

23.3.6.3 vector capacity [vector.capacity]

23.3.6.4 vector data [vector.data]

23.3.6.5 vector modifiers [vector.modifiers]

23.3.6.6 vector specialized algorithms [vector.special]

23.3.7 Class vector<bool> [vector.bool]

23.4 Associative containers [associative]

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

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

23.4.4 Class template map [map]

23.4.4.1 Class template map overview [map.overview]

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

23.4.4.3 map element access [map.access]

23.4.4.4 map modifiers [map.modifiers]

23.4.4.5 map specialized algorithms [map.special]

23.4.5 Class template multimap [multimap]

23.4.5.1 Class template multimap overview [multimap.overview]

23.4.5.2 multimap constructors [multimap.cons]

23.4.5.3 multimap modifiers [multimap.modifiers]

23.4.5.4 multimap specialized algorithms [multimap.special]

23.4.6 Class template set [set]

23.4.6.1 Class template set overview [set.overview]

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

23.4.6.3 set specialized algorithms [set.special]

23.4.7 Class template multiset [multiset]

23.4.7.1 Class template multiset overview [multiset.overview]

23.4.7.2 multiset constructors [multiset.cons]

23.4.7.3 multiset specialized algorithms [multiset.special]

23.5 Unordered associative containers [unord]

23.5.1 In general [unord.general]

23.5.2 Header <unordered_map> synopsis [unord.map.syn]

23.5.3 Header <unordered_set> synopsis [unord.set.syn]

23.5.4 Class template unordered_map [unord.map]

23.5.4.1 Class template unordered_map overview [unord.map.overview]

23.5.4.2 unordered_map constructors [unord.map.cnstr]

23.5.4.3 unordered_map element access [unord.map.elem]

23.5.4.4 unordered_map modifiers [unord.map.modifiers]

23.5.4.5 unordered_map swap [unord.map.swap]

23.5.5 Class template unordered_multimap [unord.multimap]

23.5.5.1 Class template unordered_multimap overview [unord.multimap.overview]

23.5.5.2 unordered_multimap constructors [unord.multimap.cnstr]

23.5.5.3 unordered_multimap modifiers [unord.multimap.modifiers]

23.5.5.4 unordered_multimap swap [unord.multimap.swap]

23.5.6 Class template unordered_set [unord.set]

23.5.6.1 Class template unordered_set overview [unord.set.overview]

23.5.6.2 unordered_set constructors [unord.set.cnstr]

23.5.6.3 unordered_set swap [unord.set.swap]

23.5.7 Class template unordered_multiset [unord.multiset]

23.5.7.1 Class template unordered_multiset overview [unord.multiset.overview]

23.5.7.2 unordered_multiset constructors [unord.multiset.cnstr]

23.5.7.3 unordered_multiset swap [unord.multiset.swap]

23.6 Container adaptors [container.adaptors]

23.6.2 Header <queue> synopsis [queue.syn]

23.6.3 Class template queue [queue]

23.6.3.1 queue definition [queue.defn]

23.6.3.2 queue constructors [queue.cons]

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

23.6.3.4 queue operators [queue.ops]

23.6.3.5 queue specialized algorithms [queue.special]

23.6.4 Class template priority_queue [priority.queue]

23.6.4.1 priority_queue constructors [priqueue.cons]

23.6.4.2 priority_queue constructors with allocators [priqueue.cons.alloc]

23.6.4.3 priority_queue members [priqueue.members]

23.6.4.4 priority_queue specialized algorithms [priqueue.special]

23.6.5 Class template stack [stack]

23.6.5.1 Header <stack> synopsis [stack.syn]

23.6.5.2 stack definition [stack.defn]

23.6.5.3 stack constructors [stack.cons]

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

23.6.5.5 stack operators [stack.ops]

23.6.5.6 stack specialized algorithms [stack.special]

24 Iterators library [iterators][iterators]

24.2 Iterator requirements [iterator.requirements]

24.2.3 Input iterators [input.iterators]

24.2.4 Output iterators [output.iterators]

24.2.5 Forward iterators [forward.iterators]

24.2.6 Bidirectional iterators [bidirectional.iterators]

24.2.7 Random access iterators [random.access.iterators]

24.3 Header <iterator> synopsis [iterator.synopsis]

24.4 Iterator primitives [iterator.primitives]

24.4.1 Iterator traits [iterator.traits]

24.4.2 Basic iterator [iterator.basic]

24.4.3 Standard iterator tags [std.iterator.tags]

24.4.4 Iterator operations [iterator.operations]

24.5 Iterator adaptors [predef.iterators]

24.5.2 Insert iterators [insert.iterators]

24.5.2.1 Class template back_insert_iterator [back.insert.iterator]

24.5.2.2 back_insert_iterator operations [back.insert.iter.ops]

24.5.2.2.1 back_insert_iterator constructor [back.insert.iter.cons]

24.5.2.2.2 back_insert_iterator::operator= [back.insert.iter.op=]

24.5.2.2.3 back_insert_iterator::operator* [back.insert.iter.op*]

24.5.2.2.4 back_insert_iterator::operator++ [back.insert.iter.op++]

24.5.2.2.5 back_inserter [back.inserter]

24.5.2.3 Class template front_insert_iterator [front.insert.iterator]

24.5.2.4 front_insert_iterator operations [front.insert.iter.ops]

24.5.2.4.1 front_insert_iterator constructor [front.insert.iter.cons]

24.5.2.4.2 front_insert_iterator::operator= [front.insert.iter.op=]

24.5.2.4.3 front_insert_iterator::operator* [front.insert.iter.op*]

24.5.2.4.4 front_insert_iterator::operator++ [front.insert.iter.op++]

24.5.2.4.5 front_inserter [front.inserter]

24.5.2.5 Class template insert_iterator [insert.iterator]

24.5.2.6 insert_iterator operations [insert.iter.ops]

24.5.2.6.1 insert_iterator constructor [insert.iter.cons]

24.5.2.6.2 insert_iterator::operator= [insert.iter.op=]

24.5.2.6.3 insert_iterator::operator* [insert.iter.op*]

24.5.2.6.4 insert_iterator::operator++ [insert.iter.op++]

24.5.3 Move iterators [move.iterators]

24.5.3.1 Class template move_iterator [move.iterator]

24.5.3.2 move_iterator requirements [move.iter.requirements]

24.5.3.3 move_iterator operations [move.iter.ops]

24.5.3.3.1 move_iterator constructors [move.iter.op.const]

24.5.3.3.2 move_iterator::operator= [move.iter.op=]

24.5.3.3.3 move_iterator conversion [move.iter.op.conv]

24.5.3.3.4 move_iterator::operator* [move.iter.op.star]

24.5.3.3.5 move_iterator::operator-> [move.iter.op.ref]

24.5.3.3.6 move_iterator::operator++ [move.iter.op.incr]

24.5.3.3.7 move_iterator::operator-- [move.iter.op.decr]

24.5.3.3.8 move_iterator::operator+ [move.iter.op.+]

24.5.3.3.9 move_iterator::operator+= [move.iter.op.+=]

24.5.3.3.10 move_iterator::operator- [move.iter.op.-]

24.5.3.3.11 move_iterator::operator-= [move.iter.op.-=]

24.5.3.3.12 move_iterator::operator[] [move.iter.op.index]

24.5.3.3.13 move_iterator comparisons [move.iter.op.comp]

24.5.3.3.14 move_iterator non-member functions [move.iter.nonmember]

24.6 Stream iterators [stream.iterators]

24.6.1 Class template istream_iterator [istream.iterator]

24.6.1.1 istream_iterator constructors and destructor [istream.iterator.cons]

24.6.1.2 istream_iterator operations [istream.iterator.ops]

24.6.2 Class template ostream_iterator [ostream.iterator]

24.6.2.1 ostream_iterator constructors and destructor [ostream.iterator.cons.des]

24.6.2.2 ostream_iterator operations [ostream.iterator.ops]

24.6.3 Class template istreambuf_iterator [istreambuf.iterator]

24.6.3.1 Class template istreambuf_iterator::proxy [istreambuf.iterator::proxy]

24.6.3.2 istreambuf_iterator constructors [istreambuf.iterator.cons]

24.6.3.3 istreambuf_iterator::operator* [istreambuf.iterator::op*]

24.6.3.4 istreambuf_iterator::operator++ [istreambuf.iterator::op++]

24.6.3.5 istreambuf_iterator::equal [istreambuf.iterator::equal]

24.6.4 Class template ostreambuf_iterator [ostreambuf.iterator]

24.6.4.1 ostreambuf_iterator constructors [ostreambuf.iter.cons]

24.6.4.2 ostreambuf_iterator operations [ostreambuf.iter.ops]

24.7 range access [iterator.range]

25 Algorithms library [algorithms][algorithms]

25.4 Sorting and related operations [alg.sorting]

25.4.3 Binary search [alg.binary.search]

25.4.3.1 lower_bound [lower.bound]

25.4.3.2 upper_bound [upper.bound]

25.4.3.3 equal_range [equal.range]

25.4.3.4 binary_search [binary.search]

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

25.4.5.1 includes [includes]

25.4.5.2 set_union [set.union]

25.4.5.3 set_intersection [set.intersection]

25.4.5.4 set_difference [set.difference]

25.4.5.5 set_symmetric_difference [set.symmetric.difference]

25.4.7 Minimum and maximum [alg.min.max]

25.4.8 Lexicographical comparison [alg.lex.comparison]

25.4.9 Permutation generators [alg.permutation.generators]

25.5 C library algorithms [alg.c.library]

26 Numerics library [numerics][numerics]

26.2 Numeric type requirements [numeric.requirements]

26.3 The floating-point environment [cfenv]

26.3.1 Header <cfenv> synopsis [cfenv.syn]

26.4 Complex numbers [complex.numbers]

26.4.1 Header <complex> synopsis [complex.syn]

26.4.2 Class template complex [complex]

26.4.3 complex specializations [complex.special]

26.4.4 complex member functions [complex.members]

26.4.5 complex member operators [complex.member.ops]

26.4.6 complex non-member operations [complex.ops]

26.4.7 complex value operations [complex.value.ops]

26.4.8 complex transcendentals [complex.transcendentals]

26.4.9 Additional overloads [cmplx.over]

26.4.10 Suffixes for complex number literals [complex.literals]

26.4.11 Header <ccomplex> [ccmplx]

26.5 Random number generation [rand]

26.5.1 Requirements [rand.req]

26.5.1.1 General requirements [rand.req.genl]

26.5.1.2 Seed sequence requirements [rand.req.seedseq]

26.5.1.3 Uniform random number generator requirements [rand.req.urng]

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

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

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

26.5.2 Header <random> synopsis [rand.synopsis]

26.5.3 Random number engine class templates [rand.eng]

26.5.3.1 Class template linear_congruential_engine [rand.eng.lcong]

26.5.3.2 Class template mersenne_twister_engine [rand.eng.mers]

26.5.3.3 Class template subtract_with_carry_engine [rand.eng.sub]

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

26.5.4.2 Class template discard_block_engine [rand.adapt.disc]

26.5.4.3 Class template independent_bits_engine [rand.adapt.ibits]

26.5.4.4 Class template shuffle_order_engine [rand.adapt.shuf]

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

26.5.6 Class random_device [rand.device]

26.5.7 Utilities [rand.util]

26.5.7.1 Class seed_seq [rand.util.seedseq]

26.5.7.2 Function template generate_canonical [rand.util.canonical]

26.5.8 Random number distribution class templates [rand.dist]

26.5.8.2 Uniform distributions [rand.dist.uni]

26.5.8.2.1 Class template uniform_int_distribution [rand.dist.uni.int]

26.5.8.2.2 Class template uniform_real_distribution [rand.dist.uni.real]

26.5.8.3 Bernoulli distributions [rand.dist.bern]

26.5.8.3.1 Class bernoulli_distribution [rand.dist.bern.bernoulli]

26.5.8.3.2 Class template binomial_distribution [rand.dist.bern.bin]

26.5.8.3.3 Class template geometric_distribution [rand.dist.bern.geo]

26.5.8.3.4 Class template negative_binomial_distribution [rand.dist.bern.negbin]

26.5.8.4 Poisson distributions [rand.dist.pois]

26.5.8.4.1 Class template poisson_distribution [rand.dist.pois.poisson]

26.5.8.4.2 Class template exponential_distribution [rand.dist.pois.exp]

26.5.8.4.3 Class template gamma_distribution [rand.dist.pois.gamma]

26.5.8.4.4 Class template weibull_distribution [rand.dist.pois.weibull]

26.5.8.4.5 Class template extreme_value_distribution [rand.dist.pois.extreme]

26.5.8.5 Normal distributions [rand.dist.norm]

26.5.8.5.1 Class template normal_distribution [rand.dist.norm.normal]

26.5.8.5.2 Class template lognormal_distribution [rand.dist.norm.lognormal]

26.5.8.5.3 Class template chi_squared_distribution [rand.dist.norm.chisq]

26.5.8.5.4 Class template cauchy_distribution [rand.dist.norm.cauchy]

26.5.8.5.5 Class template fisher_f_distribution [rand.dist.norm.f]

26.5.8.5.6 Class template student_t_distribution [rand.dist.norm.t]

26.5.8.6 Sampling distributions [rand.dist.samp]

26.5.8.6.1 Class template discrete_distribution [rand.dist.samp.discrete]

26.5.8.6.2 Class template piecewise_constant_distribution [rand.dist.samp.pconst]

26.5.8.6.3 Class template piecewise_linear_distribution [rand.dist.samp.plinear]

26.6 Numeric arrays [numarray]

26.6.1 Header <valarray> synopsis [valarray.syn]

26.6.2 Class template valarray [template.valarray]

26.6.2.1 Class template valarray overview [template.valarray.overview]

26.6.2.2 valarray constructors [valarray.cons]

26.6.2.3 valarray assignment [valarray.assign]

26.6.2.4 valarray element access [valarray.access]

26.6.2.5 valarray subset operations [valarray.sub]

26.6.2.6 valarray unary operators [valarray.unary]

26.6.2.7 valarray computed assignment [valarray.cassign]

26.6.2.8 valarray member functions [valarray.members]

26.6.3 valarray non-member operations [valarray.nonmembers]

26.6.3.1 valarray binary operators [valarray.binary]

26.6.3.2 valarray logical operators [valarray.comparison]

26.6.3.3 valarray transcendentals [valarray.transcend]

26.6.3.4 valarray specialized algorithms [valarray.special]

26.6.4 Class slice [class.slice]

26.6.4.1 Class slice overview [class.slice.overview]

26.6.4.2 slice constructors [cons.slice]

26.6.4.3 slice access functions [slice.access]

26.6.5 Class template slice_array [template.slice.array]

26.6.5.1 Class template slice_array overview [template.slice.array.overview]

26.6.5.2 slice_array assignment [slice.arr.assign]

26.6.5.3 slice_array computed assignment [slice.arr.comp.assign]

26.6.5.4 slice_array fill function [slice.arr.fill]

26.6.6 The gslice class [class.gslice]

26.6.6.1 The gslice class overview [class.gslice.overview]

26.6.6.2 gslice constructors [gslice.cons]

26.6.6.3 gslice access functions [gslice.access]

26.6.7 Class template gslice_array [template.gslice.array]

26.6.7.1 Class template gslice_array overview [template.gslice.array.overview]

26.6.7.2 gslice_array assignment [gslice.array.assign]

26.6.7.4 gslice_array fill function [gslice.array.fill]

26.6.8 Class template mask_array [template.mask.array]

26.6.8.1 Class template mask_array overview [template.mask.array.overview]

26.6.8.2 mask_array assignment [mask.array.assign]

26.6.8.3 mask_array computed assignment [mask.array.comp.assign]

26.6.8.4 mask_array fill function [mask.array.fill]

26.6.9 Class template indirect_array [template.indirect.array]

26.6.9.1 Class template indirect_array overview [template.indirect.array.overview]

26.6.9.2 indirect_array assignment [indirect.array.assign]

26.6.9.3 indirect_array computed assignment [indirect.array.comp.assign]

26.6.9.4 indirect_array fill function [indirect.array.fill]

26.6.10 valarray range access [valarray.range]

26.7 Generalized numeric operations [numeric.ops]

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

26.7.2 Accumulate [accumulate]

26.7.3 Inner product [inner.product]

26.7.4 Partial sum [partial.sum]

26.7.5 Adjacent difference [adjacent.difference]

26.8 C library [c.math]

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

27.2 Iostreams requirements [iostreams.requirements]

27.2.1 Imbue limitations [iostream.limits.imbue]

27.2.2 Positioning type limitations [iostreams.limits.pos]

27.3 Forward declarations [iostream.forward]

27.4 Standard iostream objects [iostream.objects]

27.4.2 Narrow stream objects [narrow.stream.objects]

27.4.3 Wide stream objects [wide.stream.objects]

27.5 Iostreams base classes [iostreams.base]

27.5.3 Class ios_base [ios.base]

27.5.3.1 Types [ios.types]

27.5.3.1.1 Class ios_base::failure [ios::failure]

27.5.3.1.2 Type ios_base::fmtflags [ios::fmtflags]

27.5.3.1.3 Type ios_base::iostate [ios::iostate]

27.5.3.1.4 Type ios_base::openmode [ios::openmode]

27.5.3.1.5 Type ios_base::seekdir [ios::seekdir]

27.5.3.1.6 Class ios_base::Init [ios::Init]

27.5.3.2 ios_base state functions [fmtflags.state]

27.5.3.3 ios_base functions [ios.base.locales]

27.5.3.4 ios_base static members [ios.members.static]

27.5.3.5 ios_base storage functions [ios.base.storage]

27.5.3.6 ios_base callbacks [ios.base.callback]

27.5.3.7 ios_base constructors/destructor [ios.base.cons]

27.5.4 Class template fpos [fpos]

27.5.4.1 fpos members [fpos.members]

27.5.4.2 fpos requirements [fpos.operations]

27.5.5 Class template basic_ios [ios]

27.5.5.2 basic_ios constructors [basic.ios.cons]

27.5.5.3 Member functions [basic.ios.members]

27.5.5.4 basic_ios flags functions [iostate.flags]

27.5.6 ios_base manipulators [std.ios.manip]

27.5.6.1 fmtflags manipulators [fmtflags.manip]

27.5.6.2 adjustfield manipulators [adjustfield.manip]

27.5.6.3 basefield manipulators [basefield.manip]

27.5.6.4 floatfield manipulators [floatfield.manip]

27.5.6.5 Error reporting [error.reporting]

27.6 Stream buffers [stream.buffers]

27.6.2 Stream buffer requirements [streambuf.reqts]

27.6.3 Class template basic_streambuf<charT,traits> [streambuf]

27.6.3.1 basic_streambuf constructors [streambuf.cons]

27.6.3.2 basic_streambuf public member functions [streambuf.members]

27.6.3.2.2 Buffer management and positioning [streambuf.buffer]

27.6.3.3 basic_streambuf protected member functions [streambuf.protected]

27.7 Formatting and manipulators [iostream.format]

27.7.2 Input streams [input.streams]

27.7.2.1 Class template basic_istream [istream]

27.7.2.1.1 basic_istream constructors [istream.cons]

27.7.2.1.2 Class basic_istream assign and swap [istream.assign]

27.7.2.1.3 Class basic_istream::sentry [istream::sentry]

27.7.2.2 Formatted input functions [istream.formatted]

27.7.2.2.3 basic_istream::operator>> [istream::extractors]

27.7.2.3 Unformatted input functions [istream.unformatted]

27.7.2.4 Standard basic_istream manipulators [istream.manip]

27.7.2.5 Class template basic_iostream [iostreamclass]

27.7.2.5.1 basic_iostream constructors [iostream.cons]

27.7.2.5.2 basic_iostream destructor [iostream.dest]

27.7.2.5.3 basic_iostream assign and swap [iostream.assign]

27.7.2.6 Rvalue stream extraction [istream.rvalue]

27.7.3 Output streams [output.streams]

27.7.3.1 Class template basic_ostream [ostream]

27.7.3.2 basic_ostream constructors [ostream.cons]

27.7.3.3 Class basic_ostream assign and swap [ostream.assign]

27.7.3.4 Class basic_ostream::sentry [ostream::sentry]

27.7.3.5 basic_ostream seek members [ostream.seeks]

27.7.3.6 Formatted output functions [ostream.formatted]

27.7.3.6.3 basic_ostream::operator<< [ostream.inserters]

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

27.7.3.7 Unformatted output functions [ostream.unformatted]

27.7.3.8 Standard basic_ostream manipulators [ostream.manip]

27.7.3.9 Rvalue stream insertion [ostream.rvalue]

27.7.4 Standard manipulators [std.manip]

27.7.5 Extended manipulators [ext.manip]

27.7.6 Quoted manipulators [quoted.manip]

27.8 String-based streams [string.streams]

27.8.2 Class template basic_stringbuf [stringbuf]

27.8.2.1 basic_stringbuf constructors [stringbuf.cons]

27.8.2.2 Assign and swap [stringbuf.assign]

27.8.2.3 Member functions [stringbuf.members]

27.8.2.4 Overridden virtual functions [stringbuf.virtuals]

27.8.3 Class template basic_istringstream [istringstream]

27.8.3.1 basic_istringstream constructors [istringstream.cons]

27.8.4 Class template basic_ostringstream [ostringstream]

27.8.4.1 basic_ostringstream constructors [ostringstream.cons]

27.8.5 Class template basic_stringstream [stringstream]

27.8.5.1 basic_stringstream constructors [stringstream.cons]

27.8.5.3 Member functions [stringstream.members]

27.9 File-based streams [file.streams]

27.9.1 File streams [fstreams]

27.9.1.1 Class template basic_filebuf [filebuf]

27.9.1.2 basic_filebuf constructors [filebuf.cons]

27.9.1.3 Assign and swap [filebuf.assign]

27.9.1.4 Member functions [filebuf.members]

27.9.1.5 Overridden virtual functions [filebuf.virtuals]

27.9.1.6 Class template basic_ifstream [ifstream]

27.9.1.7 basic_ifstream constructors [ifstream.cons]

27.9.1.8 Assign and swap [ifstream.assign]

27.9.1.9 Member functions [ifstream.members]

27.9.1.10 Class template basic_ofstream [ofstream]

27.9.1.11 basic_ofstream constructors [ofstream.cons]

27.9.1.12 Assign and swap [ofstream.assign]

27.9.1.13 Member functions [ofstream.members]

27.9.1.14 Class template basic_fstream [fstream]

27.9.1.15 basic_fstream constructors [fstream.cons]

27.9.1.16 Assign and swap [fstream.assign]

27.9.1.17 Member functions [fstream.members]

27.9.2 C library files [c.files]

28 Regular expressions library [re][re]

28.1 General [re.general]

28.3 Requirements [re.req]

28.4 Header <regex> synopsis [re.syn]

28.5 Namespace std::regex_constants [re.const]

28.5.1 Bitmask type syntax_option_type [re.synopt]

28.5.2 Bitmask type regex_constants::match_flag_type [re.matchflag]

28.5.3 Implementation-defined error_type [re.err]

28.6 Class regex_error [re.badexp]

28.7 Class template regex_traits [re.traits]

28.8 Class template basic_regex [re.regex]

28.8.1 basic_regex constants [re.regex.const]

28.8.2 basic_regex constructors [re.regex.construct]

28.8.3 basic_regex assign [re.regex.assign]

28.8.4 basic_regex constant operations [re.regex.operations]

28.8.5 basic_regex locale [re.regex.locale]

28.8.6 basic_regex swap [re.regex.swap]

28.8.7 basic_regex non-member functions [re.regex.nonmemb]

28.8.7.1 basic_regex non-member swap [re.regex.nmswap]

28.9 Class template sub_match [re.submatch]

28.9.1 sub_match members [re.submatch.members]

28.9.2 sub_match non-member operators [re.submatch.op]

28.10 Class template match_results [re.results]

28.10.1 match_results constructors [re.results.const]

28.10.2 match_results state [re.results.state]

28.10.3 match_results size [re.results.size]

28.10.4 match_results element access [re.results.acc]

28.10.5 match_results formatting [re.results.form]

28.10.6 match_results allocator [re.results.all]

28.10.7 match_results swap [re.results.swap]

28.10.8 match_results non-member functions [re.results.nonmember]

28.11 Regular expression algorithms [re.alg]

28.11.1 exceptions [re.except]

28.11.2 regex_match [re.alg.match]

28.11.3 regex_search [re.alg.search]

28.11.4 regex_replace [re.alg.replace]

28.12 Regular expression iterators [re.iter]

28.12.1 Class template regex_iterator [re.regiter]

28.12.1.1 regex_iterator constructors [re.regiter.cnstr]

28.12.1.2 regex_iterator comparisons [re.regiter.comp]

28.12.1.3 regex_iterator indirection [re.regiter.deref]

28.12.1.4 regex_iterator increment [re.regiter.incr]

28.12.2 Class template regex_token_iterator [re.tokiter]

28.12.2.1 regex_token_iterator constructors [re.tokiter.cnstr]

28.12.2.2 regex_token_iterator comparisons [re.tokiter.comp]

28.12.2.3 regex_token_iterator indirection [re.tokiter.deref]

28.12.2.4 regex_token_iterator increment [re.tokiter.incr]

28.13 Modified ECMAScript regular expression grammar [re.grammar]

29 Atomic operations library [atomics][atomics]

29.2 Header <atomic> synopsis [atomics.syn]

29.3 Order and consistency [atomics.order]

29.4 Lock-free property [atomics.lockfree]

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

29.6.1 General operations on atomic types [atomics.types.operations.general]

29.6.2 Templated operations on atomic types [atomics.types.operations.templ]

29.6.3 Arithmetic operations on atomic types [atomics.types.operations.arith]

29.6.4 Operations on atomic pointer types [atomics.types.operations.pointer]

29.6.5 Requirements for operations on atomic types [atomics.types.operations.req]

29.7 Flag type and operations [atomics.flag]

30 Thread support library [thread][thread]

30.2 Requirements [thread.req]

30.2.1 Template parameter names [thread.req.paramname]

30.2.3 Native handles [thread.req.native]

30.2.4 Timing specifications [thread.req.timing]

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

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

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

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

30.3 Threads [thread.threads]

30.3.1 Class thread [thread.thread.class]

30.3.1.1 Class thread::id [thread.thread.id]

30.3.1.2 thread constructors [thread.thread.constr]

30.3.1.3 thread destructor [thread.thread.destr]

30.3.1.4 thread assignment [thread.thread.assign]

30.3.1.6 thread static members [thread.thread.static]

30.3.1.7 thread specialized algorithms [thread.thread.algorithm]

30.3.2 Namespace this_thread [thread.thread.this]

30.4 Mutual exclusion [thread.mutex]

30.4.2 Locks [thread.lock]

30.4.2.1 Class template lock_guard [thread.lock.guard]

30.4.2.2 Class template unique_lock [thread.lock.unique]

30.4.2.2.1 unique_lock constructors, destructor, and assignment [thread.lock.unique.cons]

30.4.2.2.3 unique_lock modifiers [thread.lock.unique.mod]

30.4.2.2.4 unique_lock observers [thread.lock.unique.obs]

30.4.2.3 Class template shared_lock [thread.lock.shared]

30.4.2.3.1 shared_lock constructors, destructor, and assignment [thread.lock.shared.cons]

30.4.2.3.3 shared_lock modifiers [thread.lock.shared.mod]

30.4.2.3.4 shared_lock observers [thread.lock.shared.obs]

30.4.3 Generic locking algorithms [thread.lock.algorithm]

30.4.4 Call once [thread.once]

30.4.4.1 Struct once_flag [thread.once.onceflag]

30.4.4.2 Function call_once [thread.once.callonce]

30.5 Condition variables [thread.condition]

30.5.1 Class condition_variable [thread.condition.condvar]

30.5.2 Class condition_variable_any [thread.condition.condvarany]

30.6 Futures [futures]

30.6.2 Error handling [futures.errors]

30.6.3 Class future_error [futures.future_error]

30.6.4 Shared state [futures.state]

30.6.5 Class template promise [futures.promise]

30.6.6 Class template future [futures.unique_future]

30.6.7 Class template shared_future [futures.shared_future]

30.6.8 Function template async [futures.async]

30.6.9 Class template packaged_task [futures.task]

30.6.9.1 packaged_task member functions [futures.task.members]

30.6.9.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.8 Classes [gram.class]

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.5 Clause [dcl.decl]: declarators [diff.cpp03.dcl.decl]

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 [dcl.dcl]: declarations [diff.cpp11.dcl.dcl]

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

C.4 C standard library [diff.library]

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

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

C.4.2.1 Types char16_t and char32_t [diff.char16]

C.4.2.2 Type wchar_t [diff.wchar.t]

C.4.2.3 Header <iso646.h> [diff.header.iso646.h]

C.4.2.4 Macro NULL [diff.null]

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

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

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

C.4.4.2 Memory allocation functions [diff.malloc]

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

D.1 Increment operator with bool operand [depr.incr.bool]

D.2 register keyword [depr.register]

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

D.4 Dynamic exception specifications [depr.except.spec]

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

D.6 Old iostreams members [depr.ios.members]

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

D.7.1 Class strstreambuf [depr.strstreambuf]

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

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

D.7.2 Class istrstream [depr.istrstream]

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

D.7.3 Class ostrstream [depr.ostrstream]

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

D.7.4 Class strstream [depr.strstream]

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

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

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

D.8 Function objects [depr.function.objects]

D.8.2 Function adaptors [depr.adaptors]

D.8.2.1 Adaptors for pointers to functions [depr.function.pointer.adaptors]

D.8.2.2 Adaptors for pointers to members [depr.member.pointer.adaptors]

D.9 Binders [depr.lib.binders]

D.9.1 Class template binder1st [depr.lib.binder.1st]

D.9.3 Class template binder2nd [depr.lib.binder.2nd]

D.10 auto_ptr [depr.auto.ptr]

D.10.1 Class template auto_ptr [auto.ptr]

D.10.1.1 auto_ptr constructors [auto.ptr.cons]

D.10.1.2 auto_ptr members [auto.ptr.members]

D.10.1.3 auto_ptr conversions [auto.ptr.conv]

D.11 Violating exception-specifications [exception.unexpected]

D.11.1 Type unexpected_handler [unexpected.handler]

D.11.2 set_unexpected [set.unexpected]

D.11.3 get_unexpected [get.unexpected]

D.11.4 unexpected [unexpected]

Annex E (normative) Universal character names for identifier characters [charname][charname]

E.1 Ranges of characters allowed [charname.allowed]

E.2 Ranges of characters disallowed initially [charname.disallowed]

Index

Index of library names

Index of implementation-defined behavior