Working Draft, Standard for Programming Language C++

(Generated on 2020-07-15 from the LaTeX sources by cxxdraft-htmlgen. This is not an ISO publication.)

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.6 Tokens [lex.token]

5.7 Comments [lex.comment]

5.9 Preprocessing numbers [lex.ppnumber]

5.10 Identifiers [lex.name]

5.11 Keywords [lex.key]

5.12 Operators and punctuators [lex.operators]

5.13 Literals [lex.literal]

5.13.1 Kinds of literals [lex.literal.kinds]

5.13.2 Integer literals [lex.icon]

5.13.3 Character literals [lex.ccon]

5.13.4 Floating-point 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 Preamble [basic.pre]

6.2 Declarations and definitions [basic.def]

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

6.4 Scope [basic.scope]

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

6.4.2 Point of declaration [basic.scope.pdecl]

6.4.3 Block scope [basic.scope.block]

6.4.4 Function parameter scope [basic.scope.param]

6.4.5 Function scope [basic.funscope]

6.4.6 Namespace scope [basic.scope.namespace]

6.4.7 Class scope [basic.scope.class]

6.4.8 Enumeration scope [basic.scope.enum]

6.4.9 Template parameter scope [basic.scope.temp]

6.4.10 Name hiding [basic.scope.hiding]

6.5 Name lookup [basic.lookup]

6.5.1 Unqualified name lookup [basic.lookup.unqual]

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

6.5.3 Qualified name lookup [basic.lookup.qual]

6.5.3.1 Class members [class.qual]

6.5.3.2 Namespace members [namespace.qual]

6.5.4 Elaborated type specifiers [basic.lookup.elab]

6.5.5 Class member access [basic.lookup.classref]

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

6.6 Program and linkage [basic.link]

6.7 Memory and objects [basic.memobj]

6.7.1 Memory model [intro.memory]

6.7.2 Object model [intro.object]

6.7.3 Lifetime [basic.life]

6.7.4 Indeterminate values [basic.indet]

6.7.5 Storage duration [basic.stc]

6.7.5.1 Static storage duration [basic.stc.static]

6.7.5.2 Thread storage duration [basic.stc.thread]

6.7.5.3 Automatic storage duration [basic.stc.auto]

6.7.5.4 Dynamic storage duration [basic.stc.dynamic]

6.7.5.4.1 Allocation functions [basic.stc.dynamic.allocation]

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

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

6.7.5.5 Duration of subobjects [basic.stc.inherit]

6.7.6 Alignment [basic.align]

6.7.7 Temporary objects [class.temporary]

6.8 Types [basic.types]

6.8.1 Fundamental types [basic.fundamental]

6.8.2 Compound types [basic.compound]

6.8.3 CV-qualifiers [basic.type.qualifier]

6.8.4 Integer conversion rank [conv.rank]

6.9 Program execution [basic.exec]

6.9.1 Sequential execution [intro.execution]

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

6.9.2.1 Data races [intro.races]

6.9.2.2 Forward progress [intro.progress]

6.9.3 Start and termination [basic.start]

6.9.3.1 main function [basic.start.main]

6.9.3.2 Static initialization [basic.start.static]

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

6.9.3.4 Termination [basic.start.term]

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.2 Type [expr.type]

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.5 Primary expressions [expr.prim]

7.5.1 Literals [expr.prim.literal]

7.5.2 This [expr.prim.this]

7.5.3 Parentheses [expr.prim.paren]

7.5.4 Names [expr.prim.id]

7.5.4.1 Unqualified names [expr.prim.id.unqual]

7.5.4.2 Qualified names [expr.prim.id.qual]

7.5.4.3 Destruction [expr.prim.id.dtor]

7.5.5 Lambda expressions [expr.prim.lambda]

7.5.5.1 Closure types [expr.prim.lambda.closure]

7.5.5.2 Captures [expr.prim.lambda.capture]

7.5.6 Fold expressions [expr.prim.fold]

7.5.7 Requires expressions [expr.prim.req]

7.5.7.1 Simple requirements [expr.prim.req.simple]

7.5.7.2 Type requirements [expr.prim.req.type]

7.5.7.3 Compound requirements [expr.prim.req.compound]

7.5.7.4 Nested requirements [expr.prim.req.nested]

7.6 Compound expressions [expr.compound]

7.6.1 Postfix expressions [expr.post]

7.6.1.1 Subscripting [expr.sub]

7.6.1.2 Function call [expr.call]

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

7.6.1.4 Class member access [expr.ref]

7.6.1.5 Increment and decrement [expr.post.incr]

7.6.1.6 Dynamic cast [expr.dynamic.cast]

7.6.1.7 Type identification [expr.typeid]

7.6.1.8 Static cast [expr.static.cast]

7.6.1.9 Reinterpret cast [expr.reinterpret.cast]

7.6.1.10 Const cast [expr.const.cast]

7.6.2 Unary expressions [expr.unary]

7.6.2.1 Unary operators [expr.unary.op]

7.6.2.2 Increment and decrement [expr.pre.incr]

7.6.2.3 Await [expr.await]

7.6.2.4 Sizeof [expr.sizeof]

7.6.2.5 Alignof [expr.alignof]

7.6.2.6 noexcept operator [expr.unary.noexcept]

7.6.2.7 New [expr.new]

7.6.2.8 Delete [expr.delete]

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 Yielding a value [expr.yield]

7.6.18 Throwing an exception [expr.throw]

7.6.19 Assignment and compound assignment operators [expr.ass]

7.6.20 Comma operator [expr.comma]

7.7 Constant expressions [expr.const]

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

8.1 Preamble [stmt.pre]

8.2 Labeled statement [stmt.label]

8.3 Expression statement [stmt.expr]

8.4 Compound statement or block [stmt.block]

8.5 Selection statements [stmt.select]

8.5.1 The if statement [stmt.if]

8.5.2 The switch statement [stmt.switch]

8.6 Iteration statements [stmt.iter]

8.6.1 The while statement [stmt.while]

8.6.2 The do statement [stmt.do]

8.6.3 The for statement [stmt.for]

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

8.7 Jump statements [stmt.jump]

8.7.1 The break statement [stmt.break]

8.7.2 The continue statement [stmt.cont]

8.7.3 The return statement [stmt.return]

8.7.4 The co_return statement [stmt.return.coroutine]

8.7.5 The goto statement [stmt.goto]

8.8 Declaration statement [stmt.dcl]

8.9 Ambiguity resolution [stmt.ambig]

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

9.1 Preamble [dcl.pre]

9.2 Specifiers [dcl.spec]

9.2.1 Storage class specifiers [dcl.stc]

9.2.2 Function specifiers [dcl.fct.spec]

9.2.3 The typedef specifier [dcl.typedef]

9.2.4 The friend specifier [dcl.friend]

9.2.5 The constexpr and consteval specifiers [dcl.constexpr]

9.2.6 The constinit specifier [dcl.constinit]

9.2.7 The inline specifier [dcl.inline]

9.2.8 Type specifiers [dcl.type]

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

9.2.8.2 Simple type specifiers [dcl.type.simple]

9.2.8.3 Elaborated type specifiers [dcl.type.elab]

9.2.8.4 Decltype specifiers [dcl.type.decltype]

9.2.8.5 Placeholder type specifiers [dcl.spec.auto]

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

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

9.3 Declarators [dcl.decl]

9.3.1 Type names [dcl.name]

9.3.2 Ambiguity resolution [dcl.ambig.res]

9.3.3 Meaning of declarators [dcl.meaning]

9.3.3.1 Pointers [dcl.ptr]

9.3.3.2 References [dcl.ref]

9.3.3.3 Pointers to members [dcl.mptr]

9.3.3.4 Arrays [dcl.array]

9.3.3.5 Functions [dcl.fct]

9.3.3.6 Default arguments [dcl.fct.default]

9.4 Initializers [dcl.init]

9.4.1 Aggregates [dcl.init.aggr]

9.4.2 Character arrays [dcl.init.string]

9.4.3 References [dcl.init.ref]

9.4.4 List-initialization [dcl.init.list]

9.5 Function definitions [dcl.fct.def]

9.5.1 In general [dcl.fct.def.general]

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

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

9.5.4 Coroutine definitions [dcl.fct.def.coroutine]

9.6 Structured binding declarations [dcl.struct.bind]

9.7 Enumerations [enum]

9.7.1 Enumeration declarations [dcl.enum]

9.7.2 The using enum declaration [enum.udecl]

9.8 Namespaces [basic.namespace]

9.8.1 Namespace definition [namespace.def]

9.8.1.1 Unnamed namespaces [namespace.unnamed]

9.8.1.2 Namespace member definitions [namespace.memdef]

9.8.2 Namespace alias [namespace.alias]

9.8.3 Using namespace directive [namespace.udir]

9.9 The using declaration [namespace.udecl]

9.10 The asm declaration [dcl.asm]

9.11 Linkage specifications [dcl.link]

9.12 Attributes [dcl.attr]

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

9.12.2 Alignment specifier [dcl.align]

9.12.3 Carries dependency attribute [dcl.attr.depend]

9.12.4 Deprecated attribute [dcl.attr.deprecated]

9.12.5 Fallthrough attribute [dcl.attr.fallthrough]

9.12.6 Likelihood attributes [dcl.attr.likelihood]

9.12.7 Maybe unused attribute [dcl.attr.unused]

9.12.8 Nodiscard attribute [dcl.attr.nodiscard]

9.12.9 Noreturn attribute [dcl.attr.noreturn]

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

10 Modules [module][module]

10.1 Module units and purviews [module.unit]

10.2 Export declaration [module.interface]

10.3 Import declaration [module.import]

10.4 Global module fragment [module.global.frag]

10.5 Private module fragment [module.private.frag]

10.6 Instantiation context [module.context]

10.7 Reachability [module.reach]

11 Classes [class][class]

11.1 Preamble [class.pre]

11.2 Properties of classes [class.prop]

11.3 Class names [class.name]

11.4 Class members [class.mem]

11.4.1 Member functions [class.mfct]

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

11.4.2.1 The this pointer [class.this]

11.4.3 Special member functions [special]

11.4.4 Constructors [class.ctor]

11.4.4.1 Default constructors [class.default.ctor]

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

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

11.4.6 Destructors [class.dtor]

11.4.7 Conversions [class.conv]

11.4.7.1 Conversion by constructor [class.conv.ctor]

11.4.7.2 Conversion functions [class.conv.fct]

11.4.8 Static members [class.static]

11.4.8.1 Static member functions [class.static.mfct]

11.4.8.2 Static data members [class.static.data]

11.4.9 Bit-fields [class.bit]

11.4.10 Nested class declarations [class.nest]

11.4.11 Nested type names [class.nested.type]

11.5 Unions [class.union]

11.5.1 Anonymous unions [class.union.anon]

11.6 Local class declarations [class.local]

11.7 Derived classes [class.derived]

11.7.1 Multiple base classes [class.mi]

11.7.2 Virtual functions [class.virtual]

11.7.3 Abstract classes [class.abstract]

11.8 Member name lookup [class.member.lookup]

11.9 Member access control [class.access]

11.9.1 Access specifiers [class.access.spec]

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

11.9.3 Friends [class.friend]

11.9.4 Protected member access [class.protected]

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

11.9.6 Multiple access [class.paths]

11.9.7 Nested classes [class.access.nest]

11.10 Initialization [class.init]

11.10.1 Explicit initialization [class.expl.init]

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

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

11.10.4 Construction and destruction [class.cdtor]

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

11.11 Comparisons [class.compare]

11.11.1 Defaulted comparison operator functions [class.compare.default]

11.11.2 Equality operator [class.eq]

11.11.3 Three-way comparison [class.spaceship]

11.11.4 Secondary comparison operators [class.compare.secondary]

11.12 Free store [class.free]

12 Overloading [over][over]

12.1 Preamble [over.pre]

12.2 Overloadable declarations [over.load]

12.3 Declaration matching [over.dcl]

12.4 Overload resolution [over.match]

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

12.4.1.1 Function call syntax [over.match.call]

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

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

12.4.1.2 Operators in expressions [over.match.oper]

12.4.1.3 Initialization by constructor [over.match.ctor]

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

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

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

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

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

12.4.2 Viable functions [over.match.viable]

12.4.3 Best viable function [over.match.best]

12.4.3.1 Implicit conversion sequences [over.best.ics]

12.4.3.1.1 Standard conversion sequences [over.ics.scs]

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

12.4.3.1.3 Ellipsis conversion sequences [over.ics.ellipsis]

12.4.3.1.4 Reference binding [over.ics.ref]

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

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

12.5 Address of overloaded function [over.over]

12.6 Overloaded operators [over.oper]

12.6.1 Unary operators [over.unary]

12.6.2 Binary operators [over.binary]

12.6.2.1 Simple assignment [over.ass]

12.6.3 Function call [over.call]

12.6.4 Subscripting [over.sub]

12.6.5 Class member access [over.ref]

12.6.6 Increment and decrement [over.inc]

12.7 Built-in operators [over.built]

12.8 User-defined literals [over.literal]

13 Templates [temp][temp]

13.1 Preamble [temp.pre]

13.2 Template parameters [temp.param]

13.3 Names of template specializations [temp.names]

13.4 Template arguments [temp.arg]

13.4.1 Template type arguments [temp.arg.type]

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

13.4.3 Template template arguments [temp.arg.template]

13.5 Template constraints [temp.constr]

13.5.1 Constraints [temp.constr.constr]

13.5.1.1 Logical operations [temp.constr.op]

13.5.1.2 Atomic constraints [temp.constr.atomic]

13.5.2 Constrained declarations [temp.constr.decl]

13.5.3 Constraint normalization [temp.constr.normal]

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

13.6 Type equivalence [temp.type]

13.7 Template declarations [temp.decls]

13.7.1 Class templates [temp.class]

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

13.7.1.2 Deduction guides [temp.deduct.guide]

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

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

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

13.7.2 Member templates [temp.mem]

13.7.3 Variadic templates [temp.variadic]

13.7.4 Friends [temp.friend]

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

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

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

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

13.7.6 Function templates [temp.fct]

13.7.6.1 Function template overloading [temp.over.link]

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

13.7.7 Alias templates [temp.alias]

13.7.8 Concept definitions [temp.concept]

13.8 Name resolution [temp.res]

13.8.1 Locally declared names [temp.local]

13.8.2 Dependent names [temp.dep]

13.8.2.1 Dependent types [temp.dep.type]

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

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

13.8.2.4 Dependent template arguments [temp.dep.temp]

13.8.3 Non-dependent names [temp.nondep]

13.8.4 Dependent name resolution [temp.dep.res]

13.8.4.1 Point of instantiation [temp.point]

13.8.4.2 Candidate functions [temp.dep.candidate]

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

13.9 Template instantiation and specialization [temp.spec]

13.9.1 Implicit instantiation [temp.inst]

13.9.2 Explicit instantiation [temp.explicit]

13.9.3 Explicit specialization [temp.expl.spec]

13.10 Function template specializations [temp.fct.spec]

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

13.10.2 Template argument deduction [temp.deduct]

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

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

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

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

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

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

13.10.3 Overload resolution [temp.over]

14 Exception handling [except][except]

14.1 Preamble [except.pre]

14.2 Throwing an exception [except.throw]

14.3 Constructors and destructors [except.ctor]

14.4 Handling an exception [except.handle]

14.5 Exception specifications [except.spec]

14.6 Special functions [except.special]

14.6.1 The std::terminate function [except.terminate]

14.6.2 The std::uncaught_exceptions() function [except.uncaught]

15 Preprocessing directives [cpp][cpp]

15.1 Preamble [cpp.pre]

15.2 Conditional inclusion [cpp.cond]

15.3 Source file inclusion [cpp.include]

15.4 Module directive [cpp.module]

15.5 Header unit importation [cpp.import]

15.6 Macro replacement [cpp.replace]

15.6.1 Argument substitution [cpp.subst]

15.6.2 The # operator [cpp.stringize]

15.6.3 The ## operator [cpp.concat]

15.6.4 Rescanning and further replacement [cpp.rescan]

15.6.5 Scope of macro definitions [cpp.scope]

15.7 Line control [cpp.line]

15.8 Error directive [cpp.error]

15.9 Pragma directive [cpp.pragma]

15.10 Null directive [cpp.null]

15.11 Predefined macro names [cpp.predefined]

15.12 Pragma operator [cpp.pragma.op]

16 Library introduction [library][library]

16.1 General [library.general]

16.2 The C standard library [library.c]

16.3 Definitions [definitions]

16.4 Method of description [description]

16.4.1 Structure of each clause [structure]

16.4.1.1 Elements [structure.elements]

16.4.1.2 Summary [structure.summary]

16.4.1.3 Requirements [structure.requirements]

16.4.1.4 Detailed specifications [structure.specifications]

16.4.1.5 C library [structure.see.also]

16.4.2 Other conventions [conventions]

16.4.2.1 Exposition-only functions [expos.only.func]

16.4.2.2 Type descriptions [type.descriptions]

16.4.2.2.1 General [type.descriptions.general]

16.4.2.2.2 Exposition-only types [expos.only.types]

16.4.2.2.3 Enumerated types [enumerated.types]

16.4.2.2.4 Bitmask types [bitmask.types]

16.4.2.2.5 Character sequences [character.seq]

16.4.2.2.5.1 Byte strings [byte.strings]

16.4.2.2.5.2 Multibyte strings [multibyte.strings]

16.4.2.2.6 Customization Point Object types [customization.point.object]

16.4.2.3 Functions within classes [functions.within.classes]

16.4.2.4 Private members [objects.within.classes]

16.5 Library-wide requirements [requirements]

16.5.1 Library contents and organization [organization]

16.5.1.1 Library contents [contents]

16.5.1.2 Headers [headers]

16.5.1.3 Freestanding implementations [compliance]

16.5.2 Using the library [using]

16.5.2.1 Overview [using.overview]

16.5.2.2 Headers [using.headers]

16.5.2.3 Linkage [using.linkage]

16.5.3 Requirements on types and expressions [utility.requirements]

16.5.3.1 Template argument requirements [utility.arg.requirements]

16.5.3.2 Swappable requirements [swappable.requirements]

16.5.3.3 Cpp17NullablePointer requirements [nullablepointer.requirements]

16.5.3.4 Cpp17Hash requirements [hash.requirements]

16.5.3.5 Cpp17Allocator requirements [allocator.requirements]

16.5.3.5.1 Allocator completeness requirements [allocator.requirements.completeness]

16.5.4 Constraints on programs [constraints]

16.5.4.1 Overview [constraints.overview]

16.5.4.2 Namespace use [namespace.constraints]

16.5.4.2.1 Namespace std [namespace.std]

16.5.4.2.2 Namespace posix [namespace.posix]

16.5.4.2.3 Namespaces for future standardization [namespace.future]

16.5.4.3 Reserved names [reserved.names]

16.5.4.3.1 Zombie names [zombie.names]

16.5.4.3.2 Macro names [macro.names]

16.5.4.3.3 External linkage [extern.names]

16.5.4.3.4 Types [extern.types]

16.5.4.3.5 User-defined literal suffixes [usrlit.suffix]

16.5.4.4 Headers [alt.headers]

16.5.4.5 Derived classes [derived.classes]

16.5.4.6 Replacement functions [replacement.functions]

16.5.4.7 Handler functions [handler.functions]

16.5.4.8 Other functions [res.on.functions]

16.5.4.9 Function arguments [res.on.arguments]

16.5.4.10 Library object access [res.on.objects]

16.5.4.11 Semantic requirements [res.on.requirements]

16.5.5 Conforming implementations [conforming]

16.5.5.1 Overview [conforming.overview]

16.5.5.2 Headers [res.on.headers]

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

16.5.5.4 Non-member functions [global.functions]

16.5.5.5 Member functions [member.functions]

16.5.5.6 Friend functions [hidden.friends]

16.5.5.7 Constexpr functions and constructors [constexpr.functions]

16.5.5.8 Requirements for stable algorithms [algorithm.stable]

16.5.5.9 Reentrancy [reentrancy]

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

16.5.5.11 Protection within classes [protection.within.classes]

16.5.5.12 Derived classes [derivation]

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

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

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

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

17 Language support library [support][support]

17.1 General [support.general]

17.2 Common definitions [support.types]

17.2.1 Header <cstddef> synopsis [cstddef.syn]

17.2.2 Header <cstdlib> synopsis [cstdlib.syn]

17.2.3 Null pointers [support.types.nullptr]

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

17.2.5 byte type operations [support.types.byteops]

17.3 Implementation properties [support.limits]

17.3.1 General [support.limits.general]

17.3.2 Header <version> synopsis [version.syn]

17.3.3 Header <limits> synopsis [limits.syn]

17.3.4 Floating-point type properties [fp.style]

17.3.4.1 Type float_round_style [round.style]

17.3.4.2 Type float_denorm_style [denorm.style]

17.3.5 Class template numeric_limits [numeric.limits]

17.3.5.1 numeric_limits members [numeric.limits.members]

17.3.5.2 numeric_limits specializations [numeric.special]

17.3.6 Header <climits> synopsis [climits.syn]

17.3.7 Header <cfloat> synopsis [cfloat.syn]

17.4 Integer types [cstdint]

17.4.1 Header <cstdint> synopsis [cstdint.syn]

17.5 Startup and termination [support.start.term]

17.6 Dynamic memory management [support.dynamic]

17.6.1 Header <new> synopsis [new.syn]

17.6.2 Storage allocation and deallocation [new.delete]

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

17.6.2.2 Array forms [new.delete.array]

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

17.6.2.4 Data races [new.delete.dataraces]

17.6.3 Storage allocation errors [alloc.errors]

17.6.3.1 Class bad_alloc [bad.alloc]

17.6.3.2 Class bad_array_new_length [new.badlength]

17.6.3.3 Type new_handler [new.handler]

17.6.3.4 set_new_handler [set.new.handler]

17.6.3.5 get_new_handler [get.new.handler]

17.6.4 Pointer optimization barrier [ptr.launder]

17.6.5 Hardware interference size [hardware.interference]

17.7 Type identification [support.rtti]

17.7.1 Header <typeinfo> synopsis [typeinfo.syn]

17.7.2 Class type_info [type.info]

17.7.3 Class bad_cast [bad.cast]

17.7.4 Class bad_typeid [bad.typeid]

17.8 Source location [support.srcloc]

17.8.1 Header <source_location> synopsis [source.location.syn]

17.8.2 Class source_location [support.srcloc.class]

17.8.2.1 Creation [support.srcloc.cons]

17.8.2.2 Observers [support.srcloc.obs]

17.9 Exception handling [support.exception]

17.9.1 Header <exception> synopsis [exception.syn]

17.9.2 Class exception [exception]

17.9.3 Class bad_exception [bad.exception]

17.9.4 Abnormal termination [exception.terminate]

17.9.4.1 Type terminate_handler [terminate.handler]

17.9.4.2 set_terminate [set.terminate]

17.9.4.3 get_terminate [get.terminate]

17.9.4.4 terminate [terminate]

17.9.5 uncaught_exceptions [uncaught.exceptions]

17.9.6 Exception propagation [propagation]

17.9.7 nested_exception [except.nested]

17.10 Initializer lists [support.initlist]

17.10.1 Header <initializer_list> synopsis [initializer.list.syn]

17.10.2 Initializer list constructors [support.initlist.cons]

17.10.3 Initializer list access [support.initlist.access]

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

17.11 Comparisons [cmp]

17.11.1 Header <compare> synopsis [compare.syn]

17.11.2 Comparison category types [cmp.categories]

17.11.2.1 Preamble [cmp.categories.pre]

17.11.2.2 Class partial_ordering [cmp.partialord]

17.11.2.3 Class weak_ordering [cmp.weakord]

17.11.2.4 Class strong_ordering [cmp.strongord]

17.11.3 Class template common_comparison_category [cmp.common]

17.11.4 Concept three_way_comparable [cmp.concept]

17.11.5 Result of three-way comparison [cmp.result]

17.11.6 Comparison algorithms [cmp.alg]

17.12 Coroutines [support.coroutine]

17.12.1 Header <coroutine> synopsis [coroutine.syn]

17.12.2 Coroutine traits [coroutine.traits]

17.12.2.1 Class template coroutine_traits [coroutine.traits.primary]

17.12.3 Class template coroutine_handle [coroutine.handle]

17.12.3.1 Construct/reset [coroutine.handle.con]

17.12.3.2 Export/import [coroutine.handle.export.import]

17.12.3.3 Observers [coroutine.handle.observers]

17.12.3.4 Resumption [coroutine.handle.resumption]

17.12.3.5 Promise access [coroutine.handle.promise]

17.12.3.6 Comparison operators [coroutine.handle.compare]

17.12.3.7 Hash support [coroutine.handle.hash]

17.12.4 No-op coroutines [coroutine.noop]

17.12.4.1 Class noop_coroutine_promise [coroutine.promise.noop]

17.12.4.2 Class coroutine_handle<noop_coroutine_promise> [coroutine.handle.noop]

17.12.4.2.1 Observers [coroutine.handle.noop.observers]

17.12.4.2.2 Resumption [coroutine.handle.noop.resumption]

17.12.4.2.3 Promise access [coroutine.handle.noop.promise]

17.12.4.2.4 Address [coroutine.handle.noop.address]

17.12.4.3 Function noop_coroutine [coroutine.noop.coroutine]

17.12.5 Trivial awaitables [coroutine.trivial.awaitables]

17.13 Other runtime support [support.runtime]

17.13.1 Header <cstdarg> synopsis [cstdarg.syn]

17.13.2 Header <csetjmp> synopsis [csetjmp.syn]

17.13.3 Header <csignal> synopsis [csignal.syn]

17.13.4 Signal handlers [support.signal]

18 Concepts library [concepts][concepts]

18.1 General [concepts.general]

18.2 Equality preservation [concepts.equality]

18.3 Header <concepts> synopsis [concepts.syn]

18.4 Language-related concepts [concepts.lang]

18.4.1 General [concepts.lang.general]

18.4.2 Concept same_as [concept.same]

18.4.3 Concept derived_from [concept.derived]

18.4.4 Concept convertible_to [concept.convertible]

18.4.5 Concept common_reference_with [concept.commonref]

18.4.6 Concept common_with [concept.common]

18.4.7 Arithmetic concepts [concepts.arithmetic]

18.4.8 Concept assignable_from [concept.assignable]

18.4.9 Concept swappable [concept.swappable]

18.4.10 Concept destructible [concept.destructible]

18.4.11 Concept constructible_from [concept.constructible]

18.4.12 Concept default_initializable [concept.default.init]

18.4.13 Concept move_constructible [concept.moveconstructible]

18.4.14 Concept copy_constructible [concept.copyconstructible]

18.5 Comparison concepts [concepts.compare]

18.5.1 General [concepts.compare.general]

18.5.2 Boolean testability [concept.booleantestable]

18.5.3 Concept equality_comparable [concept.equalitycomparable]

18.5.4 Concept totally_ordered [concept.totallyordered]

18.6 Object concepts [concepts.object]

18.7 Callable concepts [concepts.callable]

18.7.1 General [concepts.callable.general]

18.7.2 Concept invocable [concept.invocable]

18.7.3 Concept regular_invocable [concept.regularinvocable]

18.7.4 Concept predicate [concept.predicate]

18.7.5 Concept relation [concept.relation]

18.7.6 Concept equivalence_relation [concept.equiv]

18.7.7 Concept strict_weak_order [concept.strictweakorder]

19 Diagnostics library [diagnostics][diagnostics]

19.1 General [diagnostics.general]

19.2 Exception classes [std.exceptions]

19.2.1 Header <stdexcept> synopsis [stdexcept.syn]

19.2.2 Class logic_error [logic.error]

19.2.3 Class domain_error [domain.error]

19.2.4 Class invalid_argument [invalid.argument]

19.2.5 Class length_error [length.error]

19.2.6 Class out_of_range [out.of.range]

19.2.7 Class runtime_error [runtime.error]

19.2.8 Class range_error [range.error]

19.2.9 Class overflow_error [overflow.error]

19.2.10 Class underflow_error [underflow.error]

19.3 Assertions [assertions]

19.3.1 Header <cassert> synopsis [cassert.syn]

19.3.2 The assert macro [assertions.assert]

19.4 Error numbers [errno]

19.4.1 Header <cerrno> synopsis [cerrno.syn]

19.5 System error support [syserr]

19.5.1 Header <system_error> synopsis [system.error.syn]

19.5.2 Class error_category [syserr.errcat]

19.5.2.1 Overview [syserr.errcat.overview]

19.5.2.2 Virtual members [syserr.errcat.virtuals]

19.5.2.3 Non-virtual members [syserr.errcat.nonvirtuals]

19.5.2.4 Program-defined classes derived from error_category [syserr.errcat.derived]

19.5.2.5 Error category objects [syserr.errcat.objects]

19.5.3 Class error_code [syserr.errcode]

19.5.3.1 Overview [syserr.errcode.overview]

19.5.3.2 Constructors [syserr.errcode.constructors]

19.5.3.3 Modifiers [syserr.errcode.modifiers]

19.5.3.4 Observers [syserr.errcode.observers]

19.5.3.5 Non-member functions [syserr.errcode.nonmembers]

19.5.4 Class error_condition [syserr.errcondition]

19.5.4.1 Overview [syserr.errcondition.overview]

19.5.4.2 Constructors [syserr.errcondition.constructors]

19.5.4.3 Modifiers [syserr.errcondition.modifiers]

19.5.4.4 Observers [syserr.errcondition.observers]

19.5.4.5 Non-member functions [syserr.errcondition.nonmembers]

19.5.5 Comparison functions [syserr.compare]

19.5.6 System error hash support [syserr.hash]

19.5.7 Class system_error [syserr.syserr]

19.5.7.1 Overview [syserr.syserr.overview]

19.5.7.2 Members [syserr.syserr.members]

20 General utilities library [utilities][utilities]

20.1 General [utilities.general]

20.2 Utility components [utility]

20.2.1 Header <utility> synopsis [utility.syn]

20.2.2 swap [utility.swap]

20.2.3 exchange [utility.exchange]

20.2.4 Forward/move helpers [forward]

20.2.5 Function template as_const [utility.as.const]

20.2.6 Function template declval [declval]

20.2.7 Integer comparison functions [utility.intcmp]

20.3 Compile-time integer sequences [intseq]

20.3.1 In general [intseq.general]

20.3.2 Class template integer_sequence [intseq.intseq]

20.3.3 Alias template make_integer_sequence [intseq.make]

20.4 Pairs [pairs]

20.4.1 In general [pairs.general]

20.4.2 Class template pair [pairs.pair]

20.4.3 Specialized algorithms [pairs.spec]

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

20.4.5 Piecewise construction [pair.piecewise]

20.5 Tuples [tuple]

20.5.1 In general [tuple.general]

20.5.2 Header <tuple> synopsis [tuple.syn]

20.5.3 Class template tuple [tuple.tuple]

20.5.3.1 Construction [tuple.cnstr]

20.5.3.2 Assignment [tuple.assign]

20.5.3.3 swap [tuple.swap]

20.5.4 Tuple creation functions [tuple.creation]

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

20.5.6 Tuple helper classes [tuple.helper]

20.5.7 Element access [tuple.elem]

20.5.8 Relational operators [tuple.rel]

20.5.9 Tuple traits [tuple.traits]

20.5.10 Tuple specialized algorithms [tuple.special]

20.6 Optional objects [optional]

20.6.1 In general [optional.general]

20.6.2 Header <optional> synopsis [optional.syn]

20.6.3 Class template optional [optional.optional]

20.6.3.1 Constructors [optional.ctor]

20.6.3.2 Destructor [optional.dtor]

20.6.3.3 Assignment [optional.assign]

20.6.3.4 Swap [optional.swap]

20.6.3.5 Observers [optional.observe]

20.6.3.6 Modifiers [optional.mod]

20.6.4 No-value state indicator [optional.nullopt]

20.6.5 Class bad_optional_access [optional.bad.access]

20.6.6 Relational operators [optional.relops]

20.6.7 Comparison with nullopt [optional.nullops]

20.6.8 Comparison with T [optional.comp.with.t]

20.6.9 Specialized algorithms [optional.specalg]

20.6.10 Hash support [optional.hash]

20.7 Variants [variant]

20.7.1 In general [variant.general]

20.7.2 Header <variant> synopsis [variant.syn]

20.7.3 Class template variant [variant.variant]

20.7.3.1 Constructors [variant.ctor]

20.7.3.2 Destructor [variant.dtor]

20.7.3.3 Assignment [variant.assign]

20.7.3.4 Modifiers [variant.mod]

20.7.3.5 Value status [variant.status]

20.7.3.6 Swap [variant.swap]

20.7.4 variant helper classes [variant.helper]

20.7.5 Value access [variant.get]

20.7.6 Relational operators [variant.relops]

20.7.7 Visitation [variant.visit]

20.7.8 Class monostate [variant.monostate]

20.7.9 monostate relational operators [variant.monostate.relops]

20.7.10 Specialized algorithms [variant.specalg]

20.7.11 Class bad_variant_access [variant.bad.access]

20.7.12 Hash support [variant.hash]

20.8 Storage for any type [any]

20.8.1 Header <any> synopsis [any.synop]

20.8.2 Class bad_any_cast [any.bad.any.cast]

20.8.3 Class any [any.class]

20.8.3.1 Construction and destruction [any.cons]

20.8.3.2 Assignment [any.assign]

20.8.3.3 Modifiers [any.modifiers]

20.8.3.4 Observers [any.observers]

20.8.4 Non-member functions [any.nonmembers]

20.9 Bitsets [bitset]

20.9.1 Header <bitset> synopsis [bitset.syn]

20.9.2 Class template bitset [template.bitset]

20.9.2.1 Constructors [bitset.cons]

20.9.2.2 Members [bitset.members]

20.9.3 bitset hash support [bitset.hash]

20.9.4 bitset operators [bitset.operators]

20.10 Memory [memory]

20.10.1 In general [memory.general]

20.10.2 Header <memory> synopsis [memory.syn]

20.10.3 Pointer traits [pointer.traits]

20.10.3.1 Member types [pointer.traits.types]

20.10.3.2 Member functions [pointer.traits.functions]

20.10.3.3 Optional members [pointer.traits.optmem]

20.10.4 Pointer conversion [pointer.conversion]

20.10.5 Pointer safety [util.dynamic.safety]

20.10.6 Pointer alignment [ptr.align]

20.10.7 Allocator argument tag [allocator.tag]

20.10.8 uses_allocator [allocator.uses]

20.10.8.1 uses_allocator trait [allocator.uses.trait]

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

20.10.9 Allocator traits [allocator.traits]

20.10.9.1 Member types [allocator.traits.types]

20.10.9.2 Static member functions [allocator.traits.members]

20.10.10 The default allocator [default.allocator]

20.10.10.1 Members [allocator.members]

20.10.10.2 Operators [allocator.globals]

20.10.11 addressof [specialized.addressof]

20.10.12 C library memory allocation [c.malloc]

20.11 Smart pointers [smartptr]

20.11.1 Class template unique_ptr [unique.ptr]

20.11.1.1 Default deleters [unique.ptr.dltr]

20.11.1.1.1 In general [unique.ptr.dltr.general]

20.11.1.1.2 default_delete [unique.ptr.dltr.dflt]

20.11.1.1.3 default_delete<T[]> [unique.ptr.dltr.dflt1]

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

20.11.1.2.1 Constructors [unique.ptr.single.ctor]

20.11.1.2.2 Destructor [unique.ptr.single.dtor]

20.11.1.2.3 Assignment [unique.ptr.single.asgn]

20.11.1.2.4 Observers [unique.ptr.single.observers]

20.11.1.2.5 Modifiers [unique.ptr.single.modifiers]

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

20.11.1.3.1 Constructors [unique.ptr.runtime.ctor]

20.11.1.3.2 Assignment [unique.ptr.runtime.asgn]

20.11.1.3.3 Observers [unique.ptr.runtime.observers]

20.11.1.3.4 Modifiers [unique.ptr.runtime.modifiers]

20.11.1.4 Creation [unique.ptr.create]

20.11.1.5 Specialized algorithms [unique.ptr.special]

20.11.1.6 I/O [unique.ptr.io]

20.11.2 Class bad_weak_ptr [util.smartptr.weak.bad]

20.11.3 Class template shared_ptr [util.smartptr.shared]

20.11.3.1 Constructors [util.smartptr.shared.const]

20.11.3.2 Destructor [util.smartptr.shared.dest]

20.11.3.3 Assignment [util.smartptr.shared.assign]

20.11.3.4 Modifiers [util.smartptr.shared.mod]

20.11.3.5 Observers [util.smartptr.shared.obs]

20.11.3.6 Creation [util.smartptr.shared.create]

20.11.3.7 Comparison [util.smartptr.shared.cmp]

20.11.3.8 Specialized algorithms [util.smartptr.shared.spec]

20.11.3.9 Casts [util.smartptr.shared.cast]

20.11.3.10 get_deleter [util.smartptr.getdeleter]

20.11.3.11 I/O [util.smartptr.shared.io]

20.11.4 Class template weak_ptr [util.smartptr.weak]

20.11.4.1 Constructors [util.smartptr.weak.const]

20.11.4.2 Destructor [util.smartptr.weak.dest]

20.11.4.3 Assignment [util.smartptr.weak.assign]

20.11.4.4 Modifiers [util.smartptr.weak.mod]

20.11.4.5 Observers [util.smartptr.weak.obs]

20.11.4.6 Specialized algorithms [util.smartptr.weak.spec]

20.11.5 Class template owner_less [util.smartptr.ownerless]

20.11.6 Class template enable_shared_from_this [util.smartptr.enab]

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

20.12 Memory resources [mem.res]

20.12.1 Header <memory_resource> synopsis [mem.res.syn]

20.12.2 Class memory_resource [mem.res.class]

20.12.2.1 Public member functions [mem.res.public]

20.12.2.2 Private virtual member functions [mem.res.private]

20.12.2.3 Equality [mem.res.eq]

20.12.3 Class template polymorphic_allocator [mem.poly.allocator.class]

20.12.3.1 Constructors [mem.poly.allocator.ctor]

20.12.3.2 Member functions [mem.poly.allocator.mem]

20.12.3.3 Equality [mem.poly.allocator.eq]

20.12.4 Access to program-wide memory_resource objects [mem.res.global]

20.12.5 Pool resource classes [mem.res.pool]

20.12.5.1 Classes synchronized_pool_resource and unsynchronized_pool_resource [mem.res.pool.overview]

20.12.5.2 pool_options data members [mem.res.pool.options]

20.12.5.3 Constructors and destructors [mem.res.pool.ctor]

20.12.5.4 Members [mem.res.pool.mem]

20.12.6 Class monotonic_buffer_resource [mem.res.monotonic.buffer]

20.12.6.1 Constructors and destructor [mem.res.monotonic.buffer.ctor]

20.12.6.2 Members [mem.res.monotonic.buffer.mem]

20.13 Class template scoped_allocator_adaptor [allocator.adaptor]

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

20.13.2 Member types [allocator.adaptor.types]

20.13.3 Constructors [allocator.adaptor.cnstr]

20.13.4 Members [allocator.adaptor.members]

20.13.5 Operators [scoped.adaptor.operators]

20.14 Function objects [function.objects]

20.14.1 Header <functional> synopsis [functional.syn]

20.14.2 Definitions [func.def]

20.14.3 Requirements [func.require]

20.14.4 Function template invoke [func.invoke]

20.14.5 Class template reference_wrapper [refwrap]

20.14.5.1 Constructors and destructor [refwrap.const]

20.14.5.2 Assignment [refwrap.assign]

20.14.5.3 Access [refwrap.access]

20.14.5.4 Invocation [refwrap.invoke]

20.14.5.5 Helper functions [refwrap.helpers]

20.14.6 Arithmetic operations [arithmetic.operations]

20.14.6.1 Class template plus [arithmetic.operations.plus]

20.14.6.2 Class template minus [arithmetic.operations.minus]

20.14.6.3 Class template multiplies [arithmetic.operations.multiplies]

20.14.6.4 Class template divides [arithmetic.operations.divides]

20.14.6.5 Class template modulus [arithmetic.operations.modulus]

20.14.6.6 Class template negate [arithmetic.operations.negate]

20.14.7 Comparisons [comparisons]

20.14.7.1 Class template equal_to [comparisons.equal.to]

20.14.7.2 Class template not_equal_to [comparisons.not.equal.to]

20.14.7.3 Class template greater [comparisons.greater]

20.14.7.4 Class template less [comparisons.less]

20.14.7.5 Class template greater_equal [comparisons.greater.equal]

20.14.7.6 Class template less_equal [comparisons.less.equal]

20.14.7.7 Class compare_three_way [comparisons.three.way]

20.14.8 Concept-constrained comparisons [range.cmp]

20.14.9 Logical operations [logical.operations]

20.14.9.1 Class template logical_and [logical.operations.and]

20.14.9.2 Class template logical_or [logical.operations.or]

20.14.9.3 Class template logical_not [logical.operations.not]

20.14.10 Bitwise operations [bitwise.operations]

20.14.10.1 Class template bit_and [bitwise.operations.and]

20.14.10.2 Class template bit_or [bitwise.operations.or]

20.14.10.3 Class template bit_xor [bitwise.operations.xor]

20.14.10.4 Class template bit_not [bitwise.operations.not]

20.14.11 Class identity [func.identity]

20.14.12 Function template not_fn [func.not.fn]

20.14.13 Function template bind_front [func.bind.front]

20.14.14 Function object binders [func.bind]

20.14.14.1 Class template is_bind_expression [func.bind.isbind]

20.14.14.2 Class template is_placeholder [func.bind.isplace]

20.14.14.3 Function template bind [func.bind.bind]

20.14.14.4 Placeholders [func.bind.place]

20.14.15 Function template mem_fn [func.memfn]

20.14.16 Polymorphic function wrappers [func.wrap]

20.14.16.1 Class bad_function_call [func.wrap.badcall]

20.14.16.2 Class template function [func.wrap.func]

20.14.16.2.1 Constructors and destructor [func.wrap.func.con]

20.14.16.2.2 Modifiers [func.wrap.func.mod]

20.14.16.2.3 Capacity [func.wrap.func.cap]

20.14.16.2.4 Invocation [func.wrap.func.inv]

20.14.16.2.5 Target access [func.wrap.func.targ]

20.14.16.2.6 Null pointer comparison functions [func.wrap.func.nullptr]

20.14.16.2.7 Specialized algorithms [func.wrap.func.alg]

20.14.17 Searchers [func.search]

20.14.17.1 Class template default_searcher [func.search.default]

20.14.17.2 Class template boyer_moore_searcher [func.search.bm]

20.14.17.3 Class template boyer_moore_horspool_searcher [func.search.bmh]

20.14.18 Class template hash [unord.hash]

20.15 Metaprogramming and type traits [meta]

20.15.1 Requirements [meta.rqmts]

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

20.15.3 Helper classes [meta.help]

20.15.4 Unary type traits [meta.unary]

20.15.4.1 Primary type categories [meta.unary.cat]

20.15.4.2 Composite type traits [meta.unary.comp]

20.15.4.3 Type properties [meta.unary.prop]

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

20.15.6 Relationships between types [meta.rel]

20.15.7 Transformations between types [meta.trans]

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

20.15.7.2 Reference modifications [meta.trans.ref]

20.15.7.3 Sign modifications [meta.trans.sign]

20.15.7.4 Array modifications [meta.trans.arr]

20.15.7.5 Pointer modifications [meta.trans.ptr]

20.15.7.6 Other transformations [meta.trans.other]

20.15.8 Logical operator traits [meta.logical]

20.15.9 Member relationships [meta.member]

20.15.10 Constant evaluation context [meta.const.eval]

20.16 Compile-time rational arithmetic [ratio]

20.16.1 In general [ratio.general]

20.16.2 Header <ratio> synopsis [ratio.syn]

20.16.3 Class template ratio [ratio.ratio]

20.16.4 Arithmetic on ratios [ratio.arithmetic]

20.16.5 Comparison of ratios [ratio.comparison]

20.16.6 SI types for ratio [ratio.si]

20.17 Class type_index [type.index]

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

20.17.2 type_index overview [type.index.overview]

20.17.3 type_index members [type.index.members]

20.17.4 Hash support [type.index.hash]

20.18 Execution policies [execpol]

20.18.1 In general [execpol.general]

20.18.2 Header <execution> synopsis [execution.syn]

20.18.3 Execution policy type trait [execpol.type]

20.18.4 Sequenced execution policy [execpol.seq]

20.18.5 Parallel execution policy [execpol.par]

20.18.6 Parallel and unsequenced execution policy [execpol.parunseq]

20.18.7 Unsequenced execution policy [execpol.unseq]

20.18.8 Execution policy objects [execpol.objects]

20.19 Primitive numeric conversions [charconv]

20.19.1 Header <charconv> synopsis [charconv.syn]

20.19.2 Primitive numeric output conversion [charconv.to.chars]

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

20.20 Formatting [format]

20.20.1 Header <format> synopsis [format.syn]

20.20.2 Format string [format.string]

20.20.2.1 In general [format.string.general]

20.20.2.2 Standard format specifiers [format.string.std]

20.20.3 Error reporting [format.err.report]

20.20.4 Formatting functions [format.functions]

20.20.5 Formatter [format.formatter]

20.20.5.1 Formatter requirements [formatter.requirements]

20.20.5.2 Formatter specializations [format.formatter.spec]

20.20.5.3 Class template basic_format_parse_context [format.parse.ctx]

20.20.5.4 Class template basic_format_context [format.context]

20.20.6 Arguments [format.arguments]

20.20.6.1 Class template basic_format_arg [format.arg]

20.20.6.2 Class template format-arg-store [format.arg.store]

20.20.6.3 Class template basic_format_args [format.args]

20.20.7 Class format_error [format.error]

21 Strings library [strings][strings]

21.1 General [strings.general]

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<char8_t> [char.traits.specializations.char8.t]

21.2.3.3 struct char_traits<char16_t> [char.traits.specializations.char16.t]

21.2.3.4 struct char_traits<char32_t> [char.traits.specializations.char32.t]

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

21.3 String classes [string.classes]

21.3.1 Header <string> synopsis [string.syn]

21.3.2 Class template basic_string [basic.string]

21.3.2.1 General requirements [string.require]

21.3.2.2 Constructors and assignment operators [string.cons]

21.3.2.3 Iterator support [string.iterators]

21.3.2.4 Capacity [string.capacity]

21.3.2.5 Element access [string.access]

21.3.2.6 Modifiers [string.modifiers]

21.3.2.6.1 basic_string::operator+= [string.op.append]

21.3.2.6.2 basic_string::append [string.append]

21.3.2.6.3 basic_string::assign [string.assign]

21.3.2.6.4 basic_string::insert [string.insert]

21.3.2.6.5 basic_string::erase [string.erase]

21.3.2.6.6 basic_string::replace [string.replace]

21.3.2.6.7 basic_string::copy [string.copy]

21.3.2.6.8 basic_string::swap [string.swap]

21.3.2.7 String operations [string.ops]

21.3.2.7.1 Accessors [string.accessors]

21.3.2.7.2 Searching [string.find]

21.3.2.7.3 basic_string::substr [string.substr]

21.3.2.7.4 basic_string::compare [string.compare]

21.3.2.7.5 basic_string::starts_with [string.starts.with]

21.3.2.7.6 basic_string::ends_with [string.ends.with]

21.3.3 Non-member functions [string.nonmembers]

21.3.3.1 operator+ [string.op.plus]

21.3.3.2 Non-member comparison functions [string.cmp]

21.3.3.3 swap [string.special]

21.3.3.4 Inserters and extractors [string.io]

21.3.3.5 Erasure [string.erasure]

21.3.4 Numeric conversions [string.conversions]

21.3.5 Hash support [basic.string.hash]

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

21.4 String view classes [string.view]

21.4.1 Header <string_view> synopsis [string.view.synop]

21.4.2 Class template basic_string_view [string.view.template]

21.4.2.1 Construction and assignment [string.view.cons]

21.4.2.2 Iterator support [string.view.iterators]

21.4.2.3 Capacity [string.view.capacity]

21.4.2.4 Element access [string.view.access]

21.4.2.5 Modifiers [string.view.modifiers]

21.4.2.6 String operations [string.view.ops]

21.4.2.7 Searching [string.view.find]

21.4.3 Deduction guide [string.view.deduct]

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

21.4.5 Inserters and extractors [string.view.io]

21.4.6 Hash support [string.view.hash]

21.4.7 Suffix for basic_string_view literals [string.view.literals]

21.5 Null-terminated sequence utilities [c.strings]

21.5.1 Header <cctype> synopsis [cctype.syn]

21.5.2 Header <cwctype> synopsis [cwctype.syn]

21.5.3 Header <cstring> synopsis [cstring.syn]

21.5.4 Header <cwchar> synopsis [cwchar.syn]

21.5.5 Header <cuchar> synopsis [cuchar.syn]

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

22 Containers library [containers][containers]

22.1 General [containers.general]

22.2 Container requirements [container.requirements]

22.2.1 General container requirements [container.requirements.general]

22.2.2 Container data races [container.requirements.dataraces]

22.2.3 Sequence containers [sequence.reqmts]

22.2.4 Node handles [container.node]

22.2.4.1 Overview [container.node.overview]

22.2.4.2 Constructors, copy, and assignment [container.node.cons]

22.2.4.3 Destructor [container.node.dtor]

22.2.4.4 Observers [container.node.observers]

22.2.4.5 Modifiers [container.node.modifiers]

22.2.5 Insert return type [container.insert.return]

22.2.6 Associative containers [associative.reqmts]

22.2.6.1 Exception safety guarantees [associative.reqmts.except]

22.2.7 Unordered associative containers [unord.req]

22.2.7.1 Exception safety guarantees [unord.req.except]

22.3 Sequence containers [sequences]

22.3.1 In general [sequences.general]

22.3.2 Header <array> synopsis [array.syn]

22.3.3 Header <deque> synopsis [deque.syn]

22.3.4 Header <forward_list> synopsis [forward.list.syn]

22.3.5 Header <list> synopsis [list.syn]

22.3.6 Header <vector> synopsis [vector.syn]

22.3.7 Class template array [array]

22.3.7.1 Overview [array.overview]

22.3.7.2 Constructors, copy, and assignment [array.cons]

22.3.7.3 Member functions [array.members]

22.3.7.4 Specialized algorithms [array.special]

22.3.7.5 Zero-sized arrays [array.zero]

22.3.7.6 Array creation functions [array.creation]

22.3.7.7 Tuple interface [array.tuple]

22.3.8 Class template deque [deque]

22.3.8.1 Overview [deque.overview]

22.3.8.2 Constructors, copy, and assignment [deque.cons]

22.3.8.3 Capacity [deque.capacity]

22.3.8.4 Modifiers [deque.modifiers]

22.3.8.5 Erasure [deque.erasure]

22.3.9 Class template forward_list [forwardlist]

22.3.9.1 Overview [forwardlist.overview]

22.3.9.2 Constructors, copy, and assignment [forwardlist.cons]

22.3.9.3 Iterators [forwardlist.iter]

22.3.9.4 Element access [forwardlist.access]

22.3.9.5 Modifiers [forwardlist.modifiers]

22.3.9.6 Operations [forwardlist.ops]

22.3.9.7 Erasure [forward.list.erasure]

22.3.10 Class template list [list]

22.3.10.1 Overview [list.overview]

22.3.10.2 Constructors, copy, and assignment [list.cons]

22.3.10.3 Capacity [list.capacity]

22.3.10.4 Modifiers [list.modifiers]

22.3.10.5 Operations [list.ops]

22.3.10.6 Erasure [list.erasure]

22.3.11 Class template vector [vector]

22.3.11.1 Overview [vector.overview]

22.3.11.2 Constructors, copy, and assignment [vector.cons]

22.3.11.3 Capacity [vector.capacity]

22.3.11.4 Data [vector.data]

22.3.11.5 Modifiers [vector.modifiers]

22.3.11.6 Erasure [vector.erasure]

22.3.12 Class vector<bool> [vector.bool]

22.4 Associative containers [associative]

22.4.1 In general [associative.general]

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

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

22.4.4 Class template map [map]

22.4.4.1 Overview [map.overview]

22.4.4.2 Constructors, copy, and assignment [map.cons]

22.4.4.3 Element access [map.access]

22.4.4.4 Modifiers [map.modifiers]

22.4.4.5 Erasure [map.erasure]

22.4.5 Class template multimap [multimap]

22.4.5.1 Overview [multimap.overview]

22.4.5.2 Constructors [multimap.cons]

22.4.5.3 Modifiers [multimap.modifiers]

22.4.5.4 Erasure [multimap.erasure]

22.4.6 Class template set [set]

22.4.6.1 Overview [set.overview]

22.4.6.2 Constructors, copy, and assignment [set.cons]

22.4.6.3 Erasure [set.erasure]

22.4.7 Class template multiset [multiset]

22.4.7.1 Overview [multiset.overview]

22.4.7.2 Constructors [multiset.cons]

22.4.7.3 Erasure [multiset.erasure]

22.5 Unordered associative containers [unord]

22.5.1 In general [unord.general]

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

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

22.5.4 Class template unordered_map [unord.map]

22.5.4.1 Overview [unord.map.overview]

22.5.4.2 Constructors [unord.map.cnstr]

22.5.4.3 Element access [unord.map.elem]

22.5.4.4 Modifiers [unord.map.modifiers]

22.5.4.5 Erasure [unord.map.erasure]

22.5.5 Class template unordered_multimap [unord.multimap]

22.5.5.1 Overview [unord.multimap.overview]

22.5.5.2 Constructors [unord.multimap.cnstr]

22.5.5.3 Modifiers [unord.multimap.modifiers]

22.5.5.4 Erasure [unord.multimap.erasure]

22.5.6 Class template unordered_set [unord.set]

22.5.6.1 Overview [unord.set.overview]

22.5.6.2 Constructors [unord.set.cnstr]

22.5.6.3 Erasure [unord.set.erasure]

22.5.7 Class template unordered_multiset [unord.multiset]

22.5.7.1 Overview [unord.multiset.overview]

22.5.7.2 Constructors [unord.multiset.cnstr]

22.5.7.3 Erasure [unord.multiset.erasure]

22.6 Container adaptors [container.adaptors]

22.6.1 In general [container.adaptors.general]

22.6.2 Header <queue> synopsis [queue.syn]

22.6.3 Header <stack> synopsis [stack.syn]

22.6.4 Class template queue [queue]

22.6.4.1 Definition [queue.defn]

22.6.4.2 Constructors [queue.cons]

22.6.4.3 Constructors with allocators [queue.cons.alloc]

22.6.4.4 Operators [queue.ops]

22.6.4.5 Specialized algorithms [queue.special]

22.6.5 Class template priority_queue [priority.queue]

22.6.5.1 Overview [priqueue.overview]

22.6.5.2 Constructors [priqueue.cons]

22.6.5.3 Constructors with allocators [priqueue.cons.alloc]

22.6.5.4 Members [priqueue.members]

22.6.5.5 Specialized algorithms [priqueue.special]

22.6.6 Class template stack [stack]

22.6.6.1 Definition [stack.defn]

22.6.6.2 Constructors [stack.cons]

22.6.6.3 Constructors with allocators [stack.cons.alloc]

22.6.6.4 Operators [stack.ops]

22.6.6.5 Specialized algorithms [stack.special]

22.7 Views [views]

22.7.1 General [views.general]

22.7.2 Header <span> synopsis [span.syn]

22.7.3 Class template span [views.span]

22.7.3.1 Overview [span.overview]

22.7.3.2 Constructors, copy, and assignment [span.cons]

22.7.3.3 Deduction guides [span.deduct]

22.7.3.4 Subviews [span.sub]

22.7.3.5 Observers [span.obs]

22.7.3.6 Element access [span.elem]

22.7.3.7 Iterator support [span.iterators]

22.7.3.8 Views of object representation [span.objectrep]

23 Iterators library [iterators][iterators]

23.1 General [iterators.general]

23.2 Header <iterator> synopsis [iterator.synopsis]

23.3 Iterator requirements [iterator.requirements]

23.3.1 In general [iterator.requirements.general]

23.3.2 Associated types [iterator.assoc.types]

23.3.2.1 Incrementable traits [incrementable.traits]

23.3.2.2 Indirectly readable traits [readable.traits]

23.3.2.3 Iterator traits [iterator.traits]

23.3.3 Customization point objects [iterator.cust]

23.3.3.1 ranges::iter_move [iterator.cust.move]

23.3.3.2 ranges::iter_swap [iterator.cust.swap]

23.3.4 Iterator concepts [iterator.concepts]

23.3.4.1 General [iterator.concepts.general]

23.3.4.2 Concept indirectly_readable [iterator.concept.readable]

23.3.4.3 Concept indirectly_writable [iterator.concept.writable]

23.3.4.4 Concept weakly_incrementable [iterator.concept.winc]

23.3.4.5 Concept incrementable [iterator.concept.inc]

23.3.4.6 Concept input_or_output_iterator [iterator.concept.iterator]

23.3.4.7 Concept sentinel_for [iterator.concept.sentinel]

23.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]

23.3.4.9 Concept input_iterator [iterator.concept.input]

23.3.4.10 Concept output_iterator [iterator.concept.output]

23.3.4.11 Concept forward_iterator [iterator.concept.forward]

23.3.4.12 Concept bidirectional_iterator [iterator.concept.bidir]

23.3.4.13 Concept random_access_iterator [iterator.concept.random.access]

23.3.4.14 Concept contiguous_iterator [iterator.concept.contiguous]

23.3.5 C++17 iterator requirements [iterator.cpp17]

23.3.5.1 Cpp17Iterator [iterator.iterators]

23.3.5.2 Input iterators [input.iterators]

23.3.5.3 Output iterators [output.iterators]

23.3.5.4 Forward iterators [forward.iterators]

23.3.5.5 Bidirectional iterators [bidirectional.iterators]

23.3.5.6 Random access iterators [random.access.iterators]

23.3.6 Indirect callable requirements [indirectcallable]

23.3.6.1 General [indirectcallable.general]

23.3.6.2 Indirect callables [indirectcallable.indirectinvocable]

23.3.6.3 Class template projected [projected]

23.3.7 Common algorithm requirements [alg.req]

23.3.7.1 General [alg.req.general]

23.3.7.2 Concept indirectly_movable [alg.req.ind.move]

23.3.7.3 Concept indirectly_copyable [alg.req.ind.copy]

23.3.7.4 Concept indirectly_swappable [alg.req.ind.swap]

23.3.7.5 Concept indirectly_comparable [alg.req.ind.cmp]

23.3.7.6 Concept permutable [alg.req.permutable]

23.3.7.7 Concept mergeable [alg.req.mergeable]

23.3.7.8 Concept sortable [alg.req.sortable]

23.4 Iterator primitives [iterator.primitives]

23.4.1 Standard iterator tags [std.iterator.tags]

23.4.2 Iterator operations [iterator.operations]

23.4.3 Range iterator operations [range.iter.ops]

23.4.3.1 ranges::advance [range.iter.op.advance]

23.4.3.2 ranges::distance [range.iter.op.distance]

23.4.3.3 ranges::next [range.iter.op.next]

23.4.3.4 ranges::prev [range.iter.op.prev]

23.5 Iterator adaptors [predef.iterators]

23.5.1 Reverse iterators [reverse.iterators]

23.5.1.1 Class template reverse_iterator [reverse.iterator]

23.5.1.2 Requirements [reverse.iter.requirements]

23.5.1.3 Construction and assignment [reverse.iter.cons]

23.5.1.4 Conversion [reverse.iter.conv]

23.5.1.5 Element access [reverse.iter.elem]

23.5.1.6 Navigation [reverse.iter.nav]

23.5.1.7 Comparisons [reverse.iter.cmp]

23.5.1.8 Non-member functions [reverse.iter.nonmember]

23.5.2 Insert iterators [insert.iterators]

23.5.2.1 Class template back_insert_iterator [back.insert.iterator]

23.5.2.1.1 Operations [back.insert.iter.ops]

23.5.2.1.2 back_inserter [back.inserter]

23.5.2.2 Class template front_insert_iterator [front.insert.iterator]

23.5.2.2.1 Operations [front.insert.iter.ops]

23.5.2.2.2 front_inserter [front.inserter]

23.5.2.3 Class template insert_iterator [insert.iterator]

23.5.2.3.1 Operations [insert.iter.ops]

23.5.2.3.2 inserter [inserter]

23.5.3 Move iterators and sentinels [move.iterators]

23.5.3.1 Class template move_iterator [move.iterator]

23.5.3.2 Requirements [move.iter.requirements]

23.5.3.3 Construction and assignment [move.iter.cons]

23.5.3.4 Conversion [move.iter.op.conv]

23.5.3.5 Element access [move.iter.elem]

23.5.3.6 Navigation [move.iter.nav]

23.5.3.7 Comparisons [move.iter.op.comp]

23.5.3.8 Non-member functions [move.iter.nonmember]

23.5.3.9 Class template move_sentinel [move.sentinel]

23.5.3.10 Operations [move.sent.ops]

23.5.4 Common iterators [iterators.common]

23.5.4.1 Class template common_iterator [common.iterator]

23.5.4.2 Associated types [common.iter.types]

23.5.4.3 Constructors and conversions [common.iter.const]

23.5.4.4 Accessors [common.iter.access]

23.5.4.5 Navigation [common.iter.nav]

23.5.4.6 Comparisons [common.iter.cmp]

23.5.4.7 Customizations [common.iter.cust]

23.5.5 Default sentinels [default.sentinels]

23.5.6 Counted iterators [iterators.counted]

23.5.6.1 Class template counted_iterator [counted.iterator]

23.5.6.2 Constructors and conversions [counted.iter.const]

23.5.6.3 Accessors [counted.iter.access]

23.5.6.4 Element access [counted.iter.elem]

23.5.6.5 Navigation [counted.iter.nav]

23.5.6.6 Comparisons [counted.iter.cmp]

23.5.6.7 Customizations [counted.iter.cust]

23.5.7 Unreachable sentinel [unreachable.sentinels]

23.5.7.1 Class unreachable_sentinel_t [unreachable.sentinel]

23.6 Stream iterators [stream.iterators]

23.6.1 Class template istream_iterator [istream.iterator]

23.6.1.1 Constructors and destructor [istream.iterator.cons]

23.6.1.2 Operations [istream.iterator.ops]

23.6.2 Class template ostream_iterator [ostream.iterator]

23.6.2.1 Constructors and destructor [ostream.iterator.cons.des]

23.6.2.2 Operations [ostream.iterator.ops]

23.6.3 Class template istreambuf_iterator [istreambuf.iterator]

23.6.3.1 Class istreambuf_iterator::proxy [istreambuf.iterator.proxy]

23.6.3.2 Constructors [istreambuf.iterator.cons]

23.6.3.3 Operations [istreambuf.iterator.ops]

23.6.4 Class template ostreambuf_iterator [ostreambuf.iterator]

23.6.4.1 Constructors [ostreambuf.iter.cons]

23.6.4.2 Operations [ostreambuf.iter.ops]

23.7 Range access [iterator.range]

24 Ranges library [ranges][ranges]

24.1 General [ranges.general]

24.2 Header <ranges> synopsis [ranges.syn]

24.3 Range access [range.access]

24.3.1 ranges::begin [range.access.begin]

24.3.2 ranges::end [range.access.end]

24.3.3 ranges::cbegin [range.access.cbegin]

24.3.4 ranges::cend [range.access.cend]

24.3.5 ranges::rbegin [range.access.rbegin]

24.3.6 ranges::rend [range.access.rend]

24.3.7 ranges::crbegin [range.access.crbegin]

24.3.8 ranges::crend [range.access.crend]

24.3.9 ranges::size [range.prim.size]

24.3.10 ranges::ssize [range.prim.ssize]

24.3.11 ranges::empty [range.prim.empty]

24.3.12 ranges::data [range.prim.data]

24.3.13 ranges::cdata [range.prim.cdata]

24.4 Range requirements [range.req]

24.4.1 General [range.req.general]

24.4.2 Ranges [range.range]

24.4.3 Sized ranges [range.sized]

24.4.4 Views [range.view]

24.5 Range utilities [range.utility]

24.5.1 Helper concepts [range.utility.helpers]

24.5.2 View interface [view.interface]

24.5.2.1 Members [view.interface.members]

24.5.3 Sub-ranges [range.subrange]

24.5.3.1 Constructors and conversions [range.subrange.ctor]

24.5.3.2 Accessors [range.subrange.access]

24.5.4 Dangling iterator handling [range.dangling]

24.6 Range factories [range.factories]

24.6.1 Empty view [range.empty]

24.6.1.1 Overview [range.empty.overview]

24.6.1.2 Class template empty_view [range.empty.view]

24.6.2 Single view [range.single]

24.6.2.1 Overview [range.single.overview]

24.6.2.2 Class template single_view [range.single.view]

24.6.3 Iota view [range.iota]

24.6.3.1 Overview [range.iota.overview]

24.6.3.2 Class template iota_view [range.iota.view]

24.6.3.3 Class iota_view::iterator [range.iota.iterator]

24.6.3.4 Class iota_view::sentinel [range.iota.sentinel]

24.6.4 Istream view [range.istream]

24.6.4.1 Overview [range.istream.overview]

24.6.4.2 Class template basic_istream_view [range.istream.view]

24.6.4.3 Class template basic_istream_view::iterator [range.istream.iterator]

24.7 Range adaptors [range.adaptors]

24.7.1 Range adaptor objects [range.adaptor.object]

24.7.2 Semiregular wrapper [range.semi.wrap]

24.7.3 All view [range.all]

24.7.3.1 Class template ref_view [range.ref.view]

24.7.4 Filter view [range.filter]

24.7.4.1 Overview [range.filter.overview]

24.7.4.2 Class template filter_view [range.filter.view]

24.7.4.3 Class filter_view::iterator [range.filter.iterator]

24.7.4.4 Class filter_view::sentinel [range.filter.sentinel]

24.7.5 Transform view [range.transform]

24.7.5.1 Overview [range.transform.overview]

24.7.5.2 Class template transform_view [range.transform.view]

24.7.5.3 Class template transform_view::iterator [range.transform.iterator]

24.7.5.4 Class template transform_view::sentinel [range.transform.sentinel]

24.7.6 Take view [range.take]

24.7.6.1 Overview [range.take.overview]

24.7.6.2 Class template take_view [range.take.view]

24.7.6.3 Class template take_view::sentinel [range.take.sentinel]

24.7.7 Take while view [range.take.while]

24.7.7.1 Overview [range.take.while.overview]

24.7.7.2 Class template take_while_view [range.take.while.view]

24.7.7.3 Class template take_while_view::sentinel [range.take.while.sentinel]

24.7.8 Drop view [range.drop]

24.7.8.1 Overview [range.drop.overview]

24.7.8.2 Class template drop_view [range.drop.view]

24.7.9 Drop while view [range.drop.while]

24.7.9.1 Overview [range.drop.while.overview]

24.7.9.2 Class template drop_while_view [range.drop.while.view]

24.7.10 Join view [range.join]

24.7.10.1 Overview [range.join.overview]

24.7.10.2 Class template join_view [range.join.view]

24.7.10.3 Class template join_view::iterator [range.join.iterator]

24.7.10.4 Class template join_view::sentinel [range.join.sentinel]

24.7.11 Split view [range.split]

24.7.11.1 Overview [range.split.overview]

24.7.11.2 Class template split_view [range.split.view]

24.7.11.3 Class template split_view::outer-iterator [range.split.outer]

24.7.11.4 Class split_view::outer-iterator::value_type [range.split.outer.value]

24.7.11.5 Class template split_view::inner-iterator [range.split.inner]

24.7.12 Counted view [range.counted]

24.7.13 Common view [range.common]

24.7.13.1 Overview [range.common.overview]

24.7.13.2 Class template common_view [range.common.view]

24.7.14 Reverse view [range.reverse]

24.7.14.1 Overview [range.reverse.overview]

24.7.14.2 Class template reverse_view [range.reverse.view]

24.7.15 Elements view [range.elements]

24.7.15.1 Overview [range.elements.overview]

24.7.15.2 Class template elements_view [range.elements.view]

24.7.15.3 Class template elements_view::iterator [range.elements.iterator]

24.7.15.4 Class template elements_view::sentinel [range.elements.sentinel]

25 Algorithms library [algorithms][algorithms]

25.1 General [algorithms.general]

25.2 Algorithms requirements [algorithms.requirements]

25.3 Parallel algorithms [algorithms.parallel]

25.3.1 Preamble [algorithms.parallel.defns]

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

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

25.3.4 Parallel algorithm exceptions [algorithms.parallel.exceptions]

25.3.5 ExecutionPolicy algorithm overloads [algorithms.parallel.overloads]

25.4 Header <algorithm> synopsis [algorithm.syn]

25.5 Algorithm result types [algorithms.results]

25.6 Non-modifying sequence operations [alg.nonmodifying]

25.6.1 All of [alg.all.of]

25.6.2 Any of [alg.any.of]

25.6.3 None of [alg.none.of]

25.6.4 For each [alg.foreach]

25.6.5 Find [alg.find]

25.6.6 Find end [alg.find.end]

25.6.7 Find first [alg.find.first.of]

25.6.8 Adjacent find [alg.adjacent.find]

25.6.9 Count [alg.count]

25.6.10 Mismatch [mismatch]

25.6.11 Equal [alg.equal]

25.6.12 Is permutation [alg.is.permutation]

25.6.13 Search [alg.search]

25.7 Mutating sequence operations [alg.modifying.operations]

25.7.1 Copy [alg.copy]

25.7.2 Move [alg.move]

25.7.3 Swap [alg.swap]

25.7.4 Transform [alg.transform]

25.7.5 Replace [alg.replace]

25.7.6 Fill [alg.fill]

25.7.7 Generate [alg.generate]

25.7.8 Remove [alg.remove]

25.7.9 Unique [alg.unique]

25.7.10 Reverse [alg.reverse]

25.7.11 Rotate [alg.rotate]

25.7.12 Sample [alg.random.sample]

25.7.13 Shuffle [alg.random.shuffle]

25.7.14 Shift [alg.shift]

25.8 Sorting and related operations [alg.sorting]

25.8.1 Sorting [alg.sort]

25.8.1.1 sort [sort]

25.8.1.2 stable_sort [stable.sort]

25.8.1.3 partial_sort [partial.sort]

25.8.1.4 partial_sort_copy [partial.sort.copy]

25.8.1.5 is_sorted [is.sorted]

25.8.2 Nth element [alg.nth.element]

25.8.3 Binary search [alg.binary.search]

25.8.3.1 lower_bound [lower.bound]

25.8.3.2 upper_bound [upper.bound]

25.8.3.3 equal_range [equal.range]

25.8.3.4 binary_search [binary.search]

25.8.4 Partitions [alg.partitions]

25.8.5 Merge [alg.merge]

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

25.8.6.1 includes [includes]

25.8.6.2 set_union [set.union]

25.8.6.3 set_intersection [set.intersection]

25.8.6.4 set_difference [set.difference]

25.8.6.5 set_symmetric_difference [set.symmetric.difference]

25.8.7 Heap operations [alg.heap.operations]

25.8.7.1 push_heap [push.heap]

25.8.7.2 pop_heap [pop.heap]

25.8.7.3 make_heap [make.heap]

25.8.7.4 sort_heap [sort.heap]

25.8.7.5 is_heap [is.heap]

25.8.8 Minimum and maximum [alg.min.max]

25.8.9 Bounded value [alg.clamp]

25.8.10 Lexicographical comparison [alg.lex.comparison]

25.8.11 Three-way comparison algorithms [alg.three.way]

25.8.12 Permutation generators [alg.permutation.generators]

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

25.10 Generalized numeric operations [numeric.ops]

25.10.1 Definitions [numerics.defns]

25.10.2 Accumulate [accumulate]

25.10.3 Reduce [reduce]

25.10.4 Inner product [inner.product]

25.10.5 Transform reduce [transform.reduce]

25.10.6 Partial sum [partial.sum]

25.10.7 Exclusive scan [exclusive.scan]

25.10.8 Inclusive scan [inclusive.scan]

25.10.9 Transform exclusive scan [transform.exclusive.scan]

25.10.10 Transform inclusive scan [transform.inclusive.scan]

25.10.11 Adjacent difference [adjacent.difference]

25.10.12 Iota [numeric.iota]

25.10.13 Greatest common divisor [numeric.ops.gcd]

25.10.14 Least common multiple [numeric.ops.lcm]

25.10.15 Midpoint [numeric.ops.midpoint]

25.11 Specialized <memory> algorithms [specialized.algorithms]

25.11.1 Special memory concepts [special.mem.concepts]

25.11.2 uninitialized_default_construct [uninitialized.construct.default]

25.11.3 uninitialized_value_construct [uninitialized.construct.value]

25.11.4 uninitialized_copy [uninitialized.copy]

25.11.5 uninitialized_move [uninitialized.move]

25.11.6 uninitialized_fill [uninitialized.fill]

25.11.7 construct_at [specialized.construct]

25.11.8 destroy [specialized.destroy]

25.12 C library algorithms [alg.c.library]

26 Numerics library [numerics][numerics]

26.1 General [numerics.general]

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 Specializations [complex.special]

26.4.4 Member functions [complex.members]

26.4.5 Member operators [complex.member.ops]

26.4.6 Non-member operations [complex.ops]

26.4.7 Value operations [complex.value.ops]

26.4.8 Transcendentals [complex.transcendentals]

26.4.9 Additional overloads [cmplx.over]

26.4.10 Suffixes for complex number literals [complex.literals]

26.5 Bit manipulation [bit]

26.5.1 General [bit.general]

26.5.2 Header <bit> synopsis [bit.syn]

26.5.3 Function template bit_cast [bit.cast]

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

26.5.5 Rotating [bit.rotate]

26.5.6 Counting [bit.count]

26.5.7 Endian [bit.endian]

26.6 Random number generation [rand]

26.6.1 Header <random> synopsis [rand.synopsis]

26.6.2 Requirements [rand.req]

26.6.2.1 General requirements [rand.req.genl]

26.6.2.2 Seed sequence requirements [rand.req.seedseq]

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

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

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

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

26.6.3 Random number engine class templates [rand.eng]

26.6.3.1 Class template linear_congruential_engine [rand.eng.lcong]

26.6.3.2 Class template mersenne_twister_engine [rand.eng.mers]

26.6.3.3 Class template subtract_with_carry_engine [rand.eng.sub]

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

26.6.4.1 In general [rand.adapt.general]

26.6.4.2 Class template discard_block_engine [rand.adapt.disc]

26.6.4.3 Class template independent_bits_engine [rand.adapt.ibits]

26.6.4.4 Class template shuffle_order_engine [rand.adapt.shuf]

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

26.6.6 Class random_device [rand.device]

26.6.7 Utilities [rand.util]

26.6.7.1 Class seed_seq [rand.util.seedseq]

26.6.7.2 Function template generate_canonical [rand.util.canonical]

26.6.8 Random number distribution class templates [rand.dist]

26.6.8.1 In general [rand.dist.general]

26.6.8.2 Uniform distributions [rand.dist.uni]

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

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

26.6.8.3 Bernoulli distributions [rand.dist.bern]

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

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

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

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

26.6.8.4 Poisson distributions [rand.dist.pois]

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

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

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

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

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

26.6.8.5 Normal distributions [rand.dist.norm]

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

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

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

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

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

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

26.6.8.6 Sampling distributions [rand.dist.samp]

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

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

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

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

26.7 Numeric arrays [numarray]

26.7.1 Header <valarray> synopsis [valarray.syn]

26.7.2 Class template valarray [template.valarray]

26.7.2.1 Overview [template.valarray.overview]

26.7.2.2 Constructors [valarray.cons]

26.7.2.3 Assignment [valarray.assign]

26.7.2.4 Element access [valarray.access]

26.7.2.5 Subset operations [valarray.sub]

26.7.2.6 Unary operators [valarray.unary]

26.7.2.7 Compound assignment [valarray.cassign]

26.7.2.8 Member functions [valarray.members]

26.7.3 valarray non-member operations [valarray.nonmembers]

26.7.3.1 Binary operators [valarray.binary]

26.7.3.2 Logical operators [valarray.comparison]

26.7.3.3 Transcendentals [valarray.transcend]

26.7.3.4 Specialized algorithms [valarray.special]

26.7.4 Class slice [class.slice]

26.7.4.1 Overview [class.slice.overview]

26.7.4.2 Constructors [cons.slice]

26.7.4.3 Access functions [slice.access]

26.7.4.4 Operators [slice.ops]

26.7.5 Class template slice_array [template.slice.array]

26.7.5.1 Overview [template.slice.array.overview]

26.7.5.2 Assignment [slice.arr.assign]

26.7.5.3 Compound assignment [slice.arr.comp.assign]

26.7.5.4 Fill function [slice.arr.fill]

26.7.6 The gslice class [class.gslice]

26.7.6.1 Overview [class.gslice.overview]

26.7.6.2 Constructors [gslice.cons]

26.7.6.3 Access functions [gslice.access]

26.7.7 Class template gslice_array [template.gslice.array]

26.7.7.1 Overview [template.gslice.array.overview]

26.7.7.2 Assignment [gslice.array.assign]

26.7.7.3 Compound assignment [gslice.array.comp.assign]

26.7.7.4 Fill function [gslice.array.fill]

26.7.8 Class template mask_array [template.mask.array]

26.7.8.1 Overview [template.mask.array.overview]

26.7.8.2 Assignment [mask.array.assign]

26.7.8.3 Compound assignment [mask.array.comp.assign]

26.7.8.4 Fill function [mask.array.fill]

26.7.9 Class template indirect_array [template.indirect.array]

26.7.9.1 Overview [template.indirect.array.overview]

26.7.9.2 Assignment [indirect.array.assign]

26.7.9.3 Compound assignment [indirect.array.comp.assign]

26.7.9.4 Fill function [indirect.array.fill]

26.7.10 valarray range access [valarray.range]

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

26.8.1 Header <cmath> synopsis [cmath.syn]

26.8.2 Absolute values [c.math.abs]

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

26.8.4 Linear interpolation [c.math.lerp]

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

26.8.6 Mathematical special functions [sf.cmath]

26.8.6.1 Associated Laguerre polynomials [sf.cmath.assoc.laguerre]

26.8.6.2 Associated Legendre functions [sf.cmath.assoc.legendre]

26.8.6.3 Beta function [sf.cmath.beta]

26.8.6.4 Complete elliptic integral of the first kind [sf.cmath.comp.ellint.1]

26.8.6.5 Complete elliptic integral of the second kind [sf.cmath.comp.ellint.2]

26.8.6.6 Complete elliptic integral of the third kind [sf.cmath.comp.ellint.3]

26.8.6.7 Regular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.i]

26.8.6.8 Cylindrical Bessel functions of the first kind [sf.cmath.cyl.bessel.j]

26.8.6.9 Irregular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.k]

26.8.6.10 Cylindrical Neumann functions [sf.cmath.cyl.neumann]

26.8.6.11 Incomplete elliptic integral of the first kind [sf.cmath.ellint.1]

26.8.6.12 Incomplete elliptic integral of the second kind [sf.cmath.ellint.2]

26.8.6.13 Incomplete elliptic integral of the third kind [sf.cmath.ellint.3]

26.8.6.14 Exponential integral [sf.cmath.expint]

26.8.6.15 Hermite polynomials [sf.cmath.hermite]

26.8.6.16 Laguerre polynomials [sf.cmath.laguerre]

26.8.6.17 Legendre polynomials [sf.cmath.legendre]

26.8.6.18 Riemann zeta function [sf.cmath.riemann.zeta]

26.8.6.19 Spherical Bessel functions of the first kind [sf.cmath.sph.bessel]

26.8.6.20 Spherical associated Legendre functions [sf.cmath.sph.legendre]

26.8.6.21 Spherical Neumann functions [sf.cmath.sph.neumann]

26.9 Numbers [numbers]

26.9.1 Header <numbers> synopsis [numbers.syn]

26.9.2 Mathematical constants [math.constants]

27 Time library [time][time]

27.1 General [time.general]

27.2 Header <chrono> synopsis [time.syn]

27.3 Cpp17Clock requirements [time.clock.req]

27.4 Time-related traits [time.traits]

27.4.1 treat_as_floating_point [time.traits.is.fp]

27.4.2 duration_values [time.traits.duration.values]

27.4.3 Specializations of common_type [time.traits.specializations]

27.4.4 Class template is_clock [time.traits.is.clock]

27.5 Class template duration [time.duration]

27.5.1 Constructors [time.duration.cons]

27.5.2 Observer [time.duration.observer]

27.5.3 Arithmetic [time.duration.arithmetic]

27.5.4 Special values [time.duration.special]

27.5.5 Non-member arithmetic [time.duration.nonmember]

27.5.6 Comparisons [time.duration.comparisons]

27.5.7 Conversions [time.duration.cast]

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

27.5.9 Algorithms [time.duration.alg]

27.5.10 I/O [time.duration.io]

27.6 Class template time_point [time.point]

27.6.1 Constructors [time.point.cons]

27.6.2 Observer [time.point.observer]

27.6.3 Arithmetic [time.point.arithmetic]

27.6.4 Special values [time.point.special]

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

27.6.6 Comparisons [time.point.comparisons]

27.6.7 Conversions [time.point.cast]

27.7 Clocks [time.clock]

27.7.1 Class system_clock [time.clock.system]

27.7.1.1 Overview [time.clock.system.overview]

27.7.1.2 Members [time.clock.system.members]

27.7.1.3 Non-member functions [time.clock.system.nonmembers]

27.7.2 Class utc_clock [time.clock.utc]

27.7.2.1 Overview [time.clock.utc.overview]

27.7.2.2 Member functions [time.clock.utc.members]

27.7.2.3 Non-member functions [time.clock.utc.nonmembers]

27.7.3 Class tai_clock [time.clock.tai]

27.7.3.1 Overview [time.clock.tai.overview]

27.7.3.2 Member functions [time.clock.tai.members]

27.7.3.3 Non-member functions [time.clock.tai.nonmembers]

27.7.4 Class gps_clock [time.clock.gps]

27.7.4.1 Overview [time.clock.gps.overview]

27.7.4.2 Member functions [time.clock.gps.members]

27.7.4.3 Non-member functions [time.clock.gps.nonmembers]

27.7.5 Type file_clock [time.clock.file]

27.7.5.1 Overview [time.clock.file.overview]

27.7.5.2 Member functions [time.clock.file.members]

27.7.5.3 Non-member functions [time.clock.file.nonmembers]

27.7.6 Class steady_clock [time.clock.steady]

27.7.7 Class high_resolution_clock [time.clock.hires]

27.7.8 Local time [time.clock.local]

27.7.9 time_point conversions [time.clock.cast]

27.7.9.1 Class template clock_time_conversion [time.clock.conv]

27.7.9.2 Identity conversions [time.clock.cast.id]

27.7.9.3 Conversions between system_clock and utc_clock [time.clock.cast.sys.utc]

27.7.9.4 Conversions between system_clock and other clocks [time.clock.cast.sys]

27.7.9.5 Conversions between utc_clock and other clocks [time.clock.cast.utc]

27.7.9.6 Function template clock_cast [time.clock.cast.fn]

27.8 The civil calendar [time.cal]

27.8.1 In general [time.cal.general]

27.8.2 Class last_spec [time.cal.last]

27.8.3 Class day [time.cal.day]

27.8.3.1 Overview [time.cal.day.overview]

27.8.3.2 Member functions [time.cal.day.members]

27.8.3.3 Non-member functions [time.cal.day.nonmembers]

27.8.4 Class month [time.cal.month]

27.8.4.1 Overview [time.cal.month.overview]

27.8.4.2 Member functions [time.cal.month.members]

27.8.4.3 Non-member functions [time.cal.month.nonmembers]

27.8.5 Class year [time.cal.year]

27.8.5.1 Overview [time.cal.year.overview]

27.8.5.2 Member functions [time.cal.year.members]

27.8.5.3 Non-member functions [time.cal.year.nonmembers]

27.8.6 Class weekday [time.cal.wd]

27.8.6.1 Overview [time.cal.wd.overview]

27.8.6.2 Member functions [time.cal.wd.members]

27.8.6.3 Non-member functions [time.cal.wd.nonmembers]

27.8.7 Class weekday_indexed [time.cal.wdidx]

27.8.7.1 Overview [time.cal.wdidx.overview]

27.8.7.2 Member functions [time.cal.wdidx.members]

27.8.7.3 Non-member functions [time.cal.wdidx.nonmembers]

27.8.8 Class weekday_last [time.cal.wdlast]

27.8.8.1 Overview [time.cal.wdlast.overview]

27.8.8.2 Member functions [time.cal.wdlast.members]

27.8.8.3 Non-member functions [time.cal.wdlast.nonmembers]

27.8.9 Class month_day [time.cal.md]

27.8.9.1 Overview [time.cal.md.overview]

27.8.9.2 Member functions [time.cal.md.members]

27.8.9.3 Non-member functions [time.cal.md.nonmembers]

27.8.10 Class month_day_last [time.cal.mdlast]

27.8.11 Class month_weekday [time.cal.mwd]

27.8.11.1 Overview [time.cal.mwd.overview]

27.8.11.2 Member functions [time.cal.mwd.members]

27.8.11.3 Non-member functions [time.cal.mwd.nonmembers]

27.8.12 Class month_weekday_last [time.cal.mwdlast]

27.8.12.1 Overview [time.cal.mwdlast.overview]

27.8.12.2 Member functions [time.cal.mwdlast.members]

27.8.12.3 Non-member functions [time.cal.mwdlast.nonmembers]

27.8.13 Class year_month [time.cal.ym]

27.8.13.1 Overview [time.cal.ym.overview]

27.8.13.2 Member functions [time.cal.ym.members]

27.8.13.3 Non-member functions [time.cal.ym.nonmembers]

27.8.14 Class year_month_day [time.cal.ymd]

27.8.14.1 Overview [time.cal.ymd.overview]

27.8.14.2 Member functions [time.cal.ymd.members]

27.8.14.3 Non-member functions [time.cal.ymd.nonmembers]

27.8.15 Class year_month_day_last [time.cal.ymdlast]

27.8.15.1 Overview [time.cal.ymdlast.overview]

27.8.15.2 Member functions [time.cal.ymdlast.members]

27.8.15.3 Non-member functions [time.cal.ymdlast.nonmembers]

27.8.16 Class year_month_weekday [time.cal.ymwd]

27.8.16.1 Overview [time.cal.ymwd.overview]

27.8.16.2 Member functions [time.cal.ymwd.members]

27.8.16.3 Non-member functions [time.cal.ymwd.nonmembers]

27.8.17 Class year_month_weekday_last [time.cal.ymwdlast]

27.8.17.1 Overview [time.cal.ymwdlast.overview]

27.8.17.2 Member functions [time.cal.ymwdlast.members]

27.8.17.3 Non-member functions [time.cal.ymwdlast.nonmembers]

27.8.18 Conventional syntax operators [time.cal.operators]

27.9 Class template hh_mm_ss [time.hms]

27.9.1 Overview [time.hms.overview]

27.9.2 Members [time.hms.members]

27.9.3 Non-members [time.hms.nonmembers]

27.10 12/24 hours functions [time.12]

27.11 Time zones [time.zone]

27.11.1 In general [time.zone.general]

27.11.2 Time zone database [time.zone.db]

27.11.2.1 Class tzdb [time.zone.db.tzdb]

27.11.2.2 Class tzdb_list [time.zone.db.list]

27.11.2.3 Time zone database access [time.zone.db.access]

27.11.2.4 Remote time zone database support [time.zone.db.remote]

27.11.3 Exception classes [time.zone.exception]

27.11.3.1 Class nonexistent_local_time [time.zone.exception.nonexist]

27.11.3.2 Class ambiguous_local_time [time.zone.exception.ambig]

27.11.4 Information classes [time.zone.info]

27.11.4.1 Class sys_info [time.zone.info.sys]

27.11.4.2 Class local_info [time.zone.info.local]

27.11.5 Class time_zone [time.zone.timezone]

27.11.5.1 Overview [time.zone.overview]

27.11.5.2 Member functions [time.zone.members]

27.11.5.3 Non-member functions [time.zone.nonmembers]

27.11.6 Class template zoned_traits [time.zone.zonedtraits]

27.11.7 Class template zoned_time [time.zone.zonedtime]

27.11.7.1 Overview [time.zone.zonedtime.overview]

27.11.7.2 Constructors [time.zone.zonedtime.ctor]

27.11.7.3 Member functions [time.zone.zonedtime.members]

27.11.7.4 Non-member functions [time.zone.zonedtime.nonmembers]

27.11.8 Class leap_second [time.zone.leap]

27.11.8.1 Overview [time.zone.leap.overview]

27.11.8.2 Member functions [time.zone.leap.members]

27.11.8.3 Non-member functions [time.zone.leap.nonmembers]

27.11.9 Class time_zone_link [time.zone.link]

27.11.9.1 Overview [time.zone.link.overview]

27.11.9.2 Member functions [time.zone.link.members]

27.11.9.3 Non-member functions [time.zone.link.nonmembers]

27.12 Formatting [time.format]

27.13 Parsing [time.parse]

27.14 Header <ctime> synopsis [ctime.syn]

28 Localization library [localization][localization]

28.1 General [localization.general]

28.2 Header <locale> synopsis [locale.syn]

28.3 Locales [locales]

28.3.1 Class locale [locale]

28.3.1.1 Types [locale.types]

28.3.1.1.1 Type locale::category [locale.category]

28.3.1.1.3 Class locale::id [locale.id]

28.3.1.2 Constructors and destructor [locale.cons]

28.3.1.3 Members [locale.members]

28.3.1.4 Operators [locale.operators]

28.3.1.5 Static members [locale.statics]

28.3.2 locale globals [locale.global.templates]

28.3.3 Convenience interfaces [locale.convenience]

28.3.3.1 Character classification [classification]

28.3.3.2 Conversions [conversions]

28.3.3.2.1 Character conversions [conversions.character]

28.4 Standard locale categories [locale.categories]

28.4.1 The ctype category [category.ctype]

28.4.1.1 Class template ctype [locale.ctype]

28.4.1.1.1 ctype members [locale.ctype.members]

28.4.1.1.2 ctype virtual functions [locale.ctype.virtuals]

28.4.1.2 Class template ctype_byname [locale.ctype.byname]

28.4.1.4 Class template codecvt [locale.codecvt]

28.4.1.4.1 Members [locale.codecvt.members]

28.4.1.4.2 Virtual functions [locale.codecvt.virtuals]

28.4.1.5 Class template codecvt_byname [locale.codecvt.byname]

28.4.2 The numeric category [category.numeric]

28.4.2.1 Class template num_get [locale.num.get]

28.4.2.2 Class template num_put [locale.nm.put]

28.4.4 The collate category [category.collate]

28.4.4.1 Class template collate [locale.collate]

28.4.4.1.1 Members [locale.collate.members]

28.4.4.1.2 Virtual functions [locale.collate.virtuals]

28.4.4.2 Class template collate_byname [locale.collate.byname]

28.4.5 The time category [category.time]

28.4.5.1 Class template time_get [locale.time.get]

28.4.5.1.1 Members [locale.time.get.members]

28.4.5.1.2 Virtual functions [locale.time.get.virtuals]

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

28.4.5.3 Class template time_put [locale.time.put]

28.4.5.3.1 Members [locale.time.put.members]

28.4.5.3.2 Virtual functions [locale.time.put.virtuals]

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

28.4.6 The monetary category [category.monetary]

28.4.6.1 Class template money_get [locale.money.get]

28.4.6.1.1 Members [locale.money.get.members]

28.4.6.1.2 Virtual functions [locale.money.get.virtuals]

28.4.6.2 Class template money_put [locale.money.put]

28.4.6.2.1 Members [locale.money.put.members]

28.4.6.2.2 Virtual functions [locale.money.put.virtuals]

28.4.6.3 Class template moneypunct [locale.moneypunct]

28.4.6.3.1 Members [locale.moneypunct.members]

28.4.6.3.2 Virtual functions [locale.moneypunct.virtuals]

28.4.6.4 Class template moneypunct_byname [locale.moneypunct.byname]

28.4.7 The message retrieval category [category.messages]

28.4.7.1 Class template messages [locale.messages]

28.4.7.1.1 Members [locale.messages.members]

28.4.7.1.2 Virtual functions [locale.messages.virtuals]

28.4.7.2 Class template messages_byname [locale.messages.byname]

28.5 C library locales [c.locales]

28.5.1 Header <clocale> synopsis [clocale.syn]

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

29.1 General [input.output.general]

29.2 Iostreams requirements [iostreams.requirements]

29.2.1 Imbue limitations [iostream.limits.imbue]

29.2.2 Positioning type limitations [iostreams.limits.pos]

29.2.3 Thread safety [iostreams.threadsafety]

29.3 Forward declarations [iostream.forward]

29.3.1 Header <iosfwd> synopsis [iosfwd.syn]

29.3.2 Overview [iostream.forward.overview]

29.4 Standard iostream objects [iostream.objects]

29.4.1 Header <iostream> synopsis [iostream.syn]

29.4.2 Overview [iostream.objects.overview]

29.4.3 Narrow stream objects [narrow.stream.objects]

29.4.4 Wide stream objects [wide.stream.objects]

29.5 Iostreams base classes [iostreams.base]

29.5.1 Header <ios> synopsis [ios.syn]

29.5.2 Types [stream.types]

29.5.3 Class ios_base [ios.base]

29.5.3.1 Types [ios.types]

29.5.3.1.1 Class ios_base::failure [ios.failure]

29.5.3.1.2 Type ios_base::fmtflags [ios.fmtflags]

29.5.3.1.3 Type ios_base::iostate [ios.iostate]

29.5.3.1.4 Type ios_base::openmode [ios.openmode]

29.5.3.1.5 Type ios_base::seekdir [ios.seekdir]

29.5.3.1.6 Class ios_base::Init [ios.init]

29.5.3.2 State functions [fmtflags.state]

29.5.3.3 Functions [ios.base.locales]

29.5.3.4 Static members [ios.members.static]

29.5.3.5 Storage functions [ios.base.storage]

29.5.3.6 Callbacks [ios.base.callback]

29.5.3.7 Constructors and destructor [ios.base.cons]

29.5.4 Class template fpos [fpos]

29.5.4.1 Members [fpos.members]

29.5.4.2 Requirements [fpos.operations]

29.5.5 Class template basic_ios [ios]

29.5.5.1 Overview [ios.overview]

29.5.5.2 Constructors [basic.ios.cons]

29.5.5.3 Member functions [basic.ios.members]

29.5.5.4 Flags functions [iostate.flags]

29.5.6 ios_base manipulators [std.ios.manip]

29.5.6.1 fmtflags manipulators [fmtflags.manip]

29.5.6.2 adjustfield manipulators [adjustfield.manip]

29.5.6.3 basefield manipulators [basefield.manip]

29.5.6.4 floatfield manipulators [floatfield.manip]

29.5.7 Error reporting [error.reporting]

29.6 Stream buffers [stream.buffers]

29.6.1 Header <streambuf> synopsis [streambuf.syn]

29.6.2 Stream buffer requirements [streambuf.reqts]

29.6.3 Class template basic_streambuf [streambuf]

29.6.3.1 Constructors [streambuf.cons]

29.6.3.2 Public member functions [streambuf.members]

29.6.3.2.1 Locales [streambuf.locales]

29.6.3.2.2 Buffer management and positioning [streambuf.buffer]

29.6.3.2.3 Get area [streambuf.pub.get]

29.6.3.2.4 Putback [streambuf.pub.pback]

29.6.3.2.5 Put area [streambuf.pub.put]

29.6.3.3 Protected member functions [streambuf.protected]

29.6.3.3.1 Assignment [streambuf.assign]

29.6.3.3.2 Get area access [streambuf.get.area]

29.6.3.3.3 Put area access [streambuf.put.area]

29.6.3.4 Virtual functions [streambuf.virtuals]

29.6.3.4.1 Locales [streambuf.virt.locales]

29.6.3.4.2 Buffer management and positioning [streambuf.virt.buffer]

29.6.3.4.3 Get area [streambuf.virt.get]

29.6.3.4.4 Putback [streambuf.virt.pback]

29.6.3.4.5 Put area [streambuf.virt.put]

29.7 Formatting and manipulators [iostream.format]

29.7.1 Header <istream> synopsis [istream.syn]

29.7.2 Header <ostream> synopsis [ostream.syn]

29.7.3 Header <iomanip> synopsis [iomanip.syn]

29.7.4 Input streams [input.streams]

29.7.4.1 Class template basic_istream [istream]

29.7.4.1.1 Constructors [istream.cons]

29.7.4.1.2 Assignment and swap [istream.assign]

29.7.4.1.3 Class basic_istream::sentry [istream.sentry]

29.7.4.2 Formatted input functions [istream.formatted]

29.7.4.2.1 Common requirements [istream.formatted.reqmts]

29.7.4.2.2 Arithmetic extractors [istream.formatted.arithmetic]

29.7.4.2.3 basic_istream::operator>> [istream.extractors]

29.7.4.3 Unformatted input functions [istream.unformatted]

29.7.4.4 Standard basic_istream manipulators [istream.manip]

29.7.4.5 Rvalue stream extraction [istream.rvalue]

29.7.4.6 Class template basic_iostream [iostreamclass]

29.7.4.6.1 Constructors [iostream.cons]

29.7.4.6.2 Destructor [iostream.dest]

29.7.4.6.3 Assignment and swap [iostream.assign]

29.7.5 Output streams [output.streams]

29.7.5.1 Class template basic_ostream [ostream]

29.7.5.1.1 Constructors [ostream.cons]

29.7.5.1.2 Assignment and swap [ostream.assign]

29.7.5.1.3 Class basic_ostream::sentry [ostream.sentry]

29.7.5.1.4 Seek members [ostream.seeks]

29.7.5.2 Formatted output functions [ostream.formatted]

29.7.5.2.1 Common requirements [ostream.formatted.reqmts]

29.7.5.2.2 Arithmetic inserters [ostream.inserters.arithmetic]

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

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

29.7.5.3 Unformatted output functions [ostream.unformatted]

29.7.5.4 Standard manipulators [ostream.manip]

29.7.5.5 Rvalue stream insertion [ostream.rvalue]

29.7.6 Standard manipulators [std.manip]

29.7.7 Extended manipulators [ext.manip]

29.7.8 Quoted manipulators [quoted.manip]

29.8 String-based streams [string.streams]

29.8.1 Header <sstream> synopsis [sstream.syn]

29.8.2 Class template basic_stringbuf [stringbuf]

29.8.2.1 Constructors [stringbuf.cons]

29.8.2.2 Assignment and swap [stringbuf.assign]

29.8.2.3 Member functions [stringbuf.members]

29.8.2.4 Overridden virtual functions [stringbuf.virtuals]

29.8.3 Class template basic_istringstream [istringstream]

29.8.3.1 Constructors [istringstream.cons]

29.8.3.2 Assignment and swap [istringstream.assign]

29.8.3.3 Member functions [istringstream.members]

29.8.4 Class template basic_ostringstream [ostringstream]

29.8.4.1 Constructors [ostringstream.cons]

29.8.4.2 Assignment and swap [ostringstream.assign]

29.8.4.3 Member functions [ostringstream.members]

29.8.5 Class template basic_stringstream [stringstream]

29.8.5.1 Constructors [stringstream.cons]

29.8.5.2 Assignment and swap [stringstream.assign]

29.8.5.3 Member functions [stringstream.members]

29.9 File-based streams [file.streams]

29.9.1 Header <fstream> synopsis [fstream.syn]

29.9.2 Class template basic_filebuf [filebuf]

29.9.2.1 Constructors [filebuf.cons]

29.9.2.2 Assignment and swap [filebuf.assign]

29.9.2.3 Member functions [filebuf.members]

29.9.2.4 Overridden virtual functions [filebuf.virtuals]

29.9.3 Class template basic_ifstream [ifstream]

29.9.3.1 Constructors [ifstream.cons]

29.9.3.2 Assignment and swap [ifstream.assign]

29.9.3.3 Member functions [ifstream.members]

29.9.4 Class template basic_ofstream [ofstream]

29.9.4.1 Constructors [ofstream.cons]

29.9.4.2 Assignment and swap [ofstream.assign]

29.9.4.3 Member functions [ofstream.members]

29.9.5 Class template basic_fstream [fstream]

29.9.5.1 Constructors [fstream.cons]

29.9.5.2 Assignment and swap [fstream.assign]

29.9.5.3 Member functions [fstream.members]

29.10 Synchronized output streams [syncstream]

29.10.1 Header <syncstream> synopsis [syncstream.syn]

29.10.2 Class template basic_syncbuf [syncstream.syncbuf]

29.10.2.1 Overview [syncstream.syncbuf.overview]

29.10.2.2 Construction and destruction [syncstream.syncbuf.cons]

29.10.2.3 Assignment and swap [syncstream.syncbuf.assign]

29.10.2.4 Member functions [syncstream.syncbuf.members]

29.10.2.5 Overridden virtual functions [syncstream.syncbuf.virtuals]

29.10.2.6 Specialized algorithms [syncstream.syncbuf.special]

29.10.3 Class template basic_osyncstream [syncstream.osyncstream]

29.10.3.1 Overview [syncstream.osyncstream.overview]

29.10.3.2 Construction and destruction [syncstream.osyncstream.cons]

29.10.3.3 Member functions [syncstream.osyncstream.members]

29.11 File systems [filesystems]

29.11.1 General [fs.general]

29.11.2 Conformance [fs.conformance]

29.11.2.1 POSIX conformance [fs.conform.9945]

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

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

29.11.3 Normative references [fs.norm.ref]

29.11.4 Requirements [fs.req]

29.11.4.1 Namespaces and headers [fs.req.namespace]

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

29.11.6 Error reporting [fs.err.report]

29.11.7 Class path [fs.class.path]

29.11.7.1 Generic pathname format [fs.path.generic]

29.11.7.2 Conversions [fs.path.cvt]

29.11.7.2.1 Argument format conversions [fs.path.fmt.cvt]

29.11.7.2.2 Type and encoding conversions [fs.path.type.cvt]

29.11.7.3 Requirements [fs.path.req]

29.11.7.4 Members [fs.path.member]

29.11.7.4.1 Constructors [fs.path.construct]

29.11.7.4.2 Assignments [fs.path.assign]

29.11.7.4.3 Appends [fs.path.append]

29.11.7.4.4 Concatenation [fs.path.concat]

29.11.7.4.5 Modifiers [fs.path.modifiers]

29.11.7.4.6 Native format observers [fs.path.native.obs]

29.11.7.4.7 Generic format observers [fs.path.generic.obs]

29.11.7.4.8 Compare [fs.path.compare]

29.11.7.4.9 Decomposition [fs.path.decompose]

29.11.7.4.10 Query [fs.path.query]

29.11.7.4.11 Generation [fs.path.gen]

29.11.7.5 Iterators [fs.path.itr]

29.11.7.6 Inserter and extractor [fs.path.io]

29.11.7.7 Non-member functions [fs.path.nonmember]

29.11.8 Class filesystem_error [fs.class.filesystem.error]

29.11.8.1 Members [fs.filesystem.error.members]

29.11.9 Enumerations [fs.enum]

29.11.9.1 Enum path::format [fs.enum.path.format]

29.11.9.2 Enum class file_type [fs.enum.file.type]

29.11.9.3 Enum class copy_options [fs.enum.copy.opts]

29.11.9.4 Enum class perms [fs.enum.perms]

29.11.9.5 Enum class perm_options [fs.enum.perm.opts]

29.11.9.6 Enum class directory_options [fs.enum.dir.opts]

29.11.10 Class file_status [fs.class.file.status]

29.11.10.1 Constructors [fs.file.status.cons]

29.11.10.2 Observers [fs.file.status.obs]

29.11.10.3 Modifiers [fs.file.status.mods]

29.11.11 Class directory_entry [fs.class.directory.entry]

29.11.11.1 Constructors [fs.dir.entry.cons]

29.11.11.2 Modifiers [fs.dir.entry.mods]

29.11.11.3 Observers [fs.dir.entry.obs]

29.11.12 Class directory_iterator [fs.class.directory.iterator]

29.11.12.1 Members [fs.dir.itr.members]

29.11.12.2 Non-member functions [fs.dir.itr.nonmembers]

29.11.13 Class recursive_directory_iterator [fs.class.rec.dir.itr]

29.11.13.1 Members [fs.rec.dir.itr.members]

29.11.13.2 Non-member functions [fs.rec.dir.itr.nonmembers]

29.11.14 Filesystem operation functions [fs.op.funcs]

29.11.14.1 Absolute [fs.op.absolute]

29.11.14.2 Canonical [fs.op.canonical]

29.11.14.3 Copy [fs.op.copy]

29.11.14.4 Copy file [fs.op.copy.file]

29.11.14.5 Copy symlink [fs.op.copy.symlink]

29.11.14.6 Create directories [fs.op.create.directories]

29.11.14.7 Create directory [fs.op.create.directory]

29.11.14.8 Create directory symlink [fs.op.create.dir.symlk]

29.11.14.9 Create hard link [fs.op.create.hard.lk]

29.11.14.10 Create symlink [fs.op.create.symlink]

29.11.14.11 Current path [fs.op.current.path]

29.11.14.12 Equivalent [fs.op.equivalent]

29.11.14.13 Exists [fs.op.exists]

29.11.14.14 File size [fs.op.file.size]

29.11.14.15 Hard link count [fs.op.hard.lk.ct]

29.11.14.16 Is block file [fs.op.is.block.file]

29.11.14.17 Is character file [fs.op.is.char.file]

29.11.14.18 Is directory [fs.op.is.directory]

29.11.14.19 Is empty [fs.op.is.empty]

29.11.14.20 Is fifo [fs.op.is.fifo]

29.11.14.21 Is other [fs.op.is.other]

29.11.14.22 Is regular file [fs.op.is.regular.file]

29.11.14.23 Is socket [fs.op.is.socket]

29.11.14.24 Is symlink [fs.op.is.symlink]

29.11.14.25 Last write time [fs.op.last.write.time]

29.11.14.26 Permissions [fs.op.permissions]

29.11.14.27 Proximate [fs.op.proximate]

29.11.14.28 Read symlink [fs.op.read.symlink]

29.11.14.29 Relative [fs.op.relative]

29.11.14.30 Remove [fs.op.remove]

29.11.14.31 Remove all [fs.op.remove.all]

29.11.14.32 Rename [fs.op.rename]

29.11.14.33 Resize file [fs.op.resize.file]

29.11.14.34 Space [fs.op.space]

29.11.14.35 Status [fs.op.status]

29.11.14.36 Status known [fs.op.status.known]

29.11.14.37 Symlink status [fs.op.symlink.status]

29.11.14.38 Temporary directory path [fs.op.temp.dir.path]

29.11.14.39 Weakly canonical [fs.op.weakly.canonical]

29.12 C library files [c.files]

29.12.1 Header <cstdio> synopsis [cstdio.syn]

29.12.2 Header <cinttypes> synopsis [cinttypes.syn]

30 Regular expressions library [re][re]

30.1 General [re.general]

30.2 Definitions [re.def]

30.3 Requirements [re.req]

30.4 Header <regex> synopsis [re.syn]

30.5 Namespace std::regex_constants [re.const]

30.5.1 Bitmask type syntax_option_type [re.synopt]

30.5.2 Bitmask type match_flag_type [re.matchflag]

30.5.3 Implementation-defined error_type [re.err]

30.6 Class regex_error [re.badexp]

30.7 Class template regex_traits [re.traits]

30.8 Class template basic_regex [re.regex]

30.8.1 Constructors [re.regex.construct]

30.8.2 Assignment [re.regex.assign]

30.8.3 Constant operations [re.regex.operations]

30.8.4 Locale [re.regex.locale]

30.8.5 Swap [re.regex.swap]

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

30.9 Class template sub_match [re.submatch]

30.9.1 Members [re.submatch.members]

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

30.10 Class template match_results [re.results]

30.10.1 Constructors [re.results.const]

30.10.2 State [re.results.state]

30.10.3 Size [re.results.size]

30.10.4 Element access [re.results.acc]

30.10.5 Formatting [re.results.form]

30.10.6 Allocator [re.results.all]

30.10.7 Swap [re.results.swap]

30.10.8 Non-member functions [re.results.nonmember]

30.11 Regular expression algorithms [re.alg]

30.11.1 Exceptions [re.except]

30.11.2 regex_match [re.alg.match]

30.11.3 regex_search [re.alg.search]

30.11.4 regex_replace [re.alg.replace]

30.12 Regular expression iterators [re.iter]

30.12.1 Class template regex_iterator [re.regiter]

30.12.1.1 Constructors [re.regiter.cnstr]

30.12.1.2 Comparisons [re.regiter.comp]

30.12.1.3 Indirection [re.regiter.deref]

30.12.1.4 Increment [re.regiter.incr]

30.12.2 Class template regex_token_iterator [re.tokiter]

30.12.2.1 Constructors [re.tokiter.cnstr]

30.12.2.2 Comparisons [re.tokiter.comp]

30.12.2.3 Indirection [re.tokiter.deref]

30.12.2.4 Increment [re.tokiter.incr]

30.13 Modified ECMAScript regular expression grammar [re.grammar]

31 Atomic operations library [atomics][atomics]

31.1 General [atomics.general]

31.2 Header <atomic> synopsis [atomics.syn]

31.3 Type aliases [atomics.alias]

31.4 Order and consistency [atomics.order]

31.5 Lock-free property [atomics.lockfree]

31.6 Waiting and notifying [atomics.wait]

31.7 Class template atomic_ref [atomics.ref.generic]

31.7.1 Operations [atomics.ref.ops]

31.7.2 Specializations for integral types [atomics.ref.int]

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

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

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

31.8 Class template atomic [atomics.types.generic]

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

31.8.2 Specializations for integers [atomics.types.int]

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

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

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

31.8.6 Partial specializations for smart pointers [util.smartptr.atomic]

31.8.6.1 Partial specialization for shared_ptr [util.smartptr.atomic.shared]

31.8.6.2 Partial specialization for weak_ptr [util.smartptr.atomic.weak]

31.9 Non-member functions [atomics.nonmembers]

31.10 Flag type and operations [atomics.flag]

31.11 Fences [atomics.fences]

32 Thread support library [thread][thread]

32.1 General [thread.general]

32.2 Requirements [thread.req]

32.2.1 Template parameter names [thread.req.paramname]

32.2.2 Exceptions [thread.req.exception]

32.2.3 Native handles [thread.req.native]

32.2.4 Timing specifications [thread.req.timing]

32.2.5 Requirements for Cpp17Lockable types [thread.req.lockable]

32.2.5.1 In general [thread.req.lockable.general]

32.2.5.2 Cpp17BasicLockable requirements [thread.req.lockable.basic]

32.2.5.3 Cpp17Lockable requirements [thread.req.lockable.req]

32.2.5.4 Cpp17TimedLockable requirements [thread.req.lockable.timed]

32.3 Stop tokens [thread.stoptoken]

32.3.1 Introduction [thread.stoptoken.intro]

32.3.2 Header <stop_token> synopsis [thread.stoptoken.syn]

32.3.3 Class stop_token [stoptoken]

32.3.3.1 Constructors, copy, and assignment [stoptoken.cons]

32.3.3.2 Members [stoptoken.mem]

32.3.3.3 Non-member functions [stoptoken.nonmembers]

32.3.4 Class stop_source [stopsource]

32.3.4.1 Constructors, copy, and assignment [stopsource.cons]

32.3.4.2 Members [stopsource.mem]

32.3.4.3 Non-member functions [stopsource.nonmembers]

32.3.5 Class template stop_callback [stopcallback]

32.3.5.1 Constructors and destructor [stopcallback.cons]

32.4 Threads [thread.threads]

32.4.1 Header <thread> synopsis [thread.syn]

32.4.2 Class thread [thread.thread.class]

32.4.2.1 Class thread::id [thread.thread.id]

32.4.2.2 Constructors [thread.thread.constr]

32.4.2.3 Destructor [thread.thread.destr]

32.4.2.4 Assignment [thread.thread.assign]

32.4.2.5 Members [thread.thread.member]

32.4.2.6 Static members [thread.thread.static]

32.4.2.7 Specialized algorithms [thread.thread.algorithm]

32.4.3 Class jthread [thread.jthread.class]

32.4.3.1 Constructors, move, and assignment [thread.jthread.cons]

32.4.3.2 Members [thread.jthread.mem]

32.4.3.3 Stop token handling [thread.jthread.stop]

32.4.3.4 Specialized algorithms [thread.jthread.special]

32.4.3.5 Static members [thread.jthread.static]

32.4.4 Namespace this_thread [thread.thread.this]

32.5 Mutual exclusion [thread.mutex]

32.5.1 Header <mutex> synopsis [mutex.syn]

32.5.2 Header <shared_mutex> synopsis [shared.mutex.syn]

32.5.3 Mutex requirements [thread.mutex.requirements]

32.5.3.1 In general [thread.mutex.requirements.general]

32.5.3.2 Mutex types [thread.mutex.requirements.mutex]

32.5.3.2.1 Class mutex [thread.mutex.class]

32.5.3.2.2 Class recursive_mutex [thread.mutex.recursive]

32.5.3.3 Timed mutex types [thread.timedmutex.requirements]

32.5.3.3.1 Class timed_mutex [thread.timedmutex.class]

32.5.3.3.2 Class recursive_timed_mutex [thread.timedmutex.recursive]

32.5.3.4 Shared mutex types [thread.sharedmutex.requirements]

32.5.3.4.1 Class shared_mutex [thread.sharedmutex.class]

32.5.3.5 Shared timed mutex types [thread.sharedtimedmutex.requirements]

32.5.3.5.1 Class shared_timed_mutex [thread.sharedtimedmutex.class]

32.5.4 Locks [thread.lock]

32.5.4.1 Class template lock_guard [thread.lock.guard]

32.5.4.2 Class template scoped_lock [thread.lock.scoped]

32.5.4.3 Class template unique_lock [thread.lock.unique]

32.5.4.3.1 Constructors, destructor, and assignment [thread.lock.unique.cons]

32.5.4.3.2 Locking [thread.lock.unique.locking]

32.5.4.3.3 Modifiers [thread.lock.unique.mod]

32.5.4.3.4 Observers [thread.lock.unique.obs]

32.5.4.4 Class template shared_lock [thread.lock.shared]

32.5.4.4.1 Constructors, destructor, and assignment [thread.lock.shared.cons]

32.5.4.4.2 Locking [thread.lock.shared.locking]

32.5.4.4.3 Modifiers [thread.lock.shared.mod]

32.5.4.4.4 Observers [thread.lock.shared.obs]

32.5.5 Generic locking algorithms [thread.lock.algorithm]

32.5.6 Call once [thread.once]

32.5.6.1 Struct once_flag [thread.once.onceflag]

32.5.6.2 Function call_once [thread.once.callonce]

32.6 Condition variables [thread.condition]

32.6.1 Header <condition_variable> synopsis [condition.variable.syn]

32.6.2 Non-member functions [thread.condition.nonmember]

32.6.3 Class condition_variable [thread.condition.condvar]

32.6.4 Class condition_variable_any [thread.condition.condvarany]

32.6.4.1 Noninterruptible waits [thread.condvarany.wait]

32.6.4.2 Interruptible waits [thread.condvarany.intwait]

32.7 Semaphore [thread.sema]

32.7.1 Header <semaphore> synopsis [semaphore.syn]

32.7.2 Class template counting_semaphore [thread.sema.cnt]

32.8 Coordination types [thread.coord]

32.8.1 Latches [thread.latch]

32.8.1.1 Header <latch> synopsis [latch.syn]

32.8.1.2 Class latch [thread.latch.class]

32.8.2 Barriers [thread.barrier]

32.8.2.1 Header <barrier> synopsis [barrier.syn]

32.8.2.2 Class template barrier [thread.barrier.class]

32.9 Futures [futures]

32.9.1 Overview [futures.overview]

32.9.2 Header <future> synopsis [future.syn]

32.9.3 Error handling [futures.errors]

32.9.4 Class future_error [futures.future.error]

32.9.5 Shared state [futures.state]

32.9.6 Class template promise [futures.promise]

32.9.7 Class template future [futures.unique.future]

32.9.8 Class template shared_future [futures.shared.future]

32.9.9 Function template async [futures.async]

32.9.10 Class template packaged_task [futures.task]

32.9.10.1 Member functions [futures.task.members]

32.9.10.2 Globals [futures.task.nonmembers]

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

A.1 Keywords [gram.key]

A.2 Lexical conventions [gram.lex]

A.3 Basics [gram.basic]

A.4 Expressions [gram.expr]

A.5 Statements [gram.stmt]

A.6 Declarations [gram.dcl]

A.7 Modules [gram.module]

A.8 Classes [gram.class]

A.9 Overloading [gram.over]

A.10 Templates [gram.temp]

A.11 Exception handling [gram.except]

A.12 Preprocessing directives [gram.cpp]

Annex B (informative) Implementation quantities [implimits][implimits]

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

C.1 C++ and ISO C++ 2017 [diff.cpp17]

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

C.1.2 [basic]: basics [diff.cpp17.basic]

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

C.1.4 [dcl.dcl]: declarations [diff.cpp17.dcl.dcl]

C.1.5 [class]: classes [diff.cpp17.class]

C.1.6 [over]: overloading [diff.cpp17.over]

C.1.7 [temp]: templates [diff.cpp17.temp]

C.1.8 [except]: exception handling [diff.cpp17.except]

C.1.9 [library]: library introduction [diff.cpp17.library]

C.1.10 [containers]: containers library [diff.cpp17.containers]

C.1.11 [iterators]: iterators library [diff.cpp17.iterators]

C.1.12 [algorithms]: algorithms library [diff.cpp17.alg.reqs]

C.1.13 [input.output]: input/output library [diff.cpp17.input.output]

C.1.14 [depr]: compatibility features [diff.cpp17.depr]

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

C.2.1 [lex]: lexical conventions [diff.cpp14.lex]

C.2.2 [expr]: expressions [diff.cpp14.expr]

C.2.3 [dcl.dcl]: declarations [diff.cpp14.dcl.dcl]

C.2.4 [class]: classes [diff.cpp14.class]

C.2.5 [temp]: templates [diff.cpp14.temp]

C.2.6 [except]: exception handling [diff.cpp14.except]

C.2.7 [library]: library introduction [diff.cpp14.library]

C.2.8 [utilities]: general utilities library [diff.cpp14.utilities]

C.2.9 [strings]: strings library [diff.cpp14.string]

C.2.10 [containers]: containers library [diff.cpp14.containers]

C.2.11 [depr]: compatibility features [diff.cpp14.depr]

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

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

C.3.2 [basic]: basics [diff.cpp11.basic]

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

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

C.3.5 [library]: library introduction [diff.cpp11.library]

C.3.6 [input.output]: input/output library [diff.cpp11.input.output]

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

C.4.1 [lex]: lexical conventions [diff.cpp03.lex]

C.4.2 [expr]: expressions [diff.cpp03.expr]

C.4.3 [dcl.dcl]: declarations [diff.cpp03.dcl.dcl]

C.4.4 [class]: classes [diff.cpp03.class]

C.4.5 [temp]: templates [diff.cpp03.temp]

C.4.6 [library]: library introduction [diff.cpp03.library]

C.4.7 [support]: language support library [diff.cpp03.language.support]

C.4.8 [diagnostics]: diagnostics library [diff.cpp03.diagnostics]

C.4.9 [utilities]: general utilities library [diff.cpp03.utilities]

C.4.10 [strings]: strings library [diff.cpp03.strings]

C.4.11 [containers]: containers library [diff.cpp03.containers]

C.4.12 [algorithms]: algorithms library [diff.cpp03.algorithms]

C.4.13 [numerics]: numerics library [diff.cpp03.numerics]

C.4.14 [input.output]: input/output library [diff.cpp03.input.output]

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

C.5.1 [lex]: lexical conventions [diff.lex]

C.5.2 [basic]: basics [diff.basic]

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

C.5.4 [stmt.stmt]: statements [diff.stat]

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

C.5.6 [class]: classes [diff.class]

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

C.6 C standard library [diff.library]

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

C.6.2 Modifications to definitions [diff.mods.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.7 Macro NULL [diff.null]

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

C.6.4 Modifications to behavior [diff.mods.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 Comma operator in subscript expressions [depr.comma.subscript]

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

D.5 Deprecated volatile types [depr.volatile.type]

D.6 Redeclaration of static constexpr data members [depr.static.constexpr]

D.7 Non-local use of TU-local entities [depr.local]

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

D.9 C headers [depr.c.headers]

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

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

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

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

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

D.9.6 Other C headers [depr.c.headers.other]

D.10 Requires paragraph [depr.res.on.required]

D.11 Relational operators [depr.relops]

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

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

D.12.2 Class strstreambuf [depr.strstreambuf]

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

D.12.2.2 Member functions [depr.strstreambuf.members]

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

D.12.3 Class istrstream [depr.istrstream]

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

D.12.3.2 Member functions [depr.istrstream.members]

D.12.4 Class ostrstream [depr.ostrstream]

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

D.12.4.2 Member functions [depr.ostrstream.members]

D.12.5 Class strstream [depr.strstream]

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

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

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

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

D.14 Tuple [depr.tuple]

D.15 Variant [depr.variant]

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

D.16.1 Basic iterator [depr.iterator.basic]

D.17 Deprecated move_iterator access [depr.move.iter.elem]

D.18 Deprecated shared_ptr atomic access [depr.util.smartptr.shared.atomic]

D.19 Deprecated basic_string capacity [depr.string.capacity]

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

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

D.20.2 Requirements [depr.locale.stdcvt.req]

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

D.21.1 Class template wstring_convert [depr.conversions.string]

D.21.2 Class template wbuffer_convert [depr.conversions.buffer]

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

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

D.24 Deprecated atomic operations [depr.atomics]

D.24.1 Volatile access [depr.atomics.volatile]

D.24.2 Non-member functions [depr.atomics.nonmembers]

D.24.3 Operations on atomic types [depr.atomics.types.operations]

D.24.4 Flag type and operations [depr.atomics.flag]

Index

Index of library headers

Index of library names

Index of library concepts

Index of implementation-defined behavior