Working Draft, Standard for Programming Language C++

(Generated on 2018-12-08 from the LaTeX sources by cxxdraft-htmlgen. This is not an ISO publication.
For historical versions of the document, see Tim Song's cppwp page.)

Note: this is an early draft. It's known to be incomplet and incorrekt, and it has lots of bad formatting.


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.1.1 Abstract machine [intro.abstract]

4.2 Structure of this document [intro.structure]

4.3 Syntax notation [syntax]

4.4 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 []

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 Basics [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 parameter scope [basic.scope.param]

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] Class members [class.qual] 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 Memory and objects [basic.memobj]

6.6.1 Memory model [intro.memory]

6.6.2 Object model [intro.object]

6.6.3 Object lifetime []

6.6.4 Indeterminate values [basic.indet]

6.6.5 Storage duration [] Static storage duration [] Thread storage duration [] Automatic storage duration [] Dynamic storage duration [] Safely-derived pointers [] Duration of subobjects []

6.6.7 Temporary objects [class.temporary]

6.7 Types [basic.types]

6.7.1 Fundamental types [basic.fundamental]

6.7.2 Compound types [basic.compound]

6.7.4 Integer conversion rank [conv.rank]

6.8 Program execution [basic.exec]

6.8.1 Sequential execution [intro.execution]

6.8.2 Multi-threaded executions and data races [intro.multithread] Forward progress [intro.progress]

6.8.3 Start and termination [basic.start] Static initialization [basic.start.static] Dynamic initialization of non-local variables [basic.start.dynamic]

7 Expressions [expr][expr]

7.1 Preamble [expr.pre]

7.2 Properties of expressions [expr.prop]

7.2.1 Value category [basic.lval]

7.2.3 Context dependence [expr.context]

7.3 Standard conversions [conv]

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

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

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

7.3.4 Temporary materialization conversion [conv.rval]

7.3.5 Qualification conversions [conv.qual]

7.3.6 Integral promotions [conv.prom]

7.3.7 Floating-point promotion [conv.fpprom]

7.3.8 Integral conversions [conv.integral]

7.3.9 Floating-point conversions [conv.double]

7.3.10 Floating-integral conversions [conv.fpint]

7.3.11 Pointer conversions [conv.ptr]

7.3.12 Pointer-to-member conversions [conv.mem]

7.3.13 Function pointer conversions [conv.fctptr]

7.3.14 Boolean conversions [conv.bool]

7.4 Usual arithmetic conversions [expr.arith.conv]

7.6 Compound expressions [expr.compound]

7.6.1 Postfix expressions [] Subscripting [expr.sub] Function call [] Explicit type conversion (functional notation) [expr.type.conv] Class member access [expr.ref] Increment and decrement [] Type identification [expr.typeid]

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

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

7.6.5 Multiplicative operators [expr.mul]

7.6.6 Additive operators [expr.add]

7.6.7 Shift operators [expr.shift]

7.6.8 Three-way comparison operator [expr.spaceship]

7.6.9 Relational operators [expr.rel]

7.6.10 Equality operators [expr.eq]

7.6.11 Bitwise AND operator [expr.bit.and]

7.6.12 Bitwise exclusive OR operator [expr.xor]

7.6.13 Bitwise inclusive OR operator [expr.or]

7.6.14 Logical AND operator [expr.log.and]

7.6.15 Logical OR operator [expr.log.or]

7.6.16 Conditional operator [expr.cond]

7.6.17 Throwing an exception [expr.throw]

7.6.18 Assignment and compound assignment operators [expr.ass]

7.6.19 Comma operator [expr.comma]

7.7 Constant expressions [expr.const]

8 Statements [stmt.stmt][stmt.stmt]

8.1 Labeled statement [stmt.label]

8.2 Expression statement [stmt.expr]

8.3 Compound statement or block [stmt.block]

8.4 Selection statements []

8.4.1 The if statement [stmt.if]

8.4.2 The switch statement [stmt.switch]

8.5 Iteration statements [stmt.iter]

8.5.1 The while statement [stmt.while]

8.5.2 The do statement []

8.5.3 The for statement [stmt.for]

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

8.6 Jump statements [stmt.jump]

8.6.1 The break statement [stmt.break]

8.6.2 The continue statement [stmt.cont]

8.6.3 The return statement [stmt.return]

8.6.4 The goto statement [stmt.goto]

8.7 Declaration statement [stmt.dcl]

8.8 Ambiguity resolution [stmt.ambig]

9 Declarations [dcl.dcl][dcl.dcl]

9.1 Specifiers [dcl.spec]

9.1.1 Storage class specifiers []

9.1.2 Function specifiers [dcl.fct.spec]

9.1.3 The typedef specifier [dcl.typedef]

9.1.4 The friend specifier [dcl.friend]

9.1.5 The constexpr specifier [dcl.constexpr]

9.1.6 The inline specifier [dcl.inline]

9.1.7 Type specifiers [dcl.type] The cv-qualifiers [] Simple type specifiers [dcl.type.simple] Elaborated type specifiers [dcl.type.elab] Decltype specifiers [dcl.type.decltype] Placeholder type specifiers [] Placeholder type deduction [] Deduced class template specialization types [dcl.type.class.deduct]

9.2 Declarators [dcl.decl]

9.2.1 Type names []

9.2.2 Ambiguity resolution [dcl.ambig.res]

9.2.3 Meaning of declarators [dcl.meaning] References [dcl.ref] Pointers to members [dcl.mptr] Functions [dcl.fct] Default arguments [dcl.fct.default]

9.3 Initializers [dcl.init]

9.3.2 Character arrays [dcl.init.string]

9.3.4 List-initialization [dcl.init.list]

9.4 Function definitions [dcl.fct.def]

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

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

9.5 Structured binding declarations [dcl.struct.bind]

9.6 Enumeration declarations [dcl.enum]

9.7 Namespaces [basic.namespace]

9.7.1 Namespace definition [namespace.def] Unnamed namespaces [namespace.unnamed] Namespace member definitions [namespace.memdef]

9.7.2 Namespace alias [namespace.alias]

9.7.3 Using directive [namespace.udir]

9.8 The using declaration [namespace.udecl]

9.9 The asm declaration [dcl.asm]

9.11 Attributes [dcl.attr]

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

9.11.2 Alignment specifier [dcl.align]

9.11.3 Carries dependency attribute [dcl.attr.depend]

9.11.5 Deprecated attribute [dcl.attr.deprecated]

9.11.6 Fallthrough attribute [dcl.attr.fallthrough]

9.11.7 Likelihood attributes [dcl.attr.likelihood]

9.11.8 Maybe unused attribute [dcl.attr.unused]

9.11.9 Nodiscard attribute [dcl.attr.nodiscard]

9.11.10 Noreturn attribute [dcl.attr.noreturn]

9.11.11 No unique address attribute [dcl.attr.nouniqueaddr]

10 Classes [class][class]

10.1 Properties of classes [class.prop]

10.2 Class names []

10.3 Class members [class.mem]

10.3.1 Member functions [class.mfct]

10.3.2 Non-static member functions [class.mfct.non-static] The this pointer [class.this]

10.3.3 Special member functions [special]

10.3.4 Constructors [class.ctor] Default constructors [class.default.ctor] Copy/move constructors [class.copy.ctor]

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

10.3.6 Destructors [class.dtor]

10.3.7 Conversions [class.conv] Conversion by constructor [class.conv.ctor] Conversion functions [class.conv.fct]

10.3.8 Static members [class.static] Static member functions [class.static.mfct] Static data members []

10.3.9 Bit-fields [class.bit]

10.3.10 Nested class declarations [class.nest]

10.3.11 Nested type names [class.nested.type]

10.5 Local class declarations [class.local]

10.6 Derived classes [class.derived]

10.6.1 Multiple base classes [class.mi]

10.6.2 Virtual functions [class.virtual]

10.6.3 Abstract classes [class.abstract]

10.7 Member name lookup [class.member.lookup]

10.8 Member access control [class.access]

10.8.1 Access specifiers [class.access.spec]

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

10.8.4 Protected member access [class.protected]

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

10.8.6 Multiple access [class.paths]

10.9 Initialization [class.init]

10.9.1 Explicit initialization [class.expl.init]

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

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

10.9.4 Construction and destruction [class.cdtor]

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

10.10 Comparisons []

10.10.1 Defaulted comparison operator functions []

10.10.2 Three-way comparison [class.spaceship]

10.10.3 Other comparison operators [class.rel.eq]

10.11 Free store []

11 Overloading [over][over]

11.1 Overloadable declarations [over.load]

11.2 Declaration matching [over.dcl]

11.3 Overload resolution [over.match]

11.3.1 Candidate functions and argument lists [over.match.funcs] Function call syntax [] Call to named function [] Call to object of class type [] Operators in expressions [over.match.oper] Initialization by constructor [over.match.ctor] Copy-initialization of class by user-defined conversion [over.match.copy] Initialization by conversion function [over.match.conv] Initialization by conversion function for direct reference binding [over.match.ref] Initialization by list-initialization [over.match.list] Class template argument deduction [over.match.class.deduct]

11.3.2 Viable functions [over.match.viable]

11.3.3 Best viable function [] Implicit conversion sequences [] Standard conversion sequences [over.ics.scs] User-defined conversion sequences [over.ics.user] Ellipsis conversion sequences [over.ics.ellipsis] Reference binding [over.ics.ref] List-initialization sequence [over.ics.list] Ranking implicit conversion sequences [over.ics.rank]

11.4 Address of overloaded function [over.over]

11.5 Overloaded operators [over.oper]

11.5.1 Unary operators [over.unary]

11.5.2 Binary operators [over.binary]

11.5.3 Assignment [over.ass]

11.5.4 Function call []

11.5.5 Subscripting [over.sub]

11.5.6 Class member access [over.ref]

11.5.7 Increment and decrement []

11.5.8 User-defined literals [over.literal]

11.6 Built-in operators [over.built]

12 Templates [temp][temp]

12.1 Template parameters [temp.param]

12.2 Names of template specializations [temp.names]

12.3 Template arguments [temp.arg]

12.3.1 Template type arguments [temp.arg.type]

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

12.3.3 Template template arguments [temp.arg.template]

12.4 Template constraints [temp.constr]

12.4.1 Constraints [temp.constr.constr] Logical operations [temp.constr.op] Atomic constraints [temp.constr.atomic]

12.4.2 Constrained declarations [temp.constr.decl]

12.4.3 Constraint normalization [temp.constr.normal]

12.4.4 Partial ordering by constraints [temp.constr.order]

12.5 Type equivalence [temp.type]

12.6 Template declarations [temp.decls]

12.6.1 Class templates [temp.class] Member functions of class templates [temp.mem.func] Member classes of class templates [temp.mem.class] Static data members of class templates [temp.static] Enumeration members of class templates [temp.mem.enum]

12.6.2 Member templates [temp.mem]

12.6.3 Variadic templates [temp.variadic]

12.6.5 Class template partial specializations [temp.class.spec] Matching of class template partial specializations [temp.class.spec.match] Partial ordering of class template specializations [temp.class.order] Members of class template specializations [temp.class.spec.mfunc]

12.6.6 Function templates [temp.fct] Partial ordering of function templates [temp.func.order]

12.6.7 Alias templates [temp.alias]

12.6.8 Concept definitions [temp.concept]

12.7 Name resolution [temp.res]

12.7.1 Locally declared names [temp.local]

12.7.2 Dependent names [temp.dep] Dependent types [temp.dep.type] Type-dependent expressions [temp.dep.expr] Value-dependent expressions [temp.dep.constexpr] Dependent template arguments [temp.dep.temp]

12.7.3 Non-dependent names [temp.nondep]

12.7.4 Dependent name resolution [temp.dep.res] Point of instantiation [temp.point] Candidate functions [temp.dep.candidate]

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

12.8 Template instantiation and specialization [temp.spec]

12.8.1 Implicit instantiation [temp.inst]

12.8.2 Explicit instantiation [temp.explicit]

12.8.3 Explicit specialization [temp.expl.spec]

12.9 Function template specializations [temp.fct.spec]

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

12.9.2 Template argument deduction [temp.deduct] Deducing template arguments from a function call [] Deducing template arguments taking the address of a function template [temp.deduct.funcaddr] Deducing conversion function template arguments [temp.deduct.conv] Deducing template arguments during partial ordering [temp.deduct.partial] Deducing template arguments from a type [temp.deduct.type] Deducing template arguments from a function declaration [temp.deduct.decl]

12.9.3 Overload resolution [temp.over]

12.10 Deduction guides []

13 Exception handling [except][except]

13.1 Throwing an exception [except.throw]

13.2 Constructors and destructors [except.ctor]

13.3 Handling an exception [except.handle]

13.4 Exception specifications [except.spec]

13.5 Special functions [except.special]

13.5.1 The std​::​terminate function [except.terminate]

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

14 Preprocessing directives [cpp][cpp]

14.1 Conditional inclusion [cpp.cond]

14.2 Source file inclusion [cpp.include]

14.3 Macro replacement [cpp.replace]

14.3.1 Argument substitution [cpp.subst]

14.3.2 The # operator [cpp.stringize]

14.3.3 The ## operator [cpp.concat]

14.3.4 Rescanning and further replacement [cpp.rescan]

14.3.5 Scope of macro definitions [cpp.scope]

14.4 Line control [cpp.line]

14.5 Error directive [cpp.error]

14.6 Pragma directive [cpp.pragma]

14.7 Null directive [cpp.null]

14.8 Predefined macro names [cpp.predefined]

14.9 Pragma operator [cpp.pragma.op]

15 Library introduction [library][library]

15.2 The C standard library [library.c]

15.3 Definitions [definitions]

15.4 Method of description (Informative) [description]

15.5 Library-wide requirements [requirements]

15.5.1 Library contents and organization [organization] Library contents [contents] Freestanding implementations [compliance]

15.5.3 Requirements on types and expressions [utility.requirements] Template argument requirements [utility.arg.requirements] Swappable requirements [swappable.requirements] Cpp17NullablePointer requirements [nullablepointer.requirements] Cpp17Hash requirements [hash.requirements] Cpp17Allocator requirements [allocator.requirements] Allocator completeness requirements [allocator.requirements.completeness]

15.5.4 Constraints on programs [constraints] Namespace use [namespace.constraints] Namespaces for future standardization [namespace.future] Reserved names [reserved.names] External linkage [extern.names] User-defined literal suffixes [usrlit.suffix] Derived classes [derived.classes] Replacement functions [replacement.functions] Handler functions [handler.functions] Function arguments [res.on.arguments] Library object access [res.on.objects] Requires paragraph [res.on.required] Semantic requirements [res.on.requirements]

15.5.5 Conforming implementations [conforming] Restrictions on macro definitions [res.on.macro.definitions] Non-member functions [global.functions] Member functions [member.functions] Constexpr functions and constructors [constexpr.functions] Requirements for stable algorithms [algorithm.stable] Data race avoidance [] Protection within classes [protection.within.classes] Derived classes [derivation] Restrictions on exception handling [res.on.exception.handling] Restrictions on storage of pointers [] Value of error codes [] Moved-from state of library types [lib.types.movedfrom]

16 Language support library [][]

16.2 Common definitions [support.types]

16.2.1 Header <cstddef> synopsis [cstddef.syn]

16.2.2 Header <cstdlib> synopsis [cstdlib.syn]

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

16.2.5 byte type operations [support.types.byteops]

16.3 Implementation properties [support.limits]

16.3.2 Header <limits> synopsis [limits.syn]

16.3.3 Floating-point type properties [] Type float_­round_­style [] Type float_­denorm_­style []

16.3.4 Class template numeric_­limits [numeric.limits] numeric_­limits members [numeric.limits.members] numeric_­limits specializations [numeric.special]

16.3.5 Header <climits> synopsis [climits.syn]

16.3.6 Header <cfloat> synopsis [cfloat.syn]

16.4 Integer types [cstdint]

16.4.1 Header <cstdint> synopsis [cstdint.syn]

16.5 Start and termination [support.start.term]

16.6 Dynamic memory management [support.dynamic]

16.6.1 Header <new> synopsis [new.syn]

16.6.2 Storage allocation and deallocation [new.delete] Single-object forms [new.delete.single] Non-allocating forms [new.delete.placement]

16.6.3 Storage allocation errors [alloc.errors] Class bad_­alloc [bad.alloc] Class bad_­array_­new_­length [new.badlength] Type new_­handler [new.handler] set_­new_­handler [] get_­new_­handler []

16.6.4 Pointer optimization barrier [ptr.launder]

16.6.5 Hardware interference size [hardware.interference]

16.7 Type identification [support.rtti]

16.7.1 Header <typeinfo> synopsis [typeinfo.syn]

16.7.2 Class type_­info []

16.7.3 Class bad_­cast [bad.cast]

16.7.4 Class bad_­typeid [bad.typeid]

16.8 Contract violation handling [support.contract]

16.8.1 Header <contract> synopsis [contract.syn]

16.8.2 Class contract_­violation [support.contract.cviol]

16.9 Exception handling [support.exception]

16.9.1 Header <exception> synopsis [exception.syn]

16.9.2 Class exception [exception]

16.9.3 Class bad_­exception [bad.exception]

16.9.4 Abnormal termination [exception.terminate] Type terminate_­handler [terminate.handler] set_­terminate [set.terminate] get_­terminate [get.terminate]

16.9.5 uncaught_­exceptions [uncaught.exceptions]

16.9.6 Exception propagation [propagation]

16.9.7 nested_­exception [except.nested]

16.10 Initializer lists [support.initlist]

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

16.10.2 Initializer list constructors [support.initlist.cons]

16.10.3 Initializer list access [support.initlist.access]

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

16.11 Comparisons [cmp]

16.11.1 Header <compare> synopsis [compare.syn]

16.11.2 Comparison category types [cmp.categories] Class weak_­equality [cmp.weakeq] Class strong_­equality [cmp.strongeq] Class partial_­ordering [cmp.partialord] Class weak_­ordering [cmp.weakord] Class strong_­ordering [cmp.strongord]

16.11.3 Class template common_­comparison_­category [cmp.common]

16.11.4 Comparison algorithms [cmp.alg]

16.12 Other runtime support [support.runtime]

16.12.1 Header <cstdarg> synopsis [cstdarg.syn]

16.12.2 Header <csetjmp> synopsis [csetjmp.syn]

16.12.3 Header <csignal> synopsis [csignal.syn]

16.12.4 Signal handlers [support.signal]

17 Concepts library [concepts][concepts]

17.2 Equality preservation [concepts.equality]

17.3 Header <concepts> synopsis [concepts.syn]

17.4 Language-related concepts [concepts.lang]

17.4.2 Concept Same [concept.same]

17.4.3 Concept DerivedFrom [concept.derivedfrom]

17.4.4 Concept ConvertibleTo [concept.convertibleto]

17.4.5 Concept CommonReference [concept.commonref]

17.4.6 Concept Common [concept.common]

17.4.7 Integral concepts [concepts.integral]

17.4.8 Concept Assignable [concept.assignable]

17.4.9 Concept Swappable [concept.swappable]

17.4.10 Concept Destructible [concept.destructible]

17.4.11 Concept Constructible [concept.constructible]

17.4.12 Concept DefaultConstructible [concept.defaultconstructible]

17.4.13 Concept MoveConstructible [concept.moveconstructible]

17.4.14 Concept CopyConstructible [concept.copyconstructible]

17.5 Comparison concepts []

17.5.2 Concept Boolean [concept.boolean]

17.5.3 Concept EqualityComparable [concept.equalitycomparable]

17.5.4 Concept StrictTotallyOrdered [concept.stricttotallyordered]

17.6 Object concepts [concepts.object]

17.7 Callable concepts [concepts.callable]

17.7.2 Concept Invocable [concept.invocable]

17.7.3 Concept RegularInvocable [concept.regularinvocable]

17.7.4 Concept Predicate [concept.predicate]

17.7.5 Concept Relation [concept.relation]

17.7.6 Concept StrictWeakOrder [concept.strictweakorder]

18 Diagnostics library [diagnostics][diagnostics]

18.2 Exception classes [std.exceptions]

18.2.1 Header <stdexcept> synopsis [stdexcept.syn]

18.2.2 Class logic_­error [logic.error]

18.2.3 Class domain_­error [domain.error]

18.2.4 Class invalid_­argument [invalid.argument]

18.2.5 Class length_­error [length.error]

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

18.2.7 Class runtime_­error [runtime.error]

18.2.8 Class range_­error [range.error]

18.2.9 Class overflow_­error [overflow.error]

18.2.10 Class underflow_­error [underflow.error]

18.3 Assertions [assertions]

18.3.1 Header <cassert> synopsis [cassert.syn]

18.3.2 The assert macro [assertions.assert]

18.4 Error numbers [errno]

18.4.1 Header <cerrno> synopsis [cerrno.syn]

19 General utilities library [utilities][utilities]

19.2 Utility components [utility]

19.2.1 Header <utility> synopsis [utility.syn]

19.2.4 Forward/move helpers [forward]

19.2.5 Function template as_­const [utility.as_const]

19.2.6 Function template declval [declval]

19.3 Compile-time integer sequences [intseq]

19.3.2 Class template integer_­sequence [intseq.intseq]

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

19.4 Pairs [pairs]

19.4.2 Class template pair [pairs.pair]

19.4.3 Specialized algorithms [pairs.spec]

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

19.4.5 Piecewise construction [pair.piecewise]

19.5 Tuples [tuple]

19.5.2 Header <tuple> synopsis [tuple.syn]

19.5.3 Class template tuple [tuple.tuple] Construction [tuple.cnstr] Tuple creation functions [tuple.creation] Calling a function with a tuple of arguments [tuple.apply] Tuple helper classes [tuple.helper] Element access [tuple.elem] Relational operators [tuple.rel] Tuple specialized algorithms [tuple.special]

19.6 Optional objects [optional]

19.6.2 Header <optional> synopsis [optional.syn]

19.6.4 No-value state indicator [optional.nullopt]

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

19.6.6 Relational operators [optional.relops]

19.6.7 Comparison with nullopt [optional.nullops]

19.6.8 Comparison with T [optional.comp_with_t]

19.6.9 Specialized algorithms [optional.specalg]

19.7 Variants [variant]

19.7.2 Header <variant> synopsis [variant.syn]

19.7.4 variant helper classes [variant.helper]

19.7.5 Value access [variant.get]

19.7.6 Relational operators [variant.relops]

19.7.8 Class monostate [variant.monostate]

19.7.9 monostate relational operators [variant.monostate.relops]

19.7.10 Specialized algorithms [variant.specalg]

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

19.7.12 Hash support [variant.hash]

19.8 Storage for any type [any]

19.8.1 Header <any> synopsis [any.synop]

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

19.8.3 Class any [any.class] Construction and destruction [any.cons]

19.8.4 Non-member functions [any.nonmembers]

19.9 Bitsets [bitset]

19.9.1 Header <bitset> synopsis [bitset.syn]

19.9.2 Class template bitset [template.bitset] Constructors [bitset.cons]

19.9.3 bitset hash support [bitset.hash]

19.9.4 bitset operators [bitset.operators]

19.10 Memory [memory]

19.10.2 Header <memory> synopsis [memory.syn]

19.10.4 Pointer conversion [pointer.conversion]

19.10.6 Pointer alignment [ptr.align]

19.10.7 Allocator argument tag [allocator.tag]

19.10.8 uses_­allocator [allocator.uses] uses_­allocator trait [allocator.uses.trait] Uses-allocator construction []

19.10.11 Specialized algorithms [specialized.algorithms] Special memory concepts [special.mem.concepts] uninitialized_­default_­construct [uninitialized.construct.default] uninitialized_­value_­construct [uninitialized.construct.value] uninitialized_­copy [uninitialized.copy] uninitialized_­move [uninitialized.move] uninitialized_­fill [uninitialized.fill]

19.10.12 C library memory allocation [c.malloc]

19.11 Smart pointers [smartptr]

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

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

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

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

19.11.8 Atomic specializations for smart pointers [util.smartptr.atomic] Atomic specialization for shared_­ptr [util.smartptr.atomic.shared] Atomic specialization for weak_­ptr [util.smartptr.atomic.weak]

19.12 Memory resources [mem.res]

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

19.12.2 Class memory_­resource [mem.res.class] Public member functions [mem.res.public] Private virtual member functions [mem.res.private]

19.12.4 Access to program-wide memory_­resource objects []

19.12.5 Pool resource classes [mem.res.pool] Classes synchronized_­pool_­resource and unsynchronized_­pool_­resource [mem.res.pool.overview] pool_­options data members [mem.res.pool.options] Constructors and destructors [mem.res.pool.ctor]

19.12.6 Class monotonic_­buffer_­resource [mem.res.monotonic.buffer] Constructors and destructor [mem.res.monotonic.buffer.ctor]

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

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

19.14 Function objects [function.objects]

19.14.1 Header <functional> synopsis [functional.syn]

19.14.2 Definitions [func.def]

19.14.3 Requirements [func.require]

19.14.4 Function template invoke [func.invoke]

19.14.5 Class template reference_­wrapper [refwrap] Constructors and destructor [refwrap.const] Helper functions [refwrap.helpers] Transformation type trait unwrap_­reference [refwrap.unwrapref]

19.14.7 Comparisons [comparisons] Class template equal_­to [comparisons.equal_to] Class template not_­equal_­to [comparisons.not_equal_to] Class template greater [comparisons.greater] Class template less [comparisons.less] Class template greater_­equal [comparisons.greater_equal] Class template less_­equal [comparisons.less_equal]

19.14.8 Range comparisons [range.cmp]

19.14.9 Logical operations [logical.operations] Class template logical_­and [logical.operations.and] Class template logical_­or [logical.operations.or] Class template logical_­not [logical.operations.not]

19.14.10 Bitwise operations [bitwise.operations] Class template bit_­and [bitwise.operations.and] Class template bit_­or [bitwise.operations.or] Class template bit_­xor [bitwise.operations.xor] Class template bit_­not [bitwise.operations.not]

19.14.11 Class identity [func.identity]

19.14.12 Function template not_­fn [func.not_fn]

19.14.13 Function template bind_­front [func.bind_front]

19.14.14 Function object binders [func.bind] Class template is_­bind_­expression [func.bind.isbind] Class template is_­placeholder [func.bind.isplace] Function template bind [func.bind.bind]

19.14.15 Function template mem_­fn [func.memfn]

19.14.16 Polymorphic function wrappers [func.wrap]

19.14.17 Searchers [] Class template default_­searcher [] Class template boyer_­moore_­searcher [] Class template boyer_­moore_­horspool_­searcher []

19.14.18 Class template hash [unord.hash]

19.15 Metaprogramming and type traits [meta]

19.15.1 Requirements [meta.rqmts]

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

19.15.3 Helper classes []

19.15.4 Unary type traits [meta.unary] Primary type categories [] Composite type traits [meta.unary.comp]

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

19.15.6 Relationships between types [meta.rel]

19.15.7 Transformations between types [meta.trans] Const-volatile modifications [] Reference modifications [meta.trans.ref] Sign modifications [meta.trans.sign] Array modifications [meta.trans.arr] Pointer modifications [meta.trans.ptr] Other transformations [meta.trans.other]

19.15.8 Logical operator traits [meta.logical]

19.15.10 Constant evaluation context [meta.const.eval]

19.16 Compile-time rational arithmetic [ratio]

19.16.2 Header <ratio> synopsis [ratio.syn]

19.16.3 Class template ratio [ratio.ratio]

19.16.4 Arithmetic on ratios [ratio.arithmetic]

19.16.5 Comparison of ratios [ratio.comparison]

19.16.6 SI types for ratio []

19.17 Class type_­index [type.index]

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

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

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

19.18 Execution policies [execpol]

19.18.2 Header <execution> synopsis [execution.syn]

19.18.3 Execution policy type trait [execpol.type]

19.18.4 Sequenced execution policy [execpol.seq]

19.18.5 Parallel execution policy [execpol.par]

19.18.6 Parallel and unsequenced execution policy [execpol.parunseq]

19.18.7 Execution policy objects [execpol.objects]

19.19 Primitive numeric conversions [charconv]

19.19.1 Header <charconv> synopsis [charconv.syn]

19.19.2 Primitive numeric output conversion []

19.19.3 Primitive numeric input conversion [charconv.from.chars]

20 Strings library [strings][strings]

20.2 Character traits [char.traits]

20.2.1 Character traits requirements [char.traits.require]

20.2.3 char_­traits specializations [char.traits.specializations] struct char_­traits<char> [char.traits.specializations.char] struct char_­traits<char8_­t> [char.traits.specializations.char8_t] struct char_­traits<char16_­t> [char.traits.specializations.char16_t] struct char_­traits<char32_­t> [char.traits.specializations.char32_t] struct char_­traits<wchar_­t> [char.traits.specializations.wchar.t]

20.3 String classes [string.classes]

20.3.1 Header <string> synopsis [string.syn]

20.3.2 Class template basic_­string [basic.string] General requirements [string.require] Constructors and assignment operators [string.cons] Iterator support [string.iterators] Element access [string.access] Modifiers [string.modifiers] basic_­string​::​operator+= [string.op.append] basic_­string​::​append [string.append] basic_­string​::​assign [string.assign] basic_­string​::​insert [string.insert] basic_­string​::​erase [string.erase] basic_­string​::​replace [string.replace] basic_­string​::​copy [string.copy] basic_­string​::​swap [string.swap] String operations [string.ops] basic_­string​::​substr [string.substr] basic_­string​::​compare [] basic_­string​::​starts_­with [string.starts.with] basic_­string​::​ends_­with [string.ends.with]

20.3.3 Non-member functions [string.nonmembers] Non-member comparison functions [string.cmp] Inserters and extractors []

20.3.4 Numeric conversions [string.conversions]

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

20.4 String view classes [string.view]

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

20.4.2 Class template basic_­string_­view [string.view.template] Construction and assignment [string.view.cons] String operations [string.view.ops]

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

20.4.4 Inserters and extractors []

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

20.5 Null-terminated sequence utilities [c.strings]

20.5.1 Header <cctype> synopsis [cctype.syn]

20.5.2 Header <cwctype> synopsis [cwctype.syn]

20.5.3 Header <cstring> synopsis [cstring.syn]

20.5.4 Header <cwchar> synopsis [cwchar.syn]

20.5.5 Header <cuchar> synopsis [cuchar.syn]

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

21 Containers library [containers][containers]

21.2 Container requirements [container.requirements]

21.2.1 General container requirements [container.requirements.general]

21.2.3 Sequence containers [sequence.reqmts]

21.2.6 Associative containers [associative.reqmts] Exception safety guarantees [associative.reqmts.except]

21.2.7 Unordered associative containers [unord.req] Exception safety guarantees [unord.req.except]

21.3 Sequence containers [sequences]

21.3.2 Header <array> synopsis [array.syn]

21.3.3 Header <deque> synopsis [deque.syn]

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

21.3.5 Header <list> synopsis [list.syn]

21.3.6 Header <vector> synopsis [vector.syn]

21.3.7 Class template array [array] Constructors, copy, and assignment [array.cons] Member functions [array.members] Specialized algorithms [array.special] Zero-sized arrays [] Tuple interface [array.tuple]

21.3.8 Class template deque [deque] Constructors, copy, and assignment [deque.cons]

21.3.10 Class template list [list] Constructors, copy, and assignment [list.cons]

21.3.12 Class vector<bool> [vector.bool]

21.4 Associative containers [associative]

21.4.2 Header <map> synopsis []

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

21.4.4 Class template map [map] Constructors, copy, and assignment [map.cons] Element access [map.access]

21.4.6 Class template set [set] Constructors, copy, and assignment [set.cons]

21.5 Unordered associative containers [unord]

21.5.2 Header <unordered_­map> synopsis []

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

21.5.6 Class template unordered_­set [unord.set]

21.6 Container adaptors [container.adaptors]

21.6.2 Header <queue> synopsis [queue.syn]

21.6.3 Header <stack> synopsis [stack.syn]

21.6.4 Class template queue [queue] Constructors [queue.cons] Constructors with allocators [queue.cons.alloc] Specialized algorithms [queue.special]

21.6.5 Class template priority_­queue [priority.queue] Constructors with allocators [priqueue.cons.alloc] Specialized algorithms [priqueue.special]

21.6.6 Class template stack [stack] Constructors [stack.cons] Constructors with allocators [stack.cons.alloc] Specialized algorithms [stack.special]

21.7 Views [views]

21.7.2 Header <span> synopsis [span.syn]

21.7.3 Class template span [views.span] Constructors, copy, and assignment [span.cons] Element access [span.elem] Iterator support [span.iterators] Views of object representation [span.objectrep]

22 Iterators library [iterators][iterators]

22.2 Header <iterator> synopsis [iterator.synopsis]

22.3 Iterator requirements [iterator.requirements]

22.3.2 Associated types [iterator.assoc.types] Incrementable traits [incrementable.traits] Readable traits [readable.traits] Iterator traits [iterator.traits]

22.3.5 C++17 iterator requirements [iterator.cpp17] Input iterators [input.iterators] Output iterators [output.iterators] Forward iterators [forward.iterators] Bidirectional iterators [bidirectional.iterators] Random access iterators [random.access.iterators]

22.3.6 Indirect callable requirements [indirectcallable] Class template projected [projected]

22.3.7 Common algorithm requirements [alg.req] Concept IndirectlyMovable [alg.req.ind.move] Concept IndirectlyCopyable [alg.req.ind.copy] Concept IndirectlySwappable [alg.req.ind.swap] Concept IndirectlyComparable [alg.req.ind.cmp] Concept Permutable [alg.req.permutable] Concept Mergeable [alg.req.mergeable] Concept Sortable [alg.req.sortable]

22.4 Iterator primitives [iterator.primitives]

22.4.1 Standard iterator tags [std.iterator.tags]

22.4.2 Iterator operations [iterator.operations]

22.4.3 Range iterator operations [range.iter.ops] ranges​::​advance [range.iter.op.advance] ranges​::​distance [range.iter.op.distance] ranges​::​next [] ranges​::​prev [range.iter.op.prev]

22.5 Iterator adaptors [predef.iterators]

22.5.1 Reverse iterators [reverse.iterators] Class template reverse_­iterator [reverse.iterator] Construction and assignment [reverse.iter.cons] Non-member functions [reverse.iter.nonmember]

22.5.2 Insert iterators [insert.iterators] Class template back_­insert_­iterator [back.insert.iterator] back_­inserter [back.inserter] Class template front_­insert_­iterator [front.insert.iterator] front_­inserter [front.inserter] Class template insert_­iterator [insert.iterator]

22.5.3 Move iterators and sentinels [move.iterators] Class template move_­iterator [move.iterator] Construction and assignment [move.iter.cons] Element access [move.iter.elem] Non-member functions [move.iter.nonmember] Class template move_­sentinel [move.sentinel]

22.5.4 Common iterators [iterators.common] Class template common_­iterator [common.iterator] Associated types [common.iter.types] Constructors and conversions [common.iter.const]

22.5.5 Default sentinels [default.sentinels]

22.5.6 Counted iterators [iterators.counted] Class template counted_­iterator [counted.iterator] Constructors and conversions [counted.iter.const]

22.5.7 Unreachable sentinel [unreachable.sentinels] Class unreachable_­sentinel_­t [unreachable.sentinel]

22.6 Stream iterators [stream.iterators]

22.6.1 Class template istream_­iterator [istream.iterator] Constructors and destructor [istream.iterator.cons]

22.6.2 Class template ostream_­iterator [ostream.iterator] Constructors and destructor [ostream.iterator.cons.des]

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

22.6.4 Class template ostreambuf_­iterator [ostreambuf.iterator]

22.7 Range access [iterator.range]

22.8 Container and view access [iterator.container]

23 Ranges library [ranges][ranges]

23.2 Header <ranges> synopsis [ranges.syn]

23.3 Range access [range.access]

23.3.1 ranges​::​begin [range.access.begin]

23.3.2 ranges​::​end [range.access.end]

23.3.3 ranges​::​cbegin [range.access.cbegin]

23.3.4 ranges​::​cend [range.access.cend]

23.3.5 ranges​::​rbegin [range.access.rbegin]

23.3.6 ranges​::​rend [range.access.rend]

23.3.7 ranges​::​crbegin [range.access.crbegin]

23.3.8 ranges​::​crend [range.access.crend]

23.5 Range requirements [range.req]

23.5.3 Sized ranges [range.sized]

23.5.5 Common range refinements [range.refinements]

23.7 Range adaptors [range.adaptors]

23.7.1 Range adaptor objects [range.adaptor.object]

23.7.2 Semiregular wrapper [range.semi.wrap]

23.7.4 Filter view [range.filter] Class template filter_­view [range.filter.view] Class filter_­view​::​iterator [range.filter.iterator] Class filter_­view​::​sentinel [range.filter.sentinel] view​::​filter [range.filter.adaptor]

23.7.5 Transform view [range.transform] Class template transform_­view [range.transform.view] Class template transform_­view​::​iterator [range.transform.iterator] Class template transform_­view​::​sentinel [range.transform.sentinel] view​::​transform [range.transform.adaptor]

23.7.6 Iota view [range.iota] Class template iota_­view [range.iota.view] Class iota_­view​::​iterator [range.iota.iterator] Class iota_­view​::​sentinel [range.iota.sentinel]

23.7.7 Take view [range.take] Class template take_­view [range.take.view] Class template take_­view​::​sentinel [range.take.sentinel]

23.7.8 Join view [range.join] Class template join_­view [range.join.view] Class template join_­view​::​iterator [range.join.iterator] Class template join_­view​::​sentinel [range.join.sentinel]

23.7.9 Empty view [range.empty] Class template empty_­view [range.empty.view]

23.7.11 Split view [range.split] Class template split_­view [range.split.view] Class template split_­view​::​outer_­iterator [range.split.outer] Class split_­view​::​outer_­iterator​::​value_­type [range.split.outer.value] Class template split_­view​::​inner_­iterator [range.split.inner]

24 Algorithms library [algorithms][algorithms]

24.2 Algorithms requirements [algorithms.requirements]

24.3 Parallel algorithms [algorithms.parallel]

24.3.1 Terms and definitions [algorithms.parallel.defns]

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

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

24.3.4 Parallel algorithm exceptions [algorithms.parallel.exceptions]

24.3.5 ExecutionPolicy algorithm overloads [algorithms.parallel.overloads]

24.4 Header <algorithm> synopsis [algorithm.syn]

24.7 Sorting and related operations [alg.sorting]

24.7.1 Sorting [alg.sort] stable_­sort [stable.sort] partial_­sort [partial.sort] partial_­sort_­copy [partial.sort.copy] is_­sorted [is.sorted]

24.7.3 Binary search [] lower_­bound [lower.bound] upper_­bound [upper.bound] equal_­range [equal.range] binary_­search []

24.7.6 Set operations on sorted structures [alg.set.operations] set_­union [set.union] set_­intersection [set.intersection] set_­difference [set.difference] set_­symmetric_­difference [set.symmetric.difference]

24.7.8 Minimum and maximum [alg.min.max]

24.7.9 Bounded value [alg.clamp]

24.7.10 Lexicographical comparison [alg.lex.comparison]

24.7.11 Three-way comparison algorithms [alg.3way]

24.7.12 Permutation generators [alg.permutation.generators]

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

24.9 Generalized numeric operations [numeric.ops]

24.9.2 Accumulate [accumulate]

24.9.4 Inner product [inner.product]

24.9.5 Transform reduce [transform.reduce]

24.9.6 Partial sum [partial.sum]

24.9.7 Exclusive scan [exclusive.scan]

24.9.8 Inclusive scan [inclusive.scan]

24.9.9 Transform exclusive scan [transform.exclusive.scan]

24.9.10 Transform inclusive scan [transform.inclusive.scan]

24.9.11 Adjacent difference [adjacent.difference]

24.9.13 Greatest common divisor [numeric.ops.gcd]

24.9.14 Least common multiple [numeric.ops.lcm]

24.10 C library algorithms [alg.c.library]

25 Numerics library [numerics][numerics]

25.2 Numeric type requirements [numeric.requirements]

25.3 The floating-point environment [cfenv]

25.3.1 Header <cfenv> synopsis [cfenv.syn]

25.4 Complex numbers [complex.numbers]

25.4.1 Header <complex> synopsis [complex.syn]

25.4.2 Class template complex [complex]

25.4.3 Specializations [complex.special]

25.4.4 Member functions [complex.members]

25.4.5 Member operators [complex.member.ops]

25.4.6 Non-member operations [complex.ops]

25.4.7 Value operations [complex.value.ops]

25.4.9 Additional overloads [cmplx.over]

25.4.10 Suffixes for complex number literals [complex.literals]

25.5 Bit manipulation [bit]

25.5.2 Header <bit> synopsis [bit.syn]

25.5.3 Function template bit_­cast [bit.cast]

25.5.4 Integral powers of 2 [bit.pow.two]

25.6 Random number generation [rand]

25.6.1 Header <random> synopsis [rand.synopsis]

25.6.2 Requirements [rand.req] General requirements [rand.req.genl] Seed sequence requirements [rand.req.seedseq] Uniform random bit generator requirements [rand.req.urng] Random number engine requirements [rand.req.eng] Random number engine adaptor requirements [rand.req.adapt] Random number distribution requirements [rand.req.dist]

25.6.3 Random number engine class templates [rand.eng] Class template linear_­congruential_­engine [rand.eng.lcong] Class template mersenne_­twister_­engine [rand.eng.mers] Class template subtract_­with_­carry_­engine [rand.eng.sub]

25.6.4 Random number engine adaptor class templates [rand.adapt] Class template discard_­block_­engine [rand.adapt.disc] Class template independent_­bits_­engine [rand.adapt.ibits] Class template shuffle_­order_­engine [rand.adapt.shuf]

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

25.6.6 Class random_­device [rand.device]

25.6.7 Utilities [rand.util] Class seed_­seq [rand.util.seedseq] Function template generate_­canonical [rand.util.canonical]

25.6.8 Random number distribution class templates [rand.dist] Uniform distributions [rand.dist.uni] Class template uniform_­int_­distribution [] Class template uniform_­real_­distribution [rand.dist.uni.real] Bernoulli distributions [rand.dist.bern] Class bernoulli_­distribution [rand.dist.bern.bernoulli] Class template binomial_­distribution [rand.dist.bern.bin] Class template geometric_­distribution [rand.dist.bern.geo] Class template negative_­binomial_­distribution [rand.dist.bern.negbin] Poisson distributions [rand.dist.pois] Class template poisson_­distribution [rand.dist.pois.poisson] Class template exponential_­distribution [rand.dist.pois.exp] Class template gamma_­distribution [rand.dist.pois.gamma] Class template weibull_­distribution [rand.dist.pois.weibull] Class template extreme_­value_­distribution [rand.dist.pois.extreme] Normal distributions [rand.dist.norm] Class template normal_­distribution [rand.dist.norm.normal] Class template lognormal_­distribution [rand.dist.norm.lognormal] Class template chi_­squared_­distribution [rand.dist.norm.chisq] Class template cauchy_­distribution [rand.dist.norm.cauchy] Class template fisher_­f_­distribution [rand.dist.norm.f] Class template student_­t_­distribution [rand.dist.norm.t] Sampling distributions [rand.dist.samp] Class template discrete_­distribution [rand.dist.samp.discrete] Class template piecewise_­constant_­distribution [rand.dist.samp.pconst] Class template piecewise_­linear_­distribution [rand.dist.samp.plinear]

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

25.7 Numeric arrays [numarray]

25.7.1 Header <valarray> synopsis [valarray.syn]

25.7.3 valarray non-member operations [valarray.nonmembers] Binary operators [valarray.binary] Specialized algorithms [valarray.special]

25.7.10 valarray range access [valarray.range]

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

25.8.1 Header <cmath> synopsis [cmath.syn]

25.8.2 Absolute values [c.math.abs]

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

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

25.8.5 Mathematical special functions [sf.cmath] Associated Laguerre polynomials [sf.cmath.assoc_laguerre] Associated Legendre functions [sf.cmath.assoc_legendre] Complete elliptic integral of the first kind [sf.cmath.comp_ellint_1] Complete elliptic integral of the second kind [sf.cmath.comp_ellint_2] Complete elliptic integral of the third kind [sf.cmath.comp_ellint_3] Regular modified cylindrical Bessel functions [sf.cmath.cyl_bessel_i] Cylindrical Bessel functions of the first kind [sf.cmath.cyl_bessel_j] Irregular modified cylindrical Bessel functions [sf.cmath.cyl_bessel_k] Cylindrical Neumann functions [sf.cmath.cyl_neumann] Incomplete elliptic integral of the first kind [sf.cmath.ellint_1] Incomplete elliptic integral of the second kind [sf.cmath.ellint_2] Incomplete elliptic integral of the third kind [sf.cmath.ellint_3] Exponential integral [sf.cmath.expint] Hermite polynomials [sf.cmath.hermite] Laguerre polynomials [sf.cmath.laguerre] Legendre polynomials [sf.cmath.legendre] Riemann zeta function [sf.cmath.riemann_zeta] Spherical Bessel functions of the first kind [sf.cmath.sph_bessel] Spherical associated Legendre functions [sf.cmath.sph_legendre] Spherical Neumann functions [sf.cmath.sph_neumann]

26 Time library [time][time]

26.2 Header <chrono> synopsis [time.syn]

26.3 Cpp17Clock requirements [time.clock.req]

26.4 Time-related traits [time.traits]

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

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

26.4.4 Class template is_­clock [time.traits.is_clock]

26.6 Class template time_­point [time.point]

26.6.5 Non-member arithmetic [time.point.nonmember]

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

26.7 Clocks [time.clock]

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

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

26.7.9 time_­point conversions [time.clock.cast] Class template clock_­time_­conversion [time.clock.conv] Identity conversions [] Conversions between system_­clock and utc_­clock [time.clock.cast.sys.utc] Conversions between system_­clock and other clocks [time.clock.cast.sys] Conversions between utc_­clock and other clocks [time.clock.cast.utc] Function template clock_­cast [time.clock.cast.fn]

26.8 The civil calendar []

26.8.2 Class last_­spec []

26.8.10 Class month_­day_­last []

26.8.18 Conventional syntax operators []

26.9 Class template time_­of_­day [time.tod]

26.9.2 Hours precision [time.tod.hours]

26.9.3 Minutes precision [time.tod.minutes]

26.9.4 Seconds precision [time.tod.seconds]

26.9.5 Sub-second precision [time.tod.subsecond]

26.9.6 Formatted output []

26.10 Time zones []

26.10.2 Time zone database [] Class tzdb_­list [] Time zone database access [] Remote time zone database support []

26.10.3 Exception classes [] Class nonexistent_­local_­time [] Class ambiguous_­local_­time []

26.10.4 Information classes []

26.10.6 Class template zoned_­traits []

26.11 Formatting [time.format]

26.13 Header <ctime> synopsis [ctime.syn]

27 Localization library [localization][localization]

27.2 Header <locale> synopsis [locale.syn]

27.3 Locales [locales]

27.3.1 Class locale [locale] Types [locale.types] Type locale​::​category [locale.category] Class locale​::​facet [locale.facet] Class locale​::​id [] Constructors and destructor [locale.cons] Static members [locale.statics]

27.3.3 Convenience interfaces [locale.convenience] Character classification [classification] Conversions [conversions] Character conversions [conversions.character]

27.4 Standard locale categories [locale.categories]

27.4.3 The numeric punctuation facet [facet.numpunct] Class template numpunct_­byname [locale.numpunct.byname]

27.4.4 The collate category [category.collate] Class template collate_­byname [locale.collate.byname]

27.4.5 The time category [category.time] Class template time_­get_­byname [locale.time.get.byname] Class template time_­put_­byname [locale.time.put.byname]

27.4.7 The message retrieval category [category.messages] Class template messages_­byname [locale.messages.byname]

27.5 C library locales [c.locales]

27.5.1 Header <clocale> synopsis [clocale.syn]

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

28.2 Iostreams requirements [iostreams.requirements]

28.2.2 Positioning type limitations [iostreams.limits.pos]

28.3 Forward declarations [iostream.forward]

28.3.1 Header <iosfwd> synopsis [iosfwd.syn]

28.4 Standard iostream objects [iostream.objects]

28.4.1 Header <iostream> synopsis [iostream.syn]

28.4.3 Narrow stream objects []

28.4.4 Wide stream objects []

28.5 Iostreams base classes [iostreams.base]

28.5.1 Header <ios> synopsis [ios.syn]

28.5.3 Class ios_­base [ios.base] Types [ios.types] Class ios_­base​::​failure [ios.failure] Type ios_­base​::​fmtflags [ios.fmtflags] Type ios_­base​::​iostate [ios.iostate] Type ios_­base​::​openmode [ios.openmode] Type ios_­base​::​seekdir [ios.seekdir] Class ios_­base​::​Init [ios.init] State functions [fmtflags.state] Storage functions [] Constructors and destructor [ios.base.cons]

28.5.4 Class template fpos [fpos]

28.5.5 Class template basic_­ios [ios] Member functions [basic.ios.members] Flags functions [iostate.flags]

28.5.6 ios_­base manipulators [std.ios.manip] fmtflags manipulators [fmtflags.manip] adjustfield manipulators [adjustfield.manip] basefield manipulators [basefield.manip] floatfield manipulators [floatfield.manip]

28.5.7 Error reporting [error.reporting]

28.7 Formatting and manipulators [iostream.format]

28.7.1 Header <istream> synopsis [istream.syn]

28.7.2 Header <ostream> synopsis [ostream.syn]

28.7.3 Header <iomanip> synopsis [iomanip.syn]

28.7.4 Input streams [input.streams] Class template basic_­istream [istream] Assignment and swap [istream.assign] Class basic_­istream​::​sentry [istream.sentry] Formatted input functions [istream.formatted] basic_­istream​::​operator>> [istream.extractors] Unformatted input functions [istream.unformatted] Standard basic_­istream manipulators [istream.manip] Rvalue stream extraction [istream.rvalue] Class template basic_­iostream [iostreamclass] Assignment and swap [iostream.assign]

28.7.5 Output streams [output.streams] Class template basic_­ostream [ostream] Assignment and swap [ostream.assign] Class basic_­ostream​::​sentry [ostream.sentry] Formatted output functions [ostream.formatted] basic_­ostream​::​operator<< [ostream.inserters] Character inserter function templates [ostream.inserters.character] Unformatted output functions [ostream.unformatted] Standard manipulators [ostream.manip] Rvalue stream insertion [ostream.rvalue]

28.7.6 Standard manipulators [std.manip]

28.7.7 Extended manipulators [ext.manip]

28.7.8 Quoted manipulators [quoted.manip]

28.8 String-based streams [string.streams]

28.8.1 Header <sstream> synopsis [sstream.syn]

28.8.2 Class template basic_­stringbuf [stringbuf] Assignment and swap [stringbuf.assign] Member functions [stringbuf.members] Overridden virtual functions [stringbuf.virtuals]

28.8.3 Class template basic_­istringstream [istringstream] Assignment and swap [istringstream.assign]

28.8.4 Class template basic_­ostringstream [ostringstream] Assignment and swap [ostringstream.assign]

28.8.5 Class template basic_­stringstream [stringstream] Assignment and swap [stringstream.assign]

28.9 File-based streams [file.streams]

28.9.1 Header <fstream> synopsis [fstream.syn]

28.9.2 Class template basic_­filebuf [filebuf] Assignment and swap [filebuf.assign] Member functions [filebuf.members] Overridden virtual functions [filebuf.virtuals]

28.9.3 Class template basic_­ifstream [ifstream] Assignment and swap [ifstream.assign] Member functions [ifstream.members]

28.9.4 Class template basic_­ofstream [ofstream] Assignment and swap [ofstream.assign] Member functions [ofstream.members]

28.9.5 Class template basic_­fstream [fstream] Assignment and swap [fstream.assign] Member functions [fstream.members]

28.10 Synchronized output streams [syncstream]

28.10.1 Header <syncstream> synopsis [syncstream.syn]

28.10.2 Class template basic_­syncbuf [syncstream.syncbuf] Construction and destruction [syncstream.syncbuf.cons] Overridden virtual functions [syncstream.syncbuf.virtuals]

28.11 File systems [filesystems]

28.11.2 Conformance [fs.conformance] POSIX conformance [fs.conform.9945] Operating system dependent behavior conformance [fs.conform.os] File system race behavior [fs.race.behavior]

28.11.3 Normative references [fs.norm.ref]

28.11.4 Requirements [fs.req] Namespaces and headers [fs.req.namespace]

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

28.11.6 Error reporting []

28.11.9 Enumerations [fs.enum] Enum path​::​format [fs.enum.path.format] Enum class file_­type [fs.enum.file_type] Enum class copy_­options [fs.enum.copy.opts] Enum class perms [fs.enum.perms] Enum class perm_­options [fs.enum.perm.opts] Enum class directory_­options [fs.enum.dir.opts]

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

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

28.11.14 Filesystem operation functions [fs.op.funcs] Create directory symlink [fs.op.create_dir_symlk] Temporary directory path [fs.op.temp_dir_path]

28.12 C library files [c.files]

28.12.1 Header <cstdio> synopsis [cstdio.syn]

28.12.2 Header <cinttypes> synopsis [cinttypes.syn]

29 Regular expressions library [re][re]

29.2 Definitions [re.def]

29.3 Requirements [re.req]

29.4 Header <regex> synopsis [re.syn]

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

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

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

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

29.6 Class regex_­error [re.badexp]

29.7 Class template regex_­traits [re.traits]

29.8 Class template basic_­regex [re.regex]

29.8.3 Constant operations [re.regex.operations]

29.8.6 Non-member functions [re.regex.nonmemb]

29.9 Class template sub_­match [re.submatch]

29.9.2 Non-member operators [re.submatch.op]

29.11 Regular expression algorithms [re.alg]

29.11.1 Exceptions [re.except]

29.11.2 regex_­match [re.alg.match]

29.11.3 regex_­search []

29.11.4 regex_­replace [re.alg.replace]

29.12 Regular expression iterators [re.iter]

29.12.1 Class template regex_­iterator [re.regiter]

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

29.13 Modified ECMAScript regular expression grammar [re.grammar]

30 Atomic operations library [atomics][atomics]

30.2 Header <atomic> synopsis [atomics.syn]

30.3 Type aliases [atomics.alias]

30.4 Order and consistency [atomics.order]

30.5 Lock-free property [atomics.lockfree]

30.6 Class template atomic_­ref [atomics.ref.generic]

30.6.2 Specializations for integral types []

30.6.3 Specializations for floating-point types [atomics.ref.float]

30.6.4 Partial specialization for pointers [atomics.ref.pointer]

30.6.5 Member operators common to integers and pointers to objects [atomics.ref.memop]

30.7 Class template atomic [atomics.types.generic]

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

30.7.2 Specializations for integers []

30.7.3 Specializations for floating-point types [atomics.types.float]

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

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

30.8 Non-member functions [atomics.nonmembers]

30.9 Flag type and operations [atomics.flag]

31 Thread support library [thread][thread]

31.2 Requirements [thread.req]

31.2.1 Template parameter names [thread.req.paramname]

31.2.4 Timing specifications [thread.req.timing]

31.2.5 Requirements for Cpp17Lockable types [thread.req.lockable] Cpp17BasicLockable requirements [thread.req.lockable.basic] Cpp17Lockable requirements [thread.req.lockable.req] Cpp17TimedLockable requirements [thread.req.lockable.timed]

31.4 Mutual exclusion [thread.mutex]

31.4.1 Header <mutex> synopsis [mutex.syn]

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

31.4.5 Generic locking algorithms [thread.lock.algorithm]

31.4.6 Call once [thread.once] Struct once_­flag [thread.once.onceflag] Function call_­once [thread.once.callonce]

31.5 Condition variables [thread.condition]

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

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

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

31.6 Futures [futures]

31.6.2 Header <future> synopsis [future.syn]

31.6.3 Error handling [futures.errors]

31.6.4 Class future_­error [futures.future_error]

31.6.5 Shared state [futures.state]

31.6.6 Class template promise [futures.promise]

31.6.7 Class template future [futures.unique_future]

31.6.8 Class template shared_­future [futures.shared_future]

31.6.9 Function template async [futures.async]

31.6.10 Class template packaged_­task [futures.task]

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

A.1 Keywords [gram.key]

A.2 Lexical conventions [gram.lex]

A.4 Expressions [gram.expr]

A.5 Statements [gram.stmt]

A.6 Declarations [gram.dcl]

A.8 Overloading [gram.over]

A.9 Templates [gram.temp]

A.10 Exception handling [gram.except]

A.11 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 [lex]: lexical conventions [diff.lex]

C.1.3 [expr]: expressions [diff.expr]

C.1.5 [dcl.dcl]: declarations [diff.dcl]

C.1.7 [cpp]: preprocessing directives [diff.cpp]

C.6 C standard library [diff.library]

C.6.1 Modifications to headers []

C.6.2 Modifications to definitions []

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

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

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

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

C.6.2.7 Macro NULL [diff.null]

C.6.3 Modifications to declarations []

C.6.4 Modifications to behavior []

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

C.6.4.2 Memory allocation functions [diff.malloc]

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

D.1 Arithmetic conversion on enumerations [depr.arith.conv.enum]

D.2 Implicit capture of *this by reference [depr.capture.this]

D.3 Array comparisons [depr.array.comp]

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

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

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

D.6.1 Header <complex.h> synopsis [depr.complex.h.syn]

D.6.2 Header <iso646.h> synopsis [depr.iso646.h.syn]

D.6.3 Header <stdalign.h> synopsis [depr.stdalign.h.syn]

D.6.4 Header <stdbool.h> synopsis [depr.stdbool.h.syn]

D.6.5 Header <tgmath.h> synopsis [depr.tgmath.h.syn]

D.7 Relational operators [depr.relops]

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

D.8.1 Header <strstream> synopsis [depr.strstream.syn]

D.8.2 Class strstreambuf [depr.strstreambuf]

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

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

D.8.3 Class istrstream [depr.istrstream]

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

D.8.4 Class ostrstream [depr.ostrstream]

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

D.8.5 Class strstream [depr.strstream]

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

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

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

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

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

D.11 Deprecated shared_­ptr atomic access [depr.util.smartptr.shared.atomic]

D.12 Deprecated basic_­string capacity [depr.string.capacity]

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

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

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

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

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

D.15 Deprecated locale category facets [depr.locale.category]

D.16 Deprecated filesystem path factory functions [depr.fs.path.factory]


Index of library headers

Index of library names

Index of implementation-defined behavior