Draft C++ Standard: Contents (original) (raw)

Working Draft

Programming Languages — C++

(Generated on 2024-02-11 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 General [intro.compliance.general]

4.1.2 Abstract machine [intro.abstract]

4.2 Structure of this document [intro.structure]

4.3 Syntax notation [syntax]

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.8 Header names [lex.header]

5.9 Preprocessing numbers [lex.ppnumber]

5.10 Identifiers [lex.name]

5.11 Keywords [lex.key]

5.12 Operators and punctuators [lex.operators]

5.13 Literals [lex.literal]

5.13.1 Kinds of literals [lex.literal.kinds]

5.13.2 Integer literals [lex.icon]

5.13.3 Character literals [lex.ccon]

5.13.4 Floating-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 General [basic.scope.scope]

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 Lambda scope [basic.scope.lambda]

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.5 Name lookup [basic.lookup]

6.5.1 General [basic.lookup.general]

6.5.2 Member name lookup [class.member.lookup]

6.5.3 Unqualified name lookup [basic.lookup.unqual]

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

6.5.5 Qualified name lookup [basic.lookup.qual]

6.5.5.1 General [basic.lookup.qual.general]

6.5.5.2 Class members [class.qual]

6.5.5.3 Namespace members [namespace.qual]

6.5.6 Elaborated type specifiers [basic.lookup.elab]

6.5.7 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 General [basic.stc.general]

6.7.5.2 Static storage duration [basic.stc.static]

6.7.5.3 Thread storage duration [basic.stc.thread]

6.7.5.4 Automatic storage duration [basic.stc.auto]

6.7.5.5 Dynamic storage duration [basic.stc.dynamic]

6.7.5.5.1 General [basic.stc.dynamic.general]

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

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

6.7.5.6 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 General [basic.types.general]

6.8.2 Fundamental types [basic.fundamental]

6.8.3 Optional extended floating-point types [basic.extended.fp]

6.8.4 Compound types [basic.compound]

6.8.5 CV-qualifiers [basic.type.qualifier]

6.8.6 Conversion ranks [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 General [intro.multithread.general]

6.9.2.2 Data races [intro.races]

6.9.2.3 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-block 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 General [conv.general]

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

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

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

7.3.5 Temporary materialization conversion [conv.rval]

7.3.6 Qualification conversions [conv.qual]

7.3.7 Integral promotions [conv.prom]

7.3.8 Floating-point promotion [conv.fpprom]

7.3.9 Integral conversions [conv.integral]

7.3.10 Floating-point conversions [conv.double]

7.3.11 Floating-integral conversions [conv.fpint]

7.3.12 Pointer conversions [conv.ptr]

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

7.3.14 Function pointer conversions [conv.fctptr]

7.3.15 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 General [expr.prim.id.general]

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

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

7.5.4.4 Destruction [expr.prim.id.dtor]

7.5.5 Lambda expressions [expr.prim.lambda]

7.5.5.1 General [expr.prim.lambda.general]

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

7.5.5.3 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 General [expr.prim.req.general]

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

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

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

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

7.6 Compound expressions [expr.compound]

7.6.1 Postfix expressions [expr.post]

7.6.1.1 General [expr.post.general]

7.6.1.2 Subscripting [expr.sub]

7.6.1.3 Function call [expr.call]

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

7.6.1.5 Class member access [expr.ref]

7.6.1.6 Increment and decrement [expr.post.incr]

7.6.1.7 Dynamic cast [expr.dynamic.cast]

7.6.1.8 Type identification [expr.typeid]

7.6.1.9 Static cast [expr.static.cast]

7.6.1.10 Reinterpret cast [expr.reinterpret.cast]

7.6.1.11 Const cast [expr.const.cast]

7.6.2 Unary expressions [expr.unary]

7.6.2.1 General [expr.unary.general]

7.6.2.2 Unary operators [expr.unary.op]

7.6.2.3 Increment and decrement [expr.pre.incr]

7.6.2.4 Await [expr.await]

7.6.2.5 Sizeof [expr.sizeof]

7.6.2.6 Alignof [expr.alignof]

7.6.2.7 noexcept operator [expr.unary.noexcept]

7.6.2.8 New [expr.new]

7.6.2.9 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 Label [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 General [stmt.select.general]

8.5.2 The if statement [stmt.if]

8.5.3 The switch statement [stmt.switch]

8.6 Iteration statements [stmt.iter]

8.6.1 General [stmt.iter.general]

8.6.2 The while statement [stmt.while]

8.6.3 The do statement [stmt.do]

8.6.4 The for statement [stmt.for]

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

8.7 Jump statements [stmt.jump]

8.7.1 General [stmt.jump.general]

8.7.2 The break statement [stmt.break]

8.7.3 The continue statement [stmt.cont]

8.7.4 The return statement [stmt.return]

8.7.5 The co_return statement [stmt.return.coroutine]

8.7.6 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 General [dcl.spec.general]

9.2.2 Storage class specifiers [dcl.stc]

9.2.3 Function specifiers [dcl.fct.spec]

9.2.4 The typedef specifier [dcl.typedef]

9.2.5 The friend specifier [dcl.friend]

9.2.6 The constexpr and consteval specifiers [dcl.constexpr]

9.2.7 The constinit specifier [dcl.constinit]

9.2.8 The inline specifier [dcl.inline]

9.2.9 Type specifiers [dcl.type]

9.2.9.1 General [dcl.type.general]

9.2.9.2 The cv-qualifier s [dcl.type.cv]

9.2.9.3 Simple type specifiers [dcl.type.simple]

9.2.9.4 Elaborated type specifiers [dcl.type.elab]

9.2.9.5 Decltype specifiers [dcl.type.decltype]

9.2.9.6 Placeholder type specifiers [dcl.spec.auto]

9.2.9.6.1 General [dcl.spec.auto.general]

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

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

9.3 Declarators [dcl.decl]

9.3.1 General [dcl.decl.general]

9.3.2 Type names [dcl.name]

9.3.3 Ambiguity resolution [dcl.ambig.res]

9.3.4 Meaning of declarators [dcl.meaning]

9.3.4.1 General [dcl.meaning.general]

9.3.4.2 Pointers [dcl.ptr]

9.3.4.3 References [dcl.ref]

9.3.4.4 Pointers to members [dcl.mptr]

9.3.4.5 Arrays [dcl.array]

9.3.4.6 Functions [dcl.fct]

9.3.4.7 Default arguments [dcl.fct.default]

9.4 Initializers [dcl.init]

9.4.1 General [dcl.init.general]

9.4.2 Aggregates [dcl.init.aggr]

9.4.3 Character arrays [dcl.init.string]

9.4.4 References [dcl.init.ref]

9.4.5 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 General [basic.namespace.general]

9.8.2 Namespace definition [namespace.def]

9.8.2.1 General [namespace.def.general]

9.8.2.2 Unnamed namespaces [namespace.unnamed]

9.8.3 Namespace alias [namespace.alias]

9.8.4 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 Assumption attribute [dcl.attr.assume]

9.12.4 Carries dependency attribute [dcl.attr.depend]

9.12.5 Deprecated attribute [dcl.attr.deprecated]

9.12.6 Fallthrough attribute [dcl.attr.fallthrough]

9.12.7 Likelihood attributes [dcl.attr.likelihood]

9.12.8 Maybe unused attribute [dcl.attr.unused]

9.12.9 Nodiscard attribute [dcl.attr.nodiscard]

9.12.10 Noreturn attribute [dcl.attr.noreturn]

9.12.11 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 General [class.mem.general]

11.4.2 Member functions [class.mfct]

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

11.4.4 Special member functions [special]

11.4.5 Constructors [class.ctor]

11.4.5.1 General [class.ctor.general]

11.4.5.2 Default constructors [class.default.ctor]

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

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

11.4.7 Destructors [class.dtor]

11.4.8 Conversions [class.conv]

11.4.8.1 General [class.conv.general]

11.4.8.2 Conversion by constructor [class.conv.ctor]

11.4.8.3 Conversion functions [class.conv.fct]

11.4.9 Static members [class.static]

11.4.9.1 General [class.static.general]

11.4.9.2 Static member functions [class.static.mfct]

11.4.9.3 Static data members [class.static.data]

11.4.10 Bit-fields [class.bit]

11.4.11 Allocation and deallocation functions [class.free]

11.4.12 Nested class declarations [class.nest]

11.5 Unions [class.union]

11.5.1 General [class.union.general]

11.5.2 Anonymous unions [class.union.anon]

11.6 Local class declarations [class.local]

11.7 Derived classes [class.derived]

11.7.1 General [class.derived.general]

11.7.2 Multiple base classes [class.mi]

11.7.3 Virtual functions [class.virtual]

11.7.4 Abstract classes [class.abstract]

11.8 Member access control [class.access]

11.8.1 General [class.access.general]

11.8.2 Access specifiers [class.access.spec]

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

11.8.4 Friends [class.friend]

11.8.5 Protected member access [class.protected]

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

11.8.7 Multiple access [class.paths]

11.8.8 Nested classes [class.access.nest]

11.9 Initialization [class.init]

11.9.1 General [class.init.general]

11.9.2 Explicit initialization [class.expl.init]

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

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

11.9.5 Construction and destruction [class.cdtor]

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

11.10 Comparisons [class.compare]

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

11.10.2 Equality operator [class.eq]

11.10.3 Three-way comparison [class.spaceship]

11.10.4 Secondary comparison operators [class.compare.secondary]

12 Overloading [over][over]

12.1 Preamble [over.pre]

12.2 Overload resolution [over.match]

12.2.1 General [over.match.general]

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

12.2.2.1 General [over.match.funcs.general]

12.2.2.2 Function call syntax [over.match.call]

12.2.2.2.1 General [over.match.call.general]

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

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

12.2.2.3 Operators in expressions [over.match.oper]

12.2.2.4 Initialization by constructor [over.match.ctor]

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

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

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

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

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

12.2.3 Viable functions [over.match.viable]

12.2.4 Best viable function [over.match.best]

12.2.4.1 General [over.match.best.general]

12.2.4.2 Implicit conversion sequences [over.best.ics]

12.2.4.2.1 General [over.best.ics.general]

12.2.4.2.2 Standard conversion sequences [over.ics.scs]

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

12.2.4.2.4 Ellipsis conversion sequences [over.ics.ellipsis]

12.2.4.2.5 Reference binding [over.ics.ref]

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

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

12.3 Address of an overload set [over.over]

12.4 Overloaded operators [over.oper]

12.4.1 General [over.oper.general]

12.4.2 Unary operators [over.unary]

12.4.3 Binary operators [over.binary]

12.4.3.1 General [over.binary.general]

12.4.3.2 Simple assignment [over.ass]

12.4.4 Function call [over.call]

12.4.5 Subscripting [over.sub]

12.4.6 Class member access [over.ref]

12.4.7 Increment and decrement [over.inc]

12.5 Built-in operators [over.built]

12.6 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 General [temp.arg.general]

13.4.2 Template type arguments [temp.arg.type]

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

13.4.4 Template template arguments [temp.arg.template]

13.5 Template constraints [temp.constr]

13.5.1 General [temp.constr.general]

13.5.2 Constraints [temp.constr.constr]

13.5.2.1 General [temp.constr.constr.general]

13.5.2.2 Logical operations [temp.constr.op]

13.5.2.3 Atomic constraints [temp.constr.atomic]

13.5.3 Constrained declarations [temp.constr.decl]

13.5.4 Constraint normalization [temp.constr.normal]

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

13.6 Type equivalence [temp.type]

13.7 Template declarations [temp.decls]

13.7.1 General [temp.decls.general]

13.7.2 Class templates [temp.class]

13.7.2.1 General [temp.class.general]

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

13.7.2.3 Deduction guides [temp.deduct.guide]

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

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

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

13.7.3 Member templates [temp.mem]

13.7.4 Variadic templates [temp.variadic]

13.7.5 Friends [temp.friend]

13.7.6 Partial specialization [temp.spec.partial]

13.7.6.1 General [temp.spec.partial.general]

13.7.6.2 Matching of partial specializations [temp.spec.partial.match]

13.7.6.3 Partial ordering of partial specializations [temp.spec.partial.order]

13.7.6.4 Members of class template partial specializations [temp.spec.partial.member]

13.7.7 Function templates [temp.fct]

13.7.7.1 General [temp.fct.general]

13.7.7.2 Function template overloading [temp.over.link]

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

13.7.8 Alias templates [temp.alias]

13.7.9 Concept definitions [temp.concept]

13.8 Name resolution [temp.res]

13.8.1 General [temp.res.general]

13.8.2 Locally declared names [temp.local]

13.8.3 Dependent names [temp.dep]

13.8.3.1 General [temp.dep.general]

13.8.3.2 Dependent types [temp.dep.type]

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

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

13.8.3.5 Dependent template arguments [temp.dep.temp]

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.9 Template instantiation and specialization [temp.spec]

13.9.1 General [temp.spec.general]

13.9.2 Implicit instantiation [temp.inst]

13.9.3 Explicit instantiation [temp.explicit]

13.9.4 Explicit specialization [temp.expl.spec]

13.10 Function template specializations [temp.fct.spec]

13.10.1 General [temp.fct.spec.general]

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

13.10.3 Template argument deduction [temp.deduct]

13.10.3.1 General [temp.deduct.general]

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

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

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

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

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

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

13.10.4 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 General [except.special.general]

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

14.6.3 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 General [cpp.replace.general]

15.6.2 Argument substitution [cpp.subst]

15.6.3 The # operator [cpp.stringize]

15.6.4 The ## operator [cpp.concat]

15.6.5 Rescanning and further replacement [cpp.rescan]

15.6.6 Scope of macro definitions [cpp.scope]

15.7 Line control [cpp.line]

15.8 Diagnostic directives [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 Method of description [description]

16.3.1 General [description.general]

16.3.2 Structure of each clause [structure]

16.3.2.1 Elements [structure.elements]

16.3.2.2 Summary [structure.summary]

16.3.2.3 Requirements [structure.requirements]

16.3.2.4 Detailed specifications [structure.specifications]

16.3.2.5 C library [structure.see.also]

16.3.3 Other conventions [conventions]

16.3.3.1 General [conventions.general]

16.3.3.2 Exposition-only entities, etc. [expos.only.entity]

16.3.3.3 Type descriptions [type.descriptions]

16.3.3.3.1 General [type.descriptions.general]

16.3.3.3.2 Enumerated types [enumerated.types]

16.3.3.3.3 Bitmask types [bitmask.types]

16.3.3.3.4 Character sequences [character.seq]

16.3.3.3.4.1 General [character.seq.general]

16.3.3.3.4.2 Byte strings [byte.strings]

16.3.3.3.4.3 Multibyte strings [multibyte.strings]

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

16.3.3.4 Functions within classes [functions.within.classes]

16.3.3.5 Private members [objects.within.classes]

16.3.3.6 Freestanding items [freestanding.item]

16.4 Library-wide requirements [requirements]

16.4.1 General [requirements.general]

16.4.2 Library contents and organization [organization]

16.4.2.1 General [organization.general]

16.4.2.2 Library contents [contents]

16.4.2.3 Headers [headers]

16.4.2.4 Modules [std.modules]

16.4.2.5 Freestanding implementations [compliance]

16.4.3 Using the library [using]

16.4.3.1 Overview [using.overview]

16.4.3.2 Headers [using.headers]

16.4.3.3 Linkage [using.linkage]

16.4.4 Requirements on types and expressions [utility.requirements]

16.4.4.1 General [utility.requirements.general]

16.4.4.2 Template argument requirements [utility.arg.requirements]

16.4.4.3 Swappable requirements [swappable.requirements]

16.4.4.4 Cpp17NullablePointer requirements [nullablepointer.requirements]

16.4.4.5 Cpp17Hash requirements [hash.requirements]

16.4.4.6 Cpp17Allocator requirements [allocator.requirements]

16.4.4.6.1 General [allocator.requirements.general]

16.4.4.6.2 Allocator completeness requirements [allocator.requirements.completeness]

16.4.5 Constraints on programs [constraints]

16.4.5.1 Overview [constraints.overview]

16.4.5.2 Namespace use [namespace.constraints]

16.4.5.2.1 Namespace std [namespace.std]

16.4.5.2.2 Namespace posix [namespace.posix]

16.4.5.2.3 Namespaces for future standardization [namespace.future]

16.4.5.3 Reserved names [reserved.names]

16.4.5.3.1 General [reserved.names.general]

16.4.5.3.2 Zombie names [zombie.names]

16.4.5.3.3 Macro names [macro.names]

16.4.5.3.4 External linkage [extern.names]

16.4.5.3.5 Types [extern.types]

16.4.5.3.6 User-defined literal suffixes [usrlit.suffix]

16.4.5.4 Headers [alt.headers]

16.4.5.5 Derived classes [derived.classes]

16.4.5.6 Replacement functions [replacement.functions]

16.4.5.7 Handler functions [handler.functions]

16.4.5.8 Other functions [res.on.functions]

16.4.5.9 Function arguments [res.on.arguments]

16.4.5.10 Library object access [res.on.objects]

16.4.5.11 Semantic requirements [res.on.requirements]

16.4.6 Conforming implementations [conforming]

16.4.6.1 Overview [conforming.overview]

16.4.6.2 Headers [res.on.headers]

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

16.4.6.4 Non-member functions [global.functions]

16.4.6.5 Member functions [member.functions]

16.4.6.6 Friend functions [hidden.friends]

16.4.6.7 Constexpr functions and constructors [constexpr.functions]

16.4.6.8 Requirements for stable algorithms [algorithm.stable]

16.4.6.9 Reentrancy [reentrancy]

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

16.4.6.11 Protection within classes [protection.within.classes]

16.4.6.12 Derived classes [derivation]

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

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

16.4.6.15 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 synopsis [cstddef.syn]

17.2.2 Header 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 synopsis [version.syn]

17.3.3 Header synopsis [limits.syn]

17.3.4 Enum float_round_style [round.style]

17.3.5 Class template numeric_limits [numeric.limits]

17.3.5.1 General [numeric.limits.general]

17.3.5.2 numeric_limits members [numeric.limits.members]

17.3.5.3 numeric_limits specializations [numeric.special]

17.3.6 Header synopsis [climits.syn]

17.3.7 Header synopsis [cfloat.syn]

17.4 Arithmetic types [support.arith.types]

17.4.1 Header synopsis [cstdint.syn]

17.4.2 Header synopsis [stdfloat.syn]

17.5 Startup and termination [support.start.term]

17.6 Dynamic memory management [support.dynamic]

17.6.1 General [support.dynamic.general]

17.6.2 Header synopsis [new.syn]

17.6.3 Storage allocation and deallocation [new.delete]

17.6.3.1 General [new.delete.general]

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

17.6.3.3 Array forms [new.delete.array]

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

17.6.3.5 Data races [new.delete.dataraces]

17.6.4 Storage allocation errors [alloc.errors]

17.6.4.1 Class bad_alloc [bad.alloc]

17.6.4.2 Class bad_array_new_length [new.badlength]

17.6.4.3 Type new_handler [new.handler]

17.6.4.4 set_new_handler [set.new.handler]

17.6.4.5 get_new_handler [get.new.handler]

17.6.5 Pointer optimization barrier [ptr.launder]

17.6.6 Hardware interference size [hardware.interference]

17.7 Type identification [support.rtti]

17.7.1 General [support.rtti.general]

17.7.2 Header synopsis [typeinfo.syn]

17.7.3 Class type_info [type.info]

17.7.4 Class bad_cast [bad.cast]

17.7.5 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 General [support.srcloc.class.general]

17.8.2.2 Creation [support.srcloc.cons]

17.8.2.3 Observers [support.srcloc.obs]

17.9 Exception handling [support.exception]

17.9.1 General [support.exception.general]

17.9.2 Header synopsis [exception.syn]

17.9.3 Class exception [exception]

17.9.4 Class bad_exception [bad.exception]

17.9.5 Abnormal termination [exception.terminate]

17.9.5.1 Type terminate_handler [terminate.handler]

17.9.5.2 set_terminate [set.terminate]

17.9.5.3 get_terminate [get.terminate]

17.9.5.4 terminate [terminate]

17.9.6 uncaught_exceptions [uncaught.exceptions]

17.9.7 Exception propagation [propagation]

17.9.8 nested_exception [except.nested]

17.10 Initializer lists [support.initlist]

17.10.1 General [support.initlist.general]

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

17.10.3 Initializer list constructors [support.initlist.cons]

17.10.4 Initializer list access [support.initlist.access]

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

17.11 Comparisons [cmp]

17.11.1 Header 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 General [support.coroutine.general]

17.12.2 Header synopsis [coroutine.syn]

17.12.3 Coroutine traits [coroutine.traits]

17.12.3.1 General [coroutine.traits.general]

17.12.3.2 Class template coroutine_traits [coroutine.traits.primary]

17.12.4 Class template coroutine_handle [coroutine.handle]

17.12.4.1 General [coroutine.handle.general]

17.12.4.2 Construct/reset [coroutine.handle.con]

17.12.4.3 Conversion [coroutine.handle.conv]

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

17.12.4.5 Observers [coroutine.handle.observers]

17.12.4.6 Resumption [coroutine.handle.resumption]

17.12.4.7 Promise access [coroutine.handle.promise]

17.12.4.8 Comparison operators [coroutine.handle.compare]

17.12.4.9 Hash support [coroutine.handle.hash]

17.12.5 No-op coroutines [coroutine.noop]

17.12.5.1 Class noop_coroutine_promise [coroutine.promise.noop]

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

17.12.5.2.1 Conversion [coroutine.handle.noop.conv]

17.12.5.2.2 Observers [coroutine.handle.noop.observers]

17.12.5.2.3 Resumption [coroutine.handle.noop.resumption]

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

17.12.5.2.5 Address [coroutine.handle.noop.address]

17.12.5.3 Function noop_coroutine [coroutine.noop.coroutine]

17.12.6 Trivial awaitables [coroutine.trivial.awaitables]

17.13 Other runtime support [support.runtime]

17.13.1 General [support.runtime.general]

17.13.2 Header synopsis [cstdarg.syn]

17.13.3 Header synopsis [csetjmp.syn]

17.13.4 Header synopsis [csignal.syn]

17.13.5 Signal handlers [support.signal]

17.14 C headers [support.c.headers]

17.14.1 General [support.c.headers.general]

17.14.2 Header <complex.h> synopsis [complex.h.syn]

17.14.3 Header <iso646.h> synopsis [iso646.h.syn]

17.14.4 Header <stdalign.h> synopsis [stdalign.h.syn]

17.14.5 Header <stdbool.h> synopsis [stdbool.h.syn]

17.14.6 Header <tgmath.h> synopsis [tgmath.h.syn]

17.14.7 Other C headers [support.c.headers.other]

18 Concepts library [concepts][concepts]

18.1 General [concepts.general]

18.2 Equality preservation [concepts.equality]

18.3 Header 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 Comparison common types [concept.comparisoncommontype]

18.5.4 Concept equality_comparable [concept.equalitycomparable]

18.5.5 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 General [std.exceptions.general]

19.2.2 Header synopsis [stdexcept.syn]

19.2.3 Class logic_error [logic.error]

19.2.4 Class domain_error [domain.error]

19.2.5 Class invalid_argument [invalid.argument]

19.2.6 Class length_error [length.error]

19.2.7 Class out_of_range [out.of.range]

19.2.8 Class runtime_error [runtime.error]

19.2.9 Class range_error [range.error]

19.2.10 Class overflow_error [overflow.error]

19.2.11 Class underflow_error [underflow.error]

19.3 Assertions [assertions]

19.3.1 General [assertions.general]

19.3.2 Header synopsis [cassert.syn]

19.3.3 The assert macro [assertions.assert]

19.4 Error numbers [errno]

19.4.1 General [errno.general]

19.4.2 Header synopsis [cerrno.syn]

19.5 System error support [syserr]

19.5.1 General [syserr.general]

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

19.5.3 Class error_category [syserr.errcat]

19.5.3.1 Overview [syserr.errcat.overview]

19.5.3.2 Virtual members [syserr.errcat.virtuals]

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

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

19.5.3.5 Error category objects [syserr.errcat.objects]

19.5.4 Class error_code [syserr.errcode]

19.5.4.1 Overview [syserr.errcode.overview]

19.5.4.2 Constructors [syserr.errcode.constructors]

19.5.4.3 Modifiers [syserr.errcode.modifiers]

19.5.4.4 Observers [syserr.errcode.observers]

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

19.5.5 Class error_condition [syserr.errcondition]

19.5.5.1 Overview [syserr.errcondition.overview]

19.5.5.2 Constructors [syserr.errcondition.constructors]

19.5.5.3 Modifiers [syserr.errcondition.modifiers]

19.5.5.4 Observers [syserr.errcondition.observers]

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

19.5.6 Comparison operator functions [syserr.compare]

19.5.7 System error hash support [syserr.hash]

19.5.8 Class system_error [syserr.syserr]

19.5.8.1 Overview [syserr.syserr.overview]

19.5.8.2 Members [syserr.syserr.members]

19.6 Stacktrace [stacktrace]

19.6.1 General [stacktrace.general]

19.6.2 Header synopsis [stacktrace.syn]

19.6.3 Class stacktrace_entry [stacktrace.entry]

19.6.3.1 Overview [stacktrace.entry.overview]

19.6.3.2 Constructors [stacktrace.entry.cons]

19.6.3.3 Observers [stacktrace.entry.obs]

19.6.3.4 Query [stacktrace.entry.query]

19.6.3.5 Comparison [stacktrace.entry.cmp]

19.6.4 Class template basic_stacktrace [stacktrace.basic]

19.6.4.1 Overview [stacktrace.basic.overview]

19.6.4.2 Creation and assignment [stacktrace.basic.cons]

19.6.4.3 Observers [stacktrace.basic.obs]

19.6.4.4 Comparisons [stacktrace.basic.cmp]

19.6.4.5 Modifiers [stacktrace.basic.mod]

19.6.4.6 Non-member functions [stacktrace.basic.nonmem]

19.6.4.7 Formatting support [stacktrace.format]

19.6.4.8 Hash support [stacktrace.basic.hash]

20 Memory management library [mem][mem]

20.1 General [mem.general]

20.2 Memory [memory]

20.2.1 In general [memory.general]

20.2.2 Header synopsis [memory.syn]

20.2.3 Pointer traits [pointer.traits]

20.2.3.1 General [pointer.traits.general]

20.2.3.2 Member types [pointer.traits.types]

20.2.3.3 Member functions [pointer.traits.functions]

20.2.3.4 Optional members [pointer.traits.optmem]

20.2.4 Pointer conversion [pointer.conversion]

20.2.5 Pointer alignment [ptr.align]

20.2.6 Explicit lifetime management [obj.lifetime]

20.2.7 Allocator argument tag [allocator.tag]

20.2.8 uses_allocator [allocator.uses]

20.2.8.1 uses_allocator trait [allocator.uses.trait]

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

20.2.9 Allocator traits [allocator.traits]

20.2.9.1 General [allocator.traits.general]

20.2.9.2 Member types [allocator.traits.types]

20.2.9.3 Static member functions [allocator.traits.members]

20.2.9.4 Other [allocator.traits.other]

20.2.10 The default allocator [default.allocator]

20.2.10.1 General [default.allocator.general]

20.2.10.2 Members [allocator.members]

20.2.10.3 Operators [allocator.globals]

20.2.11 addressof [specialized.addressof]

20.2.12 C library memory allocation [c.malloc]

20.3 Smart pointers [smartptr]

20.3.1 Unique-ownership pointers [unique.ptr]

20.3.1.1 General [unique.ptr.general]

20.3.1.2 Default deleters [unique.ptr.dltr]

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

20.3.1.2.2 default_delete [unique.ptr.dltr.dflt]

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

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

20.3.1.3.1 General [unique.ptr.single.general]

20.3.1.3.2 Constructors [unique.ptr.single.ctor]

20.3.1.3.3 Destructor [unique.ptr.single.dtor]

20.3.1.3.4 Assignment [unique.ptr.single.asgn]

20.3.1.3.5 Observers [unique.ptr.single.observers]

20.3.1.3.6 Modifiers [unique.ptr.single.modifiers]

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

20.3.1.4.1 General [unique.ptr.runtime.general]

20.3.1.4.2 Constructors [unique.ptr.runtime.ctor]

20.3.1.4.3 Assignment [unique.ptr.runtime.asgn]

20.3.1.4.4 Observers [unique.ptr.runtime.observers]

20.3.1.4.5 Modifiers [unique.ptr.runtime.modifiers]

20.3.1.5 Creation [unique.ptr.create]

20.3.1.6 Specialized algorithms [unique.ptr.special]

20.3.1.7 I/O [unique.ptr.io]

20.3.2 Shared-ownership pointers [util.sharedptr]

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

20.3.2.2 Class template shared_ptr [util.smartptr.shared]

20.3.2.2.1 General [util.smartptr.shared.general]

20.3.2.2.2 Constructors [util.smartptr.shared.const]

20.3.2.2.3 Destructor [util.smartptr.shared.dest]

20.3.2.2.4 Assignment [util.smartptr.shared.assign]

20.3.2.2.5 Modifiers [util.smartptr.shared.mod]

20.3.2.2.6 Observers [util.smartptr.shared.obs]

20.3.2.2.7 Creation [util.smartptr.shared.create]

20.3.2.2.8 Comparison [util.smartptr.shared.cmp]

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

20.3.2.2.10 Casts [util.smartptr.shared.cast]

20.3.2.2.11 get_deleter [util.smartptr.getdeleter]

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

20.3.2.3 Class template weak_ptr [util.smartptr.weak]

20.3.2.3.1 General [util.smartptr.weak.general]

20.3.2.3.2 Constructors [util.smartptr.weak.const]

20.3.2.3.3 Destructor [util.smartptr.weak.dest]

20.3.2.3.4 Assignment [util.smartptr.weak.assign]

20.3.2.3.5 Modifiers [util.smartptr.weak.mod]

20.3.2.3.6 Observers [util.smartptr.weak.obs]

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

20.3.2.4 Class template owner_less [util.smartptr.ownerless]

20.3.2.5 Class template enable_shared_from_this [util.smartptr.enab]

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

20.3.4 Smart pointer adaptors [smartptr.adapt]

20.3.4.1 Class template out_ptr_t [out.ptr.t]

20.3.4.2 Function template out_ptr [out.ptr]

20.3.4.3 Class template inout_ptr_t [inout.ptr.t]

20.3.4.4 Function template inout_ptr [inout.ptr]

20.4 Memory resources [mem.res]

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

20.4.2 Class memory_resource [mem.res.class]

20.4.2.1 General [mem.res.class.general]

20.4.2.2 Public member functions [mem.res.public]

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

20.4.2.4 Equality [mem.res.eq]

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

20.4.3.1 General [mem.poly.allocator.class.general]

20.4.3.2 Constructors [mem.poly.allocator.ctor]

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

20.4.3.4 Equality [mem.poly.allocator.eq]

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

20.4.5 Pool resource classes [mem.res.pool]

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

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

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

20.4.5.4 Members [mem.res.pool.mem]

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

20.4.6.1 General [mem.res.monotonic.buffer.general]

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

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

20.5 Class template scoped_allocator_adaptor [allocator.adaptor]

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

20.5.2 Member types [allocator.adaptor.types]

20.5.3 Constructors [allocator.adaptor.cnstr]

20.5.4 Members [allocator.adaptor.members]

20.5.5 Operators [scoped.adaptor.operators]

21 Metaprogramming library [meta][meta]

21.1 General [meta.general]

21.2 Compile-time integer sequences [intseq]

21.2.1 In general [intseq.general]

21.2.2 Class template integer_sequence [intseq.intseq]

21.2.3 Alias template make_integer_sequence [intseq.make]

21.3 Metaprogramming and type traits [type.traits]

21.3.1 General [type.traits.general]

21.3.2 Requirements [meta.rqmts]

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

21.3.4 Helper classes [meta.help]

21.3.5 Unary type traits [meta.unary]

21.3.5.1 General [meta.unary.general]

21.3.5.2 Primary type categories [meta.unary.cat]

21.3.5.3 Composite type traits [meta.unary.comp]

21.3.5.4 Type properties [meta.unary.prop]

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

21.3.7 Relationships between types [meta.rel]

21.3.8 Transformations between types [meta.trans]

21.3.8.1 General [meta.trans.general]

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

21.3.8.3 Reference modifications [meta.trans.ref]

21.3.8.4 Sign modifications [meta.trans.sign]

21.3.8.5 Array modifications [meta.trans.arr]

21.3.8.6 Pointer modifications [meta.trans.ptr]

21.3.8.7 Other transformations [meta.trans.other]

21.3.9 Logical operator traits [meta.logical]

21.3.10 Member relationships [meta.member]

21.3.11 Constant evaluation context [meta.const.eval]

21.4 Compile-time rational arithmetic [ratio]

21.4.1 In general [ratio.general]

21.4.2 Header synopsis [ratio.syn]

21.4.3 Class template ratio [ratio.ratio]

21.4.4 Arithmetic on ratios [ratio.arithmetic]

21.4.5 Comparison of ratios [ratio.comparison]

21.4.6 SI types for ratio [ratio.si]

22 General utilities library [utilities][utilities]

22.1 General [utilities.general]

22.2 Utility components [utility]

22.2.1 Header synopsis [utility.syn]

22.2.2 swap [utility.swap]

22.2.3 exchange [utility.exchange]

22.2.4 Forward/move helpers [forward]

22.2.5 Function template as_const [utility.as.const]

22.2.6 Function template declval [declval]

22.2.7 Integer comparison functions [utility.intcmp]

22.2.8 Function template to_underlying [utility.underlying]

22.2.9 Function unreachable [utility.unreachable]

22.3 Pairs [pairs]

22.3.1 In general [pairs.general]

22.3.2 Class template pair [pairs.pair]

22.3.3 Specialized algorithms [pairs.spec]

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

22.3.5 Piecewise construction [pair.piecewise]

22.4 Tuples [tuple]

22.4.1 In general [tuple.general]

22.4.2 Header synopsis [tuple.syn]

22.4.3 Concept tuple-like [tuple.like]

22.4.4 Class template tuple [tuple.tuple]

22.4.4.1 Construction [tuple.cnstr]

22.4.4.2 Assignment [tuple.assign]

22.4.4.3 swap [tuple.swap]

22.4.5 Tuple creation functions [tuple.creation]

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

22.4.7 Tuple helper classes [tuple.helper]

22.4.8 Element access [tuple.elem]

22.4.9 Relational operators [tuple.rel]

22.4.10 common_reference related specializations [tuple.common.ref]

22.4.11 Tuple traits [tuple.traits]

22.4.12 Tuple specialized algorithms [tuple.special]

22.5 Optional objects [optional]

22.5.1 In general [optional.general]

22.5.2 Header synopsis [optional.syn]

22.5.3 Class template optional [optional.optional]

22.5.3.1 General [optional.optional.general]

22.5.3.2 Constructors [optional.ctor]

22.5.3.3 Destructor [optional.dtor]

22.5.3.4 Assignment [optional.assign]

22.5.3.5 Swap [optional.swap]

22.5.3.6 Observers [optional.observe]

22.5.3.7 Monadic operations [optional.monadic]

22.5.3.8 Modifiers [optional.mod]

22.5.4 No-value state indicator [optional.nullopt]

22.5.5 Class bad_optional_access [optional.bad.access]

22.5.6 Relational operators [optional.relops]

22.5.7 Comparison with nullopt [optional.nullops]

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

22.5.9 Specialized algorithms [optional.specalg]

22.5.10 Hash support [optional.hash]

22.6 Variants [variant]

22.6.1 In general [variant.general]

22.6.2 Header synopsis [variant.syn]

22.6.3 Class template variant [variant.variant]

22.6.3.1 General [variant.variant.general]

22.6.3.2 Constructors [variant.ctor]

22.6.3.3 Destructor [variant.dtor]

22.6.3.4 Assignment [variant.assign]

22.6.3.5 Modifiers [variant.mod]

22.6.3.6 Value status [variant.status]

22.6.3.7 Swap [variant.swap]

22.6.4 variant helper classes [variant.helper]

22.6.5 Value access [variant.get]

22.6.6 Relational operators [variant.relops]

22.6.7 Visitation [variant.visit]

22.6.8 Class monostate [variant.monostate]

22.6.9 monostate relational operators [variant.monostate.relops]

22.6.10 Specialized algorithms [variant.specalg]

22.6.11 Class bad_variant_access [variant.bad.access]

22.6.12 Hash support [variant.hash]

22.7 Storage for any type [any]

22.7.1 General [any.general]

22.7.2 Header synopsis [any.synop]

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

22.7.4 Class any [any.class]

22.7.4.1 General [any.class.general]

22.7.4.2 Construction and destruction [any.cons]

22.7.4.3 Assignment [any.assign]

22.7.4.4 Modifiers [any.modifiers]

22.7.4.5 Observers [any.observers]

22.7.5 Non-member functions [any.nonmembers]

22.8 Expected objects [expected]

22.8.1 In general [expected.general]

22.8.2 Header synopsis [expected.syn]

22.8.3 Class template unexpected [expected.unexpected]

22.8.3.1 General [expected.un.general]

22.8.3.2 Constructors [expected.un.cons]

22.8.3.3 Observers [expected.un.obs]

22.8.3.4 Swap [expected.un.swap]

22.8.3.5 Equality operator [expected.un.eq]

22.8.4 Class template bad_expected_access [expected.bad]

22.8.5 Class template specialization bad_expected_access [expected.bad.void]

22.8.6 Class template expected [expected.expected]

22.8.6.1 General [expected.object.general]

22.8.6.2 Constructors [expected.object.cons]

22.8.6.3 Destructor [expected.object.dtor]

22.8.6.4 Assignment [expected.object.assign]

22.8.6.5 Swap [expected.object.swap]

22.8.6.6 Observers [expected.object.obs]

22.8.6.7 Monadic operations [expected.object.monadic]

22.8.6.8 Equality operators [expected.object.eq]

22.8.7 Partial specialization of expected for void types [expected.void]

22.8.7.1 General [expected.void.general]

22.8.7.2 Constructors [expected.void.cons]

22.8.7.3 Destructor [expected.void.dtor]

22.8.7.4 Assignment [expected.void.assign]

22.8.7.5 Swap [expected.void.swap]

22.8.7.6 Observers [expected.void.obs]

22.8.7.7 Monadic operations [expected.void.monadic]

22.8.7.8 Equality operators [expected.void.eq]

22.9 Bitsets [bitset]

22.9.1 Header synopsis [bitset.syn]

22.9.2 Class template bitset [template.bitset]

22.9.2.1 General [template.bitset.general]

22.9.2.2 Constructors [bitset.cons]

22.9.2.3 Members [bitset.members]

22.9.3 bitset hash support [bitset.hash]

22.9.4 bitset operators [bitset.operators]

22.10 Function objects [function.objects]

22.10.1 General [function.objects.general]

22.10.2 Header synopsis [functional.syn]

22.10.3 Definitions [func.def]

22.10.4 Requirements [func.require]

22.10.5 invoke functions [func.invoke]

22.10.6 Class template reference_wrapper [refwrap]

22.10.6.1 General [refwrap.general]

22.10.6.2 Constructors [refwrap.const]

22.10.6.3 Assignment [refwrap.assign]

22.10.6.4 Access [refwrap.access]

22.10.6.5 Invocation [refwrap.invoke]

22.10.6.6 Helper functions [refwrap.helpers]

22.10.6.7 common_reference related specializations [refwrap.common.ref]

22.10.7 Arithmetic operations [arithmetic.operations]

22.10.7.1 General [arithmetic.operations.general]

22.10.7.2 Class template plus [arithmetic.operations.plus]

22.10.7.3 Class template minus [arithmetic.operations.minus]

22.10.7.4 Class template multiplies [arithmetic.operations.multiplies]

22.10.7.5 Class template divides [arithmetic.operations.divides]

22.10.7.6 Class template modulus [arithmetic.operations.modulus]

22.10.7.7 Class template negate [arithmetic.operations.negate]

22.10.8 Comparisons [comparisons]

22.10.8.1 General [comparisons.general]

22.10.8.2 Class template equal_to [comparisons.equal.to]

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

22.10.8.4 Class template greater [comparisons.greater]

22.10.8.5 Class template less [comparisons.less]

22.10.8.6 Class template greater_equal [comparisons.greater.equal]

22.10.8.7 Class template less_equal [comparisons.less.equal]

22.10.8.8 Class compare_three_way [comparisons.three.way]

22.10.9 Concept-constrained comparisons [range.cmp]

22.10.10 Logical operations [logical.operations]

22.10.10.1 General [logical.operations.general]

22.10.10.2 Class template logical_and [logical.operations.and]

22.10.10.3 Class template logical_or [logical.operations.or]

22.10.10.4 Class template logical_not [logical.operations.not]

22.10.11 Bitwise operations [bitwise.operations]

22.10.11.1 General [bitwise.operations.general]

22.10.11.2 Class template bit_and [bitwise.operations.and]

22.10.11.3 Class template bit_or [bitwise.operations.or]

22.10.11.4 Class template bit_xor [bitwise.operations.xor]

22.10.11.5 Class template bit_not [bitwise.operations.not]

22.10.12 Class identity [func.identity]

22.10.13 Function template not_fn [func.not.fn]

22.10.14 Function templates bind_front and bind_back [func.bind.partial]

22.10.15 Function object binders [func.bind]

22.10.15.1 General [func.bind.general]

22.10.15.2 Class template is_bind_expression [func.bind.isbind]

22.10.15.3 Class template is_placeholder [func.bind.isplace]

22.10.15.4 Function template bind [func.bind.bind]

22.10.15.5 Placeholders [func.bind.place]

22.10.16 Function template mem_fn [func.memfn]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.1 General [func.wrap.general]

22.10.17.2 Class bad_function_call [func.wrap.badcall]

22.10.17.3 Class template function [func.wrap.func]

22.10.17.3.1 General [func.wrap.func.general]

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

22.10.17.3.3 Modifiers [func.wrap.func.mod]

22.10.17.3.4 Capacity [func.wrap.func.cap]

22.10.17.3.5 Invocation [func.wrap.func.inv]

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

22.10.17.3.7 Null pointer comparison operator functions [func.wrap.func.nullptr]

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

22.10.17.4 Move only wrapper [func.wrap.move]

22.10.17.4.1 General [func.wrap.move.general]

22.10.17.4.2 Class template move_only_function [func.wrap.move.class]

22.10.17.4.3 Constructors, assignment, and destructor [func.wrap.move.ctor]

22.10.17.4.4 Invocation [func.wrap.move.inv]

22.10.17.4.5 Utility [func.wrap.move.util]

22.10.18 Searchers [func.search]

22.10.18.1 General [func.search.general]

22.10.18.2 Class template default_searcher [func.search.default]

22.10.18.3 Class template boyer_moore_searcher [func.search.bm]

22.10.18.4 Class template boyer_moore_horspool_searcher [func.search.bmh]

22.10.19 Class template hash [unord.hash]

22.11 Class type_index [type.index]

22.11.1 Header synopsis [type.index.synopsis]

22.11.2 type_index overview [type.index.overview]

22.11.3 type_index members [type.index.members]

22.11.4 Hash support [type.index.hash]

22.12 Execution policies [execpol]

22.12.1 In general [execpol.general]

22.12.2 Header synopsis [execution.syn]

22.12.3 Execution policy type trait [execpol.type]

22.12.4 Sequenced execution policy [execpol.seq]

22.12.5 Parallel execution policy [execpol.par]

22.12.6 Parallel and unsequenced execution policy [execpol.parunseq]

22.12.7 Unsequenced execution policy [execpol.unseq]

22.12.8 Execution policy objects [execpol.objects]

22.13 Primitive numeric conversions [charconv]

22.13.1 Header synopsis [charconv.syn]

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

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

22.14 Formatting [format]

22.14.1 Header synopsis [format.syn]

22.14.2 Format string [format.string]

22.14.2.1 In general [format.string.general]

22.14.2.2 Standard format specifiers [format.string.std]

22.14.3 Error reporting [format.err.report]

22.14.4 Class template basic_format_string [format.fmt.string]

22.14.5 Formatting functions [format.functions]

22.14.6 Formatter [format.formatter]

22.14.6.1 Formatter requirements [formatter.requirements]

22.14.6.2 Concept formattable [format.formattable]

22.14.6.3 Formatter specializations [format.formatter.spec]

22.14.6.4 Formatting escaped characters and strings [format.string.escaped]

22.14.6.5 Class template basic_format_parse_context [format.parse.ctx]

22.14.6.6 Class template basic_format_context [format.context]

22.14.7 Formatting of ranges [format.range]

22.14.7.1 Variable template format_kind [format.range.fmtkind]

22.14.7.2 Class template range_formatter [format.range.formatter]

22.14.7.3 Class template range-default-formatter [format.range.fmtdef]

22.14.7.4 Specialization of range-default-formatter for maps [format.range.fmtmap]

22.14.7.5 Specialization of range-default-formatter for sets [format.range.fmtset]

22.14.7.6 Specialization of range-default-formatter for strings [format.range.fmtstr]

22.14.8 Arguments [format.arguments]

22.14.8.1 Class template basic_format_arg [format.arg]

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

22.14.8.3 Class template basic_format_args [format.args]

22.14.9 Tuple formatter [format.tuple]

22.14.10 Class format_error [format.error]

22.15 Bit manipulation [bit]

22.15.1 General [bit.general]

22.15.2 Header synopsis [bit.syn]

22.15.3 Function template bit_cast [bit.cast]

22.15.4 byteswap [bit.byteswap]

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

22.15.6 Rotating [bit.rotate]

22.15.7 Counting [bit.count]

22.15.8 Endian [bit.endian]

23 Strings library [strings][strings]

23.1 General [strings.general]

23.2 Character traits [char.traits]

23.2.1 General [char.traits.general]

23.2.2 Character traits requirements [char.traits.require]

23.2.3 Traits typedefs [char.traits.typedefs]

23.2.4 char_traits specializations [char.traits.specializations]

23.2.4.1 General [char.traits.specializations.general]

23.2.4.2 struct char_traits [char.traits.specializations.char]

23.2.4.3 struct char_traits<char8_t> [char.traits.specializations.char8.t]

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

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

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

23.3 String view classes [string.view]

23.3.1 General [string.view.general]

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

23.3.3 Class template basic_string_view [string.view.template]

23.3.3.1 General [string.view.template.general]

23.3.3.2 Construction and assignment [string.view.cons]

23.3.3.3 Deduction guides [string.view.deduct]

23.3.3.4 Iterator support [string.view.iterators]

23.3.3.5 Capacity [string.view.capacity]

23.3.3.6 Element access [string.view.access]

23.3.3.7 Modifiers [string.view.modifiers]

23.3.3.8 String operations [string.view.ops]

23.3.3.9 Searching [string.view.find]

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

23.3.5 Inserters and extractors [string.view.io]

23.3.6 Hash support [string.view.hash]

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

23.4 String classes [string.classes]

23.4.1 General [string.classes.general]

23.4.2 Header synopsis [string.syn]

23.4.3 Class template basic_string [basic.string]

23.4.3.1 General [basic.string.general]

23.4.3.2 General requirements [string.require]

23.4.3.3 Constructors and assignment operators [string.cons]

23.4.3.4 Iterator support [string.iterators]

23.4.3.5 Capacity [string.capacity]

23.4.3.6 Element access [string.access]

23.4.3.7 Modifiers [string.modifiers]

23.4.3.7.1 basic_string​::​operator+= [string.op.append]

23.4.3.7.2 basic_string​::​append [string.append]

23.4.3.7.3 basic_string​::​assign [string.assign]

23.4.3.7.4 basic_string​::​insert [string.insert]

23.4.3.7.5 basic_string​::​erase [string.erase]

23.4.3.7.6 basic_string​::​replace [string.replace]

23.4.3.7.7 basic_string​::​copy [string.copy]

23.4.3.7.8 basic_string​::​swap [string.swap]

23.4.3.8 String operations [string.ops]

23.4.3.8.1 Accessors [string.accessors]

23.4.3.8.2 Searching [string.find]

23.4.3.8.3 basic_string​::​substr [string.substr]

23.4.3.8.4 basic_string​::​compare [string.compare]

23.4.3.8.5 basic_string​::​starts_with [string.starts.with]

23.4.3.8.6 basic_string​::​ends_with [string.ends.with]

23.4.3.8.7 basic_string​::​contains [string.contains]

23.4.4 Non-member functions [string.nonmembers]

23.4.4.1 operator+ [string.op.plus]

23.4.4.2 Non-member comparison operator functions [string.cmp]

23.4.4.3 swap [string.special]

23.4.4.4 Inserters and extractors [string.io]

23.4.4.5 Erasure [string.erasure]

23.4.5 Numeric conversions [string.conversions]

23.4.6 Hash support [basic.string.hash]

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

23.5 Null-terminated sequence utilities [c.strings]

23.5.1 Header synopsis [cctype.syn]

23.5.2 Header synopsis [cwctype.syn]

23.5.3 Header synopsis [cstring.syn]

23.5.4 Header synopsis [cwchar.syn]

23.5.5 Header synopsis [cuchar.syn]

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

24 Containers library [containers][containers]

24.1 General [containers.general]

24.2 Requirements [container.requirements]

24.2.1 Preamble [container.requirements.pre]

24.2.2 General containers [container.requirements.general]

24.2.2.1 Introduction [container.intro.reqmts]

24.2.2.2 Container requirements [container.reqmts]

24.2.2.3 Reversible container requirements [container.rev.reqmts]

24.2.2.4 Optional container requirements [container.opt.reqmts]

24.2.2.5 Allocator-aware containers [container.alloc.reqmts]

24.2.3 Container data races [container.requirements.dataraces]

24.2.4 Sequence containers [sequence.reqmts]

24.2.5 Node handles [container.node]

24.2.5.1 Overview [container.node.overview]

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

24.2.5.3 Destructor [container.node.dtor]

24.2.5.4 Observers [container.node.observers]

24.2.5.5 Modifiers [container.node.modifiers]

24.2.6 Insert return type [container.insert.return]

24.2.7 Associative containers [associative.reqmts]

24.2.7.1 General [associative.reqmts.general]

24.2.7.2 Exception safety guarantees [associative.reqmts.except]

24.2.8 Unordered associative containers [unord.req]

24.2.8.1 General [unord.req.general]

24.2.8.2 Exception safety guarantees [unord.req.except]

24.3 Sequence containers [sequences]

24.3.1 In general [sequences.general]

24.3.2 Header synopsis [array.syn]

24.3.3 Header synopsis [deque.syn]

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

24.3.5 Header synopsis [list.syn]

24.3.6 Header synopsis [vector.syn]

24.3.7 Class template array [array]

24.3.7.1 Overview [array.overview]

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

24.3.7.3 Member functions [array.members]

24.3.7.4 Specialized algorithms [array.special]

24.3.7.5 Zero-sized arrays [array.zero]

24.3.7.6 Array creation functions [array.creation]

24.3.7.7 Tuple interface [array.tuple]

24.3.8 Class template deque [deque]

24.3.8.1 Overview [deque.overview]

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

24.3.8.3 Capacity [deque.capacity]

24.3.8.4 Modifiers [deque.modifiers]

24.3.8.5 Erasure [deque.erasure]

24.3.9 Class template forward_list [forward.list]

24.3.9.1 Overview [forward.list.overview]

24.3.9.2 Constructors, copy, and assignment [forward.list.cons]

24.3.9.3 Iterators [forward.list.iter]

24.3.9.4 Element access [forward.list.access]

24.3.9.5 Modifiers [forward.list.modifiers]

24.3.9.6 Operations [forward.list.ops]

24.3.9.7 Erasure [forward.list.erasure]

24.3.10 Class template list [list]

24.3.10.1 Overview [list.overview]

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

24.3.10.3 Capacity [list.capacity]

24.3.10.4 Modifiers [list.modifiers]

24.3.10.5 Operations [list.ops]

24.3.10.6 Erasure [list.erasure]

24.3.11 Class template vector [vector]

24.3.11.1 Overview [vector.overview]

24.3.11.2 Constructors [vector.cons]

24.3.11.3 Capacity [vector.capacity]

24.3.11.4 Data [vector.data]

24.3.11.5 Modifiers [vector.modifiers]

24.3.11.6 Erasure [vector.erasure]

24.3.12 Specialization of vector for bool [vector.bool]

24.3.12.1 Partial class template specialization vector<bool, Allocator> [vector.bool.pspc]

24.3.12.2 Formatter specialization for vector [vector.bool.fmt]

24.4 Associative containers [associative]

24.4.1 In general [associative.general]

24.4.2 Header synopsis [associative.map.syn]

24.4.3 Header synopsis [associative.set.syn]

24.4.4 Class template map [map]

24.4.4.1 Overview [map.overview]

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

24.4.4.3 Element access [map.access]

24.4.4.4 Modifiers [map.modifiers]

24.4.4.5 Erasure [map.erasure]

24.4.5 Class template multimap [multimap]

24.4.5.1 Overview [multimap.overview]

24.4.5.2 Constructors [multimap.cons]

24.4.5.3 Modifiers [multimap.modifiers]

24.4.5.4 Erasure [multimap.erasure]

24.4.6 Class template set [set]

24.4.6.1 Overview [set.overview]

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

24.4.6.3 Erasure [set.erasure]

24.4.7 Class template multiset [multiset]

24.4.7.1 Overview [multiset.overview]

24.4.7.2 Constructors [multiset.cons]

24.4.7.3 Erasure [multiset.erasure]

24.5 Unordered associative containers [unord]

24.5.1 In general [unord.general]

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

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

24.5.4 Class template unordered_map [unord.map]

24.5.4.1 Overview [unord.map.overview]

24.5.4.2 Constructors [unord.map.cnstr]

24.5.4.3 Element access [unord.map.elem]

24.5.4.4 Modifiers [unord.map.modifiers]

24.5.4.5 Erasure [unord.map.erasure]

24.5.5 Class template unordered_multimap [unord.multimap]

24.5.5.1 Overview [unord.multimap.overview]

24.5.5.2 Constructors [unord.multimap.cnstr]

24.5.5.3 Modifiers [unord.multimap.modifiers]

24.5.5.4 Erasure [unord.multimap.erasure]

24.5.6 Class template unordered_set [unord.set]

24.5.6.1 Overview [unord.set.overview]

24.5.6.2 Constructors [unord.set.cnstr]

24.5.6.3 Erasure [unord.set.erasure]

24.5.7 Class template unordered_multiset [unord.multiset]

24.5.7.1 Overview [unord.multiset.overview]

24.5.7.2 Constructors [unord.multiset.cnstr]

24.5.7.3 Erasure [unord.multiset.erasure]

24.6 Container adaptors [container.adaptors]

24.6.1 In general [container.adaptors.general]

24.6.2 Header synopsis [queue.syn]

24.6.3 Header synopsis [stack.syn]

24.6.4 Header <flat_map> synopsis [flat.map.syn]

24.6.5 Header <flat_set> synopsis [flat.set.syn]

24.6.6 Class template queue [queue]

24.6.6.1 Definition [queue.defn]

24.6.6.2 Constructors [queue.cons]

24.6.6.3 Constructors with allocators [queue.cons.alloc]

24.6.6.4 Modifiers [queue.mod]

24.6.6.5 Operators [queue.ops]

24.6.6.6 Specialized algorithms [queue.special]

24.6.7 Class template priority_queue [priority.queue]

24.6.7.1 Overview [priqueue.overview]

24.6.7.2 Constructors [priqueue.cons]

24.6.7.3 Constructors with allocators [priqueue.cons.alloc]

24.6.7.4 Members [priqueue.members]

24.6.7.5 Specialized algorithms [priqueue.special]

24.6.8 Class template stack [stack]

24.6.8.1 General [stack.general]

24.6.8.2 Definition [stack.defn]

24.6.8.3 Constructors [stack.cons]

24.6.8.4 Constructors with allocators [stack.cons.alloc]

24.6.8.5 Modifiers [stack.mod]

24.6.8.6 Operators [stack.ops]

24.6.8.7 Specialized algorithms [stack.special]

24.6.9 Class template flat_map [flat.map]

24.6.9.1 Overview [flat.map.overview]

24.6.9.2 Definition [flat.map.defn]

24.6.9.3 Constructors [flat.map.cons]

24.6.9.4 Capacity [flat.map.capacity]

24.6.9.5 Access [flat.map.access]

24.6.9.6 Modifiers [flat.map.modifiers]

24.6.9.7 Erasure [flat.map.erasure]

24.6.10 Class template flat_multimap [flat.multimap]

24.6.10.1 Overview [flat.multimap.overview]

24.6.10.2 Definition [flat.multimap.defn]

24.6.10.3 Constructors [flat.multimap.cons]

24.6.10.4 Erasure [flat.multimap.erasure]

24.6.11 Class template flat_set [flat.set]

24.6.11.1 Overview [flat.set.overview]

24.6.11.2 Definition [flat.set.defn]

24.6.11.3 Constructors [flat.set.cons]

24.6.11.4 Modifiers [flat.set.modifiers]

24.6.11.5 Erasure [flat.set.erasure]

24.6.12 Class template flat_multiset [flat.multiset]

24.6.12.1 Overview [flat.multiset.overview]

24.6.12.2 Definition [flat.multiset.defn]

24.6.12.3 Constructors [flat.multiset.cons]

24.6.12.4 Modifiers [flat.multiset.modifiers]

24.6.12.5 Erasure [flat.multiset.erasure]

24.6.13 Container adaptors formatting [container.adaptors.format]

24.7 Views [views]

24.7.1 General [views.general]

24.7.2 Contiguous access [views.contiguous]

24.7.2.1 Header synopsis [span.syn]

24.7.2.2 Class template span [views.span]

24.7.2.2.1 Overview [span.overview]

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

24.7.2.2.3 Deduction guides [span.deduct]

24.7.2.2.4 Subviews [span.sub]

24.7.2.2.5 Observers [span.obs]

24.7.2.2.6 Element access [span.elem]

24.7.2.2.7 Iterator support [span.iterators]

24.7.2.3 Views of object representation [span.objectrep]

24.7.3 Multidimensional access [views.multidim]

24.7.3.1 Overview [mdspan.overview]

24.7.3.2 Header synopsis [mdspan.syn]

24.7.3.3 Class template extents [mdspan.extents]

24.7.3.3.1 Overview [mdspan.extents.overview]

24.7.3.3.2 Exposition-only helpers [mdspan.extents.expo]

24.7.3.3.3 Constructors [mdspan.extents.cons]

24.7.3.3.4 Observers of the multidimensional index space [mdspan.extents.obs]

24.7.3.3.5 Comparison operators [mdspan.extents.cmp]

24.7.3.3.6 Alias template dextents [mdspan.extents.dextents]

24.7.3.4 Layout mapping [mdspan.layout]

24.7.3.4.1 General [mdspan.layout.general]

24.7.3.4.2 Requirements [mdspan.layout.reqmts]

24.7.3.4.3 Layout mapping policy requirements [mdspan.layout.policy.reqmts]

24.7.3.4.4 Layout mapping policies [mdspan.layout.policy.overview]

24.7.3.4.5 Class template layout_left​::​mapping [mdspan.layout.left]

24.7.3.4.5.1 Overview [mdspan.layout.left.overview]

24.7.3.4.5.2 Constructors [mdspan.layout.left.cons]

24.7.3.4.5.3 Observers [mdspan.layout.left.obs]

24.7.3.4.6 Class template layout_right​::​mapping [mdspan.layout.right]

24.7.3.4.6.1 Overview [mdspan.layout.right.overview]

24.7.3.4.6.2 Constructors [mdspan.layout.right.cons]

24.7.3.4.6.3 Observers [mdspan.layout.right.obs]

24.7.3.4.7 Class template layout_stride​::​mapping [mdspan.layout.stride]

24.7.3.4.7.1 Overview [mdspan.layout.stride.overview]

24.7.3.4.7.2 Exposition-only helpers [mdspan.layout.stride.expo]

24.7.3.4.7.3 Constructors [mdspan.layout.stride.cons]

24.7.3.4.7.4 Observers [mdspan.layout.stride.obs]

24.7.3.5 Accessor policy [mdspan.accessor]

24.7.3.5.1 General [mdspan.accessor.general]

24.7.3.5.2 Requirements [mdspan.accessor.reqmts]

24.7.3.5.3 Class template default_accessor [mdspan.accessor.default]

24.7.3.5.3.1 Overview [mdspan.accessor.default.overview]

24.7.3.5.3.2 Members [mdspan.accessor.default.members]

24.7.3.6 Class template mdspan [mdspan.mdspan]

24.7.3.6.1 Overview [mdspan.mdspan.overview]

24.7.3.6.2 Constructors [mdspan.mdspan.cons]

24.7.3.6.3 Members [mdspan.mdspan.members]

25 Iterators library [iterators][iterators]

25.1 General [iterators.general]

25.2 Header synopsis [iterator.synopsis]

25.3 Iterator requirements [iterator.requirements]

25.3.1 In general [iterator.requirements.general]

25.3.2 Associated types [iterator.assoc.types]

25.3.2.1 Incrementable traits [incrementable.traits]

25.3.2.2 Indirectly readable traits [readable.traits]

25.3.2.3 Iterator traits [iterator.traits]

25.3.3 Customization point objects [iterator.cust]

25.3.3.1 ranges​::​iter_move [iterator.cust.move]

25.3.3.2 ranges​::​iter_swap [iterator.cust.swap]

25.3.4 Iterator concepts [iterator.concepts]

25.3.4.1 General [iterator.concepts.general]

25.3.4.2 Concept indirectly_readable [iterator.concept.readable]

25.3.4.3 Concept indirectly_writable [iterator.concept.writable]

25.3.4.4 Concept weakly_incrementable [iterator.concept.winc]

25.3.4.5 Concept incrementable [iterator.concept.inc]

25.3.4.6 Concept input_or_output_iterator [iterator.concept.iterator]

25.3.4.7 Concept sentinel_for [iterator.concept.sentinel]

25.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]

25.3.4.9 Concept input_iterator [iterator.concept.input]

25.3.4.10 Concept output_iterator [iterator.concept.output]

25.3.4.11 Concept forward_iterator [iterator.concept.forward]

25.3.4.12 Concept bidirectional_iterator [iterator.concept.bidir]

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

25.3.4.14 Concept contiguous_iterator [iterator.concept.contiguous]

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

25.3.5.1 General [iterator.cpp17.general]

25.3.5.2 Cpp17Iterator [iterator.iterators]

25.3.5.3 Input iterators [input.iterators]

25.3.5.4 Output iterators [output.iterators]

25.3.5.5 Forward iterators [forward.iterators]

25.3.5.6 Bidirectional iterators [bidirectional.iterators]

25.3.5.7 Random access iterators [random.access.iterators]

25.3.6 Indirect callable requirements [indirectcallable]

25.3.6.1 General [indirectcallable.general]

25.3.6.2 Indirect callable traits [indirectcallable.traits]

25.3.6.3 Indirect callables [indirectcallable.indirectinvocable]

25.3.6.4 Class template projected [projected]

25.3.7 Common algorithm requirements [alg.req]

25.3.7.1 General [alg.req.general]

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

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

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

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

25.3.7.6 Concept permutable [alg.req.permutable]

25.3.7.7 Concept mergeable [alg.req.mergeable]

25.3.7.8 Concept sortable [alg.req.sortable]

25.4 Iterator primitives [iterator.primitives]

25.4.1 General [iterator.primitives.general]

25.4.2 Standard iterator tags [std.iterator.tags]

25.4.3 Iterator operations [iterator.operations]

25.4.4 Range iterator operations [range.iter.ops]

25.4.4.1 General [range.iter.ops.general]

25.4.4.2 ranges​::​advance [range.iter.op.advance]

25.4.4.3 ranges​::​distance [range.iter.op.distance]

25.4.4.4 ranges​::​next [range.iter.op.next]

25.4.4.5 ranges​::​prev [range.iter.op.prev]

25.5 Iterator adaptors [predef.iterators]

25.5.1 Reverse iterators [reverse.iterators]

25.5.1.1 General [reverse.iterators.general]

25.5.1.2 Class template reverse_iterator [reverse.iterator]

25.5.1.3 Requirements [reverse.iter.requirements]

25.5.1.4 Construction and assignment [reverse.iter.cons]

25.5.1.5 Conversion [reverse.iter.conv]

25.5.1.6 Element access [reverse.iter.elem]

25.5.1.7 Navigation [reverse.iter.nav]

25.5.1.8 Comparisons [reverse.iter.cmp]

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

25.5.2 Insert iterators [insert.iterators]

25.5.2.1 General [insert.iterators.general]

25.5.2.2 Class template back_insert_iterator [back.insert.iterator]

25.5.2.2.1 Operations [back.insert.iter.ops]

25.5.2.2.2 back_inserter [back.inserter]

25.5.2.3 Class template front_insert_iterator [front.insert.iterator]

25.5.2.3.1 Operations [front.insert.iter.ops]

25.5.2.3.2 front_inserter [front.inserter]

25.5.2.4 Class template insert_iterator [insert.iterator]

25.5.2.4.1 Operations [insert.iter.ops]

25.5.2.4.2 inserter [inserter]

25.5.3 Constant iterators and sentinels [const.iterators]

25.5.3.1 General [const.iterators.general]

25.5.3.2 Alias templates [const.iterators.alias]

25.5.3.3 Class template basic_const_iterator [const.iterators.iterator]

25.5.3.4 Member types [const.iterators.types]

25.5.3.5 Operations [const.iterators.ops]

25.5.4 Move iterators and sentinels [move.iterators]

25.5.4.1 General [move.iterators.general]

25.5.4.2 Class template move_iterator [move.iterator]

25.5.4.3 Requirements [move.iter.requirements]

25.5.4.4 Construction and assignment [move.iter.cons]

25.5.4.5 Conversion [move.iter.op.conv]

25.5.4.6 Element access [move.iter.elem]

25.5.4.7 Navigation [move.iter.nav]

25.5.4.8 Comparisons [move.iter.op.comp]

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

25.5.4.10 Class template move_sentinel [move.sentinel]

25.5.4.11 Operations [move.sent.ops]

25.5.5 Common iterators [iterators.common]

25.5.5.1 Class template common_iterator [common.iterator]

25.5.5.2 Associated types [common.iter.types]

25.5.5.3 Constructors and conversions [common.iter.const]

25.5.5.4 Accessors [common.iter.access]

25.5.5.5 Navigation [common.iter.nav]

25.5.5.6 Comparisons [common.iter.cmp]

25.5.5.7 Customizations [common.iter.cust]

25.5.6 Default sentinel [default.sentinel]

25.5.7 Counted iterators [iterators.counted]

25.5.7.1 Class template counted_iterator [counted.iterator]

25.5.7.2 Constructors and conversions [counted.iter.const]

25.5.7.3 Accessors [counted.iter.access]

25.5.7.4 Element access [counted.iter.elem]

25.5.7.5 Navigation [counted.iter.nav]

25.5.7.6 Comparisons [counted.iter.cmp]