Working Draft
Programming Languages — C++

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

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

Contents

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.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 Characters [lex.char]

5.3.1 Character sets [lex.charset]

5.3.2 Universal character names [lex.universal.char]

5.5 Preprocessing tokens [lex.pptoken]

5.6 Header names [lex.header]

5.7 Preprocessing numbers [lex.ppnumber]

5.8 Operators and punctuators [lex.operators]

5.9 Alternative tokens [lex.digraph]

5.11 Identifiers [lex.name]

5.12 Keywords [lex.key]

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 Unevaluated strings [lex.string.uneval]

5.13.7 Boolean literals [lex.bool]

5.13.8 Pointer literals [lex.nullptr]

5.13.9 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.2 Point of declaration [basic.scope.pdecl]

6.4.4 Function parameter scope [basic.scope.param]

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.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.6 Elaborated type specifiers [basic.lookup.elab]

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

6.7 Memory and objects [basic.memobj]

6.7.1 Memory model [intro.memory]

6.7.2 Object model [intro.object]

6.7.5 Indeterminate and erroneous values [basic.indet]

6.7.6 Storage duration [basic.stc]

6.7.6.2 Static storage duration [basic.stc.static]

6.7.6.3 Thread storage duration [basic.stc.thread]

6.7.6.4 Automatic storage duration [basic.stc.auto]

6.7.7 Temporary objects [class.temporary]

6.8 Types [basic.types]

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.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.3 Forward progress [intro.progress]

6.9.3 Start and termination [basic.start]

6.9.3.2 Static initialization [basic.start.static]

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

7 Expressions [expr][expr]

7.1 Preamble [expr.pre]

7.2 Properties of expressions [expr.prop]

7.2.1 Value category [basic.lval]

7.2.3 Context dependence [expr.context]

7.3 Standard conversions [conv]

7.3.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.6 Compound expressions [expr.compound]

7.6.1 Postfix expressions [expr.post]

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.8 Type identification [expr.typeid]

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

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

7.6.5 Multiplicative operators [expr.mul]

7.6.6 Additive operators [expr.add]

7.6.7 Shift operators [expr.shift]

7.6.8 Three-way comparison operator [expr.spaceship]

7.6.9 Relational operators [expr.rel]

7.6.10 Equality operators [expr.eq]

7.6.11 Bitwise AND operator [expr.bit.and]

7.6.12 Bitwise exclusive OR operator [expr.xor]

7.6.13 Bitwise inclusive OR operator [expr.or]

7.6.14 Logical AND operator [expr.log.and]

7.6.15 Logical OR operator [expr.log.or]

7.6.16 Conditional operator [expr.cond]

7.6.17 Yielding a value [expr.yield]

7.6.18 Throwing an exception [expr.throw]

7.6.19 Assignment and compound assignment operators [expr.assign]

7.6.20 Comma operator [expr.comma]

7.7 Constant expressions [expr.const]

8 Statements [stmt][stmt]

8.1 Preamble [stmt.pre]

8.3 Expression statement [stmt.expr]

8.4 Compound statement or block [stmt.block]

8.5 Selection statements [stmt.select]

8.5.2 The if statement [stmt.if]

8.5.3 The switch statement [stmt.switch]

8.6 Iteration statements [stmt.iter]

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.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]

9.1 Preamble [dcl.pre]

9.2 Specifiers [dcl.spec]

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.2 The cv-qualifiers [dcl.type.cv]

9.2.9.3 Simple type specifiers [dcl.type.simple]

9.2.9.4 Pack indexing specifier [dcl.type.pack.index]

9.2.9.5 Elaborated type specifiers [dcl.type.elab]

9.2.9.6 Decltype specifiers [dcl.type.decltype]

9.2.9.7 Placeholder type specifiers [dcl.spec.auto]

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

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

9.3 Declarators [dcl.decl]

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.3 References [dcl.ref]

9.3.4.4 Pointers to members [dcl.mptr]

9.3.4.6 Functions [dcl.fct]

9.3.4.7 Default arguments [dcl.fct.default]

9.4 Initializers [dcl.init]

9.4.3 Character arrays [dcl.init.string]

9.4.5 List-initialization [dcl.init.list]

9.5 Function definitions [dcl.fct.def]

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.2 Namespace definition [namespace.def]

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.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 Indeterminate storage [dcl.attr.indet]

9.12.8 Likelihood attributes [dcl.attr.likelihood]

9.12.9 Maybe unused attribute [dcl.attr.unused]

9.12.10 Nodiscard attribute [dcl.attr.nodiscard]

9.12.11 Noreturn attribute [dcl.attr.noreturn]

9.12.12 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.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.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.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.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.6 Local class declarations [class.local]

11.7 Derived classes [class.derived]

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.2 Access specifiers [class.access.spec]

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

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.9 Initialization [class.init]

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.2 Candidate functions and argument lists [over.match.funcs]

12.2.2.2 Function call syntax [over.match.call]

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.2 Implicit conversion sequences [over.best.ics]

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.2 Unary operators [over.unary]

12.4.3 Binary operators [over.binary]

12.4.3.2 Simple assignment [over.assign]

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.2 Type template arguments [temp.arg.type]

13.4.3 Constant template arguments [temp.arg.nontype]

13.4.4 Template template arguments [temp.arg.template]

13.5 Template constraints [temp.constr]

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.2 Class templates [temp.class]

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.6 Partial specialization [temp.spec.partial]

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.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.2 Locally declared names [temp.local]

13.8.3 Dependent names [temp.dep]

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.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.2 Explicit template argument specification [temp.arg.explicit]

13.10.3 Template argument deduction [temp.deduct]

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.2 Throwing an exception [except.throw]

14.3 Stack unwinding [except.ctor]

14.4 Handling an exception [except.handle]

14.5 Exception specifications [except.spec]

14.6 Special functions [except.special]

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

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.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.2 The C standard library [library.c]

16.4 Library-wide requirements [requirements]

16.4.2 Library contents and organization [organization]

16.4.2.2 Library contents [contents]

16.4.2.5 Freestanding implementations [compliance]

16.4.4 Requirements on types and expressions [utility.requirements]

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.5 Constraints on programs [constraints]

16.4.5.2 Namespace use [namespace.constraints]

16.4.5.2.3 Namespaces for future standardization [namespace.future]

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.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.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.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.2 Common definitions [support.types]

17.2.1 Header <cstddef> synopsis [cstddef.syn]

17.2.2 Header <cstdlib> synopsis [cstdlib.syn]

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

17.3.3 Header <limits> synopsis [limits.syn]

17.3.4 Enum float_round_style [round.style]

17.3.5 Class template numeric_limits [numeric.limits]

17.3.5.2 numeric_limits members [numeric.limits.members]

17.3.5.3 numeric_limits specializations [numeric.special]

17.3.6 Header <climits> synopsis [climits.syn]

17.3.7 Header <cfloat> synopsis [cfloat.syn]

17.4 Arithmetic types [support.arith.types]

17.4.1 Header <cstdint> synopsis [cstdint.syn]

17.4.2 Header <stdfloat> synopsis [stdfloat.syn]

17.5 Startup and termination [support.start.term]

17.6 Dynamic memory management [support.dynamic]

17.6.2 Header <new> synopsis [new.syn]

17.6.3 Storage allocation and deallocation [new.delete]

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

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

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.2 Header <typeinfo> 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.7.6 Header <typeindex> synopsis [type.index.synopsis]

17.7.7 Class type_index [type.index]

17.9 Exception handling [support.exception]

17.9.2 Header <exception> 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.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.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 <compare> synopsis [compare.syn]

17.11.2 Comparison category types [cmp.categories]

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.13 Other runtime support [support.runtime]

17.13.2 Header <cstdarg> synopsis [cstdarg.syn]

17.13.3 Header <csetjmp> synopsis [csetjmp.syn]

17.13.4 Header <csignal> synopsis [csignal.syn]

17.13.5 Signal handlers [support.signal]

17.14 C headers [support.c.headers]

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]

18 Concepts library [concepts][concepts]

18.2 Equality preservation [concepts.equality]

18.3 Header <concepts> synopsis [concepts.syn]

18.4 Language-related concepts [concepts.lang]

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.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.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.2 Exception classes [std.exceptions]

19.2.2 Header <stdexcept> 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.2 Header <cassert> synopsis [cassert.syn]

19.3.3 The assert macro [assertions.assert]

19.4 Error numbers [errno]

19.4.2 Header <cerrno> synopsis [cerrno.syn]

19.7 Debugging [debugging]

19.7.2 Header <debugging> synopsis [debugging.syn]

20 Memory management library [mem][mem]

20.3 Smart pointers [smartptr]

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.2 Public member functions [mem.res.public]

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

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.5 Class template scoped_allocator_adaptor [allocator.adaptor]

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

21 Metaprogramming library [meta][meta]

21.2 Compile-time integer sequences [intseq]

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.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.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.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.2 Header <ratio> 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.2 Utility components [utility]

22.2.1 Header <utility> synopsis [utility.syn]

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.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.2 Header <tuple> synopsis [tuple.syn]

22.4.3 Concept tuple-like [tuple.like]

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.2 Header <optional> synopsis [optional.syn]

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.6 Variants [variant]

22.6.2 Header <variant> synopsis [variant.syn]

22.6.4 variant helper classes [variant.helper]

22.6.5 Value access [variant.get]

22.6.6 Relational operators [variant.relops]

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.2 Header <any> synopsis [any.synop]

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

22.7.5 Non-member functions [any.nonmembers]

22.9 Bitsets [bitset]

22.9.1 Header <bitset> synopsis [bitset.syn]

22.9.3 bitset hash support [bitset.hash]

22.9.4 bitset operators [bitset.operators]

22.10 Function objects [function.objects]

22.10.2 Header <functional> 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.7 Helper functions [refwrap.helpers]

22.10.6.8 common_reference related specializations [refwrap.common.ref]

22.10.8 Comparisons [comparisons]

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.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.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.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.16 Function template mem_fn [func.memfn]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.2 Class bad_function_call [func.wrap.badcall]

22.10.17.6 Non-owning wrapper [func.wrap.ref]

22.10.17.6.2 Class template function_ref [func.wrap.ref.class]

22.10.17.6.3 Constructors and assignment operators [func.wrap.ref.ctor]

22.10.18 Searchers [func.search]

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 Bit manipulation [bit]

22.11.2 Header <bit> synopsis [bit.syn]

22.11.3 Function template bit_cast [bit.cast]

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

22.12 Header <stdbit.h> synopsis [stdbit.h.syn]

23 Containers library [containers][containers]

23.2 Requirements [container.requirements]

23.2.2 General containers [container.requirements.general]

23.2.2.2 Container requirements [container.reqmts]

23.2.2.3 Reversible container requirements [container.rev.reqmts]

23.2.2.4 Optional container requirements [container.opt.reqmts]

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

23.2.4 Sequence containers [sequence.reqmts]

23.2.8 Unordered associative containers [unord.req]

23.2.8.2 Exception safety guarantees [unord.req.except]

23.3 Sequence containers [sequences]

23.3.2 Header <array> synopsis [array.syn]

23.3.3 Class template array [array]

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

23.3.3.3 Member functions [array.members]

23.3.3.4 Specialized algorithms [array.special]

23.3.3.5 Zero-sized arrays [array.zero]

23.3.3.6 Array creation functions [array.creation]

23.3.3.7 Tuple interface [array.tuple]

23.3.4 Header <deque> synopsis [deque.syn]

23.3.5 Class template deque [deque]

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

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

23.3.8 Header <list> synopsis [list.syn]

23.3.9 Class template list [list]

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

23.3.9.5 Operations [list.ops]

23.3.10 Header <vector> synopsis [vector.syn]

23.3.12 Specialization of vector for bool [vector.bool]

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

23.3.12.2 Formatter specialization for vector<bool> [vector.bool.fmt]

23.3.13 Header <inplace_vector> synopsis [inplace.vector.syn]

23.4 Associative containers [associative]

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

23.4.3 Class template map [map]

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

23.4.3.3 Element access [map.access]

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

23.4.6 Class template set [set]

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

23.5 Unordered associative containers [unord]

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

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

23.6 Container adaptors [container.adaptors]

23.6.2 Header <queue> synopsis [queue.syn]

23.6.3 Class template queue [queue]

23.6.3.2 Constructors [queue.cons]

23.6.3.3 Constructors with allocators [queue.cons.alloc]

23.6.3.6 Specialized algorithms [queue.special]

23.6.4 Class template priority_queue [priority.queue]

23.6.4.3 Constructors with allocators [priqueue.cons.alloc]

23.6.4.5 Specialized algorithms [priqueue.special]

23.6.5 Header <stack> synopsis [stack.syn]

23.6.6 Class template stack [stack]

23.6.6.3 Constructors [stack.cons]

23.6.6.4 Constructors with allocators [stack.cons.alloc]

23.6.6.7 Specialized algorithms [stack.special]

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

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

23.6.13 Container adaptors formatting [container.adaptors.format]

23.7 Views [views]

23.7.2 Contiguous access [views.contiguous]

23.7.2.1 Header <span> synopsis [span.syn]

23.7.2.2 Class template span [views.span]

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

23.7.2.2.3 Deduction guides [span.deduct]

23.7.2.2.6 Element access [span.elem]

23.7.2.2.7 Iterator support [span.iterators]

23.7.2.3 Views of object representation [span.objectrep]

23.7.3 Multidimensional access [views.multidim]

23.7.3.2 Header <mdspan> synopsis [mdspan.syn]

23.7.3.3 Class template extents [mdspan.extents]

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

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

23.7.3.3.5 Comparison operators [mdspan.extents.cmp]

23.7.3.3.6 Alias template dextents [mdspan.extents.dextents]

23.7.3.3.7 Alias template dims [mdspan.extents.dims]

23.7.3.4 Layout mapping [mdspan.layout]

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

23.7.3.7 submdspan [mdspan.sub]

23.7.3.7.3 submdspan_mapping_result [mdspan.sub.map.result]

23.7.3.7.4 Exposition-only helpers [mdspan.sub.helpers]

23.7.3.7.5 submdspan_extents function [mdspan.sub.extents]

23.7.3.7.6 Specializations of submdspan_mapping [mdspan.sub.map]

23.7.3.7.6.2 layout_left specialization of submdspan_mapping [mdspan.sub.map.left]

23.7.3.7.6.3 layout_right specialization of submdspan_mapping [mdspan.sub.map.right]

23.7.3.7.6.4 layout_stride specialization of submdspan_mapping [mdspan.sub.map.stride]

23.7.3.7.6.5 layout_left_padded specialization of submdspan_mapping [mdspan.sub.map.leftpad]

23.7.3.7.6.6 layout_right_padded specialization of submdspan_mapping [mdspan.sub.map.rightpad]

23.7.3.7.7 submdspan function template [mdspan.sub.sub]

24 Iterators library [iterators][iterators]

24.2 Header <iterator> synopsis [iterator.synopsis]

24.3 Iterator requirements [iterator.requirements]

24.3.2 Associated types [iterator.assoc.types]

24.3.2.1 Incrementable traits [incrementable.traits]

24.3.2.2 Indirectly readable traits [readable.traits]

24.3.2.3 Iterator traits [iterator.traits]

24.3.3 Customization point objects [iterator.cust]

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

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

24.3.4 Iterator concepts [iterator.concepts]

24.3.4.2 Concept indirectly_readable [iterator.concept.readable]

24.3.4.3 Concept indirectly_writable [iterator.concept.writable]

24.3.4.4 Concept weakly_incrementable [iterator.concept.winc]

24.3.4.5 Concept incrementable [iterator.concept.inc]

24.3.4.6 Concept input_or_output_iterator [iterator.concept.iterator]

24.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]

24.3.4.9 Concept input_iterator [iterator.concept.input]

24.3.4.10 Concept output_iterator [iterator.concept.output]

24.3.4.11 Concept forward_iterator [iterator.concept.forward]

24.3.4.12 Concept bidirectional_iterator [iterator.concept.bidir]

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

24.3.4.14 Concept contiguous_iterator [iterator.concept.contiguous]

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

24.3.5.3 Input iterators [input.iterators]

24.3.5.4 Output iterators [output.iterators]

24.3.5.5 Forward iterators [forward.iterators]

24.3.5.6 Bidirectional iterators [bidirectional.iterators]

24.3.5.7 Random access iterators [random.access.iterators]

24.3.6 Indirect callable requirements [indirectcallable]

24.3.6.2 Indirect callable traits [indirectcallable.traits]

24.3.6.4 Class template projected [projected]

24.3.7 Common algorithm requirements [alg.req]

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

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

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

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

24.3.7.6 Concept permutable [alg.req.permutable]

24.3.7.7 Concept mergeable [alg.req.mergeable]

24.3.7.8 Concept sortable [alg.req.sortable]

24.4 Iterator primitives [iterator.primitives]

24.4.2 Standard iterator tags [std.iterator.tags]

24.4.3 Iterator operations [iterator.operations]

24.4.4 Range iterator operations [range.iter.ops]

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

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

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

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

24.5 Iterator adaptors [predef.iterators]

24.5.3 Constant iterators and sentinels [const.iterators]

24.5.3.3 Class template basic_const_iterator [const.iterators.iterator]

24.5.4 Move iterators and sentinels [move.iterators]

24.5.4.2 Class template move_iterator [move.iterator]

24.5.4.4 Construction and assignment [move.iter.cons]

24.5.4.6 Element access [move.iter.elem]

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

24.5.4.10 Class template move_sentinel [move.sentinel]

24.5.5 Common iterators [iterators.common]

24.5.5.1 Class template common_iterator [common.iterator]

24.5.5.2 Associated types [common.iter.types]

24.5.5.3 Constructors and conversions [common.iter.const]

24.5.6 Default sentinel [default.sentinel]

24.5.7 Counted iterators [iterators.counted]

24.5.7.1 Class template counted_iterator [counted.iterator]

24.5.7.2 Constructors and conversions [counted.iter.const]

24.5.8 Unreachable sentinel [unreachable.sentinel]

24.7 Range access [iterator.range]

25 Ranges library [ranges][ranges]

25.2 Header <ranges> synopsis [ranges.syn]

25.3 Range access [range.access]

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

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

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

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

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

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

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

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

25.3.10 ranges​::​size [range.prim.size]

25.3.11 ranges​::​ssize [range.prim.ssize]

25.3.12 ranges​::​empty [range.prim.empty]

25.3.13 ranges​::​data [range.prim.data]

25.3.14 ranges​::​cdata [range.prim.cdata]

25.4 Range requirements [range.req]

25.4.3 Sized ranges [range.sized]

25.4.5 Other range refinements [range.refinements]

25.6 Range factories [range.factories]

25.6.4 Iota view [range.iota]

25.6.4.2 Class template iota_view [range.iota.view]

25.6.4.3 Class iota_view​::​iterator [range.iota.iterator]

25.6.4.4 Class iota_view​::​sentinel [range.iota.sentinel]

25.6.5 Repeat view [range.repeat]

25.6.5.2 Class template repeat_view [range.repeat.view]

25.6.5.3 Class repeat_view​::​iterator [range.repeat.iterator]

25.6.6 Istream view [range.istream]

25.6.6.2 Class template basic_istream_view [range.istream.view]

25.6.6.3 Class basic_istream_view​::​iterator [range.istream.iterator]

25.7 Range adaptors [range.adaptors]

25.7.2 Range adaptor objects [range.adaptor.object]

25.7.3 Movable wrapper [range.move.wrap]

25.7.4 Non-propagating cache [range.nonprop.cache]

25.7.5 Range adaptor helpers [range.adaptor.helpers]

25.7.6 All view [range.all]

25.7.6.2 Class template ref_view [range.ref.view]

25.7.6.3 Class template owning_view [range.owning.view]

25.7.8 Filter view [range.filter]

25.7.8.2 Class template filter_view [range.filter.view]

25.7.8.3 Class filter_view​::​iterator [range.filter.iterator]

25.7.8.4 Class filter_view​::​sentinel [range.filter.sentinel]

25.7.9 Transform view [range.transform]

25.7.9.2 Class template transform_view [range.transform.view]

25.7.9.3 Class template transform_view​::​iterator [range.transform.iterator]

25.7.9.4 Class template transform_view​::​sentinel [range.transform.sentinel]

25.7.10 Take view [range.take]

25.7.10.2 Class template take_view [range.take.view]

25.7.10.3 Class template take_view​::​sentinel [range.take.sentinel]

25.7.11 Take while view [range.take.while]

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

25.7.11.3 Class template take_while_view​::​sentinel [range.take.while.sentinel]

25.7.14 Join view [range.join]

25.7.14.2 Class template join_view [range.join.view]

25.7.14.3 Class template join_view​::​iterator [range.join.iterator]

25.7.14.4 Class template join_view​::​sentinel [range.join.sentinel]

25.7.15 Join with view [range.join.with]

25.7.15.2 Class template join_with_view [range.join.with.view]

25.7.15.3 Class template join_with_view​::​iterator [range.join.with.iterator]

25.7.15.4 Class template join_with_view​::​sentinel [range.join.with.sentinel]

25.7.16 Lazy split view [range.lazy.split]

25.7.16.2 Class template lazy_split_view [range.lazy.split.view]

25.7.16.3 Class template lazy_split_view​::​outer-iterator [range.lazy.split.outer]

25.7.16.4 Class lazy_split_view​::​outer-iterator​::​value_type [range.lazy.split.outer.value]

25.7.16.5 Class template lazy_split_view​::​inner-iterator [range.lazy.split.inner]

25.7.17 Split view [range.split]

25.7.17.2 Class template split_view [range.split.view]

25.7.17.3 Class split_view​::​iterator [range.split.iterator]

25.7.17.4 Class split_view​::​sentinel [range.split.sentinel]

25.7.18 Concat view [range.concat]

25.7.18.2 Class template concat_view [range.concat.view]

25.7.18.3 Class concat_view​::​iterator [range.concat.iterator]

25.7.23 Elements view [range.elements]

25.7.23.2 Class template elements_view [range.elements.view]

25.7.23.3 Class template elements_view​::​iterator [range.elements.iterator]

25.7.23.4 Class template elements_view​::​sentinel [range.elements.sentinel]

25.7.24 Enumerate view [range.enumerate]

25.7.24.2 Class template enumerate_view [range.enumerate.view]

25.7.24.3 Class template enumerate_view​::​iterator [range.enumerate.iterator]

25.7.24.4 Class template enumerate_view​::​sentinel [range.enumerate.sentinel]

25.7.25 Zip view [range.zip]

25.7.25.2 Class template zip_view [range.zip.view]

25.7.25.3 Class template zip_view​::​iterator [range.zip.iterator]

25.7.25.4 Class template zip_view​::​sentinel [range.zip.sentinel]

25.7.26 Zip transform view [range.zip.transform]

25.7.26.2 Class template zip_transform_view [range.zip.transform.view]

25.7.26.3 Class template zip_transform_view​::​iterator [range.zip.transform.iterator]

25.7.26.4 Class template zip_transform_view​::​sentinel [range.zip.transform.sentinel]

25.7.27 Adjacent view [range.adjacent]

25.7.27.2 Class template adjacent_view [range.adjacent.view]

25.7.27.3 Class template adjacent_view​::​iterator [range.adjacent.iterator]

25.7.27.4 Class template adjacent_view​::​sentinel [range.adjacent.sentinel]

25.7.28 Adjacent transform view [range.adjacent.transform]

25.7.28.2 Class template adjacent_transform_view [range.adjacent.transform.view]

25.7.28.3 Class template adjacent_transform_view​::​iterator [range.adjacent.transform.iterator]

25.7.28.4 Class template adjacent_transform_view​::​sentinel [range.adjacent.transform.sentinel]

25.7.29 Chunk view [range.chunk]

25.7.29.2 Class template chunk_view for input ranges [range.chunk.view.input]

25.7.29.3 Class chunk_view​::​outer-iterator [range.chunk.outer.iter]

25.7.29.4 Class chunk_view​::​outer-iterator​::​value_type [range.chunk.outer.value]

25.7.29.5 Class chunk_view​::​inner-iterator [range.chunk.inner.iter]

25.7.29.6 Class template chunk_view for forward ranges [range.chunk.view.fwd]

25.7.29.7 Class template chunk_view​::​iterator for forward ranges [range.chunk.fwd.iter]

25.7.30 Slide view [range.slide]

25.7.30.2 Class template slide_view [range.slide.view]

25.7.30.3 Class template slide_view​::​iterator [range.slide.iterator]

25.7.30.4 Class slide_view​::​sentinel [range.slide.sentinel]

25.7.31 Chunk by view [range.chunk.by]

25.7.31.2 Class template chunk_by_view [range.chunk.by.view]

25.7.31.3 Class chunk_by_view​::​iterator [range.chunk.by.iter]

25.7.32 Stride view [range.stride]

25.7.32.2 Class template stride_view [range.stride.view]

25.7.32.3 Class template stride_view​::​iterator [range.stride.iterator]

25.7.33 Cartesian product view [range.cartesian]

25.7.33.2 Class template cartesian_product_view [range.cartesian.view]

25.7.33.3 Class template cartesian_product_view​::​iterator [range.cartesian.iterator]

25.7.34 Cache latest view [range.cache.latest]

25.7.34.2 Class template cache_latest_view [range.cache.latest.view]

25.7.34.3 Class cache_latest_view​::​iterator [range.cache.latest.iterator]

25.7.34.4 Class cache_latest_view​::​sentinel [range.cache.latest.sentinel]

25.8 Range generators [coro.generator]

25.8.2 Header <generator> synopsis [generator.syn]

25.8.3 Class template generator [coro.generator.class]

25.8.5 Class generator​::​promise_type [coro.generator.promise]

25.8.6 Class generator​::​iterator [coro.generator.iterator]

26 Algorithms library [algorithms][algorithms]

26.2 Algorithms requirements [algorithms.requirements]

26.3 Parallel algorithms [algorithms.parallel]

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

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

26.3.4 Parallel algorithm exceptions [algorithms.parallel.exceptions]

26.3.5 ExecutionPolicy algorithm overloads [algorithms.parallel.overloads]

26.3.6 Execution policies [execpol]

26.3.6.2 Execution policy type trait [execpol.type]

26.3.6.3 Sequenced execution policy [execpol.seq]

26.3.6.4 Parallel execution policy [execpol.par]

26.3.6.5 Parallel and unsequenced execution policy [execpol.parunseq]

26.3.6.6 Unsequenced execution policy [execpol.unseq]

26.3.6.7 Execution policy objects [execpol.objects]

26.4 Header <algorithm> synopsis [algorithm.syn]

26.5 Algorithm result types [algorithms.results]

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

26.10 Generalized numeric operations [numeric.ops]

26.10.5 Inner product [inner.product]

26.10.6 Transform reduce [transform.reduce]

26.10.8 Exclusive scan [exclusive.scan]

26.10.9 Inclusive scan [inclusive.scan]

26.10.10 Transform exclusive scan [transform.exclusive.scan]

26.10.11 Transform inclusive scan [transform.inclusive.scan]

26.10.12 Adjacent difference [adjacent.difference]

26.10.14 Greatest common divisor [numeric.ops.gcd]

26.10.15 Least common multiple [numeric.ops.lcm]

26.10.17 Saturation arithmetic [numeric.sat]

26.10.17.1 Arithmetic functions [numeric.sat.func]

26.11 Specialized <memory> algorithms [specialized.algorithms]

26.11.2 Special memory concepts [special.mem.concepts]

26.11.3 uninitialized_default_construct [uninitialized.construct.default]

26.11.4 uninitialized_value_construct [uninitialized.construct.value]

26.11.5 uninitialized_copy [uninitialized.copy]

26.11.6 uninitialized_move [uninitialized.move]

26.11.7 uninitialized_fill [uninitialized.fill]

26.12 Specialized <random> algorithms [alg.rand]

26.13 C library algorithms [alg.c.library]

27 Strings library [strings][strings]

27.3 String view classes [string.view]

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

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

27.3.5 Inserters and extractors [string.view.io]

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

27.4 String classes [string.classes]

27.4.2 Header <string> synopsis [string.syn]

27.4.3 Class template basic_string [basic.string]

27.4.3.2 General requirements [string.require]

27.4.3.3 Constructors and assignment operators [string.cons]

27.4.3.4 Iterator support [string.iterators]

27.4.3.6 Element access [string.access]

27.4.3.7 Modifiers [string.modifiers]

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

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

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

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

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

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

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

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

27.4.3.8 String operations [string.ops]

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

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

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

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

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

27.4.4 Non-member functions [string.nonmembers]

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

27.4.4.4 Inserters and extractors [string.io]

27.4.5 Numeric conversions [string.conversions]

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

27.5 Null-terminated sequence utilities [c.strings]

27.5.1 Header <cstring> synopsis [cstring.syn]

28 Text processing library [text][text]

28.2 Primitive numeric conversions [charconv]

28.2.1 Header <charconv> synopsis [charconv.syn]

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

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

28.3 Localization library [localization]

28.3.2 Header <locale> synopsis [locale.syn]

28.3.3 Locales [locales]

28.3.3.1 Class locale [locale]

28.3.3.1.2 Types [locale.types]

28.3.3.1.2.1 Type locale​::​category [locale.category]

28.3.3.1.2.2 Class locale​::​facet [locale.facet]

28.3.3.1.2.3 Class locale​::​id [locale.id]

28.3.3.1.3 Constructors and destructor [locale.cons]

28.3.3.3 Convenience interfaces [locale.convenience]

28.3.3.3.1 Character classification [classification]

28.3.3.3.2 Character conversions [conversions.character]

28.3.4 Standard locale categories [locale.categories]

28.3.5 C library locales [c.locales]

28.3.5.1 Header <clocale> synopsis [clocale.syn]

28.4 Text encodings identification [text.encoding]

28.4.1 Header <text_encoding> synopsis [text.encoding.syn]

28.4.2 Class text_encoding [text.encoding.class]

28.4.2.4 Comparison functions [text.encoding.cmp]

28.4.2.5 Class text_encoding​::​aliases_view [text.encoding.aliases]

28.4.2.6 Enumeration text_encoding​::​id [text.encoding.id]

28.5 Formatting [format]

28.5.1 Header <format> synopsis [format.syn]

28.5.3 Error reporting [format.err.report]

28.5.4 Class template basic_format_string [format.fmt.string]

28.5.5 Formatting functions [format.functions]

28.5.6 Formatter [format.formatter]

28.5.6.1 Formatter requirements [formatter.requirements]

28.5.6.3 Concept formattable [format.formattable]

28.5.6.4 Formatter specializations [format.formatter.spec]

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

28.5.6.6 Class template basic_format_parse_context [format.parse.ctx]

28.5.6.7 Class template basic_format_context [format.context]

28.5.7 Formatting of ranges [format.range]

28.5.7.1 Variable template format_kind [format.range.fmtkind]

28.5.7.2 Class template range_formatter [format.range.formatter]

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

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

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

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

28.5.8 Arguments [format.arguments]

28.5.8.1 Class template basic_format_arg [format.arg]

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

28.5.8.3 Class template basic_format_args [format.args]

28.5.9 Tuple formatter [format.tuple]

28.5.10 Class format_error [format.error]

28.6 Regular expressions library [re]

28.6.2 Requirements [re.req]

28.6.3 Header <regex> synopsis [re.syn]

28.6.4 Namespace std​::​regex_constants [re.const]

28.6.4.2 Bitmask type syntax_option_type [re.synopt]

28.6.4.3 Bitmask type match_flag_type [re.matchflag]

28.6.4.4 Implementation-defined error_type [re.err]

28.6.5 Class regex_error [re.badexp]

28.6.6 Class template regex_traits [re.traits]

28.6.10 Regular expression algorithms [re.alg]

28.6.12 Modified ECMAScript regular expression grammar [re.grammar]

28.7 Null-terminated sequence utilities [text.c.strings]

28.7.1 Header <cctype> synopsis [cctype.syn]

28.7.2 Header <cwctype> synopsis [cwctype.syn]

28.7.3 Header <cwchar> synopsis [cwchar.syn]

28.7.4 Header <cuchar> synopsis [cuchar.syn]

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

29 Numerics library [numerics][numerics]

29.2 Numeric type requirements [numeric.requirements]

29.3 The floating-point environment [cfenv]

29.3.1 Header <cfenv> synopsis [cfenv.syn]

29.4 Complex numbers [complex.numbers]

29.4.2 Header <complex> synopsis [complex.syn]

29.4.3 Class template complex [complex]

29.4.4 Member functions [complex.members]

29.4.5 Member operators [complex.member.ops]

29.4.6 Non-member operations [complex.ops]

29.4.7 Value operations [complex.value.ops]

29.4.9 Tuple interface [complex.tuple]

29.4.10 Additional overloads [cmplx.over]

29.4.11 Suffixes for complex number literals [complex.literals]

29.5 Random number generation [rand]

29.5.2 Header <random> synopsis [rand.synopsis]

29.5.3 Requirements [rand.req]

29.5.3.1 General requirements [rand.req.genl]

29.5.3.2 Seed sequence requirements [rand.req.seedseq]

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

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

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

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

29.5.4 Random number engine class templates [rand.eng]

29.5.4.2 Class template linear_congruential_engine [rand.eng.lcong]

29.5.4.3 Class template mersenne_twister_engine [rand.eng.mers]

29.5.4.4 Class template subtract_with_carry_engine [rand.eng.sub]

29.5.4.5 Class template philox_engine [rand.eng.philox]

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

29.5.5.2 Class template discard_block_engine [rand.adapt.disc]

29.5.5.3 Class template independent_bits_engine [rand.adapt.ibits]

29.5.5.4 Class template shuffle_order_engine [rand.adapt.shuf]

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

29.5.7 Class random_device [rand.device]

29.5.8 Utilities [rand.util]

29.5.8.2 Function template generate_canonical [rand.util.canonical]

29.5.9 Random number distribution class templates [rand.dist]

29.5.9.2 Uniform distributions [rand.dist.uni]

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

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

29.5.9.3 Bernoulli distributions [rand.dist.bern]

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

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

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

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

29.5.9.4 Poisson distributions [rand.dist.pois]

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

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

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

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

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

29.5.9.5 Normal distributions [rand.dist.norm]

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

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

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

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

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

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

29.5.9.6 Sampling distributions [rand.dist.samp]

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

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

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

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

29.6 Numeric arrays [numarray]

29.6.1 Header <valarray> synopsis [valarray.syn]

29.6.3 valarray non-member operations [valarray.nonmembers]

29.6.3.1 Binary operators [valarray.binary]

29.6.3.4 Specialized algorithms [valarray.special]

29.6.10 valarray range access [valarray.range]

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

29.7.1 Header <cmath> synopsis [cmath.syn]

29.7.2 Absolute values [c.math.abs]

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

29.7.4 Linear interpolation [c.math.lerp]

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

29.7.6 Mathematical special functions [sf.cmath]

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

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

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

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

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

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

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

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

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

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

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

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

29.7.6.15 Exponential integral [sf.cmath.expint]

29.7.6.16 Hermite polynomials [sf.cmath.hermite]

29.7.6.17 Laguerre polynomials [sf.cmath.laguerre]

29.7.6.18 Legendre polynomials [sf.cmath.legendre]

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

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

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

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

29.8 Numbers [numbers]

29.8.1 Header <numbers> synopsis [numbers.syn]

29.8.2 Mathematical constants [math.constants]

29.9 Basic linear algebra algorithms [linalg]

29.9.2 Header <linalg> synopsis [linalg.syn]

29.9.4 Requirements [linalg.reqs]

29.9.4.1 Linear algebra value types [linalg.reqs.val]

29.9.4.2 Algorithm and class requirements [linalg.reqs.alg]

29.9.8 Scaled in-place transformation [linalg.scaled]

29.9.8.2 Class template scaled_accessor [linalg.scaled.scaledaccessor]

29.9.8.3 Function template scaled [linalg.scaled.scaled]

29.9.9 Conjugated in-place transformation [linalg.conj]

29.9.9.2 Class template conjugated_accessor [linalg.conj.conjugatedaccessor]

29.9.9.3 Function template conjugated [linalg.conj.conjugated]

29.9.10 Transpose in-place transformation [linalg.transp]

29.9.10.2 Exposition-only helpers for layout_transpose and transposed [linalg.transp.helpers]

29.9.10.3 Class template layout_transpose [linalg.transp.layout.transpose]

29.9.10.4 Function template transposed [linalg.transp.transposed]

29.9.11 Conjugate transpose in-place transform [linalg.conjtransposed]

29.9.12 Algorithm requirements based on template parameter name [linalg.algs.reqs]

29.9.13 BLAS 1 algorithms [linalg.algs.blas1]

29.9.13.2 Givens rotations [linalg.algs.blas1.givens]

29.9.13.2.2 Apply a computed Givens rotation to vectors [linalg.algs.blas1.givens.rot]

29.9.13.3 Swap matrix or vector elements [linalg.algs.blas1.swap]

29.9.13.4 Multiply the elements of an object in place by a scalar [linalg.algs.blas1.scal]

29.9.13.5 Copy elements of one matrix or vector into another [linalg.algs.blas1.copy]

29.9.13.6 Add vectors or matrices elementwise [linalg.algs.blas1.add]

29.9.13.7 Dot product of two vectors [linalg.algs.blas1.dot]

29.9.13.8 Scaled sum of squares of a vector's elements [linalg.algs.blas1.ssq]

29.9.13.9 Euclidean norm of a vector [linalg.algs.blas1.nrm2]

29.9.13.10 Sum of absolute values of vector elements [linalg.algs.blas1.asum]

29.9.13.11 Index of maximum absolute value of vector elements [linalg.algs.blas1.iamax]

29.9.13.12 Frobenius norm of a matrix [linalg.algs.blas1.matfrobnorm]

29.9.13.14 Infinity norm of a matrix [linalg.algs.blas1.matinfnorm]

29.9.14 BLAS 2 algorithms [linalg.algs.blas2]

29.9.14.1 General matrix-vector product [linalg.algs.blas2.gemv]

29.9.14.2 Symmetric matrix-vector product [linalg.algs.blas2.symv]

29.9.14.3 Hermitian matrix-vector product [linalg.algs.blas2.hemv]

29.9.14.4 Triangular matrix-vector product [linalg.algs.blas2.trmv]

29.9.14.5 Solve a triangular linear system [linalg.algs.blas2.trsv]

29.9.14.6 Rank-1 (outer product) update of a matrix [linalg.algs.blas2.rank1]

29.9.14.7 Symmetric or Hermitian Rank-1 (outer product) update of a matrix [linalg.algs.blas2.symherrank1]

29.9.14.8 Symmetric and Hermitian rank-2 matrix updates [linalg.algs.blas2.rank2]

29.9.15 BLAS 3 algorithms [linalg.algs.blas3]

29.9.15.1 General matrix-matrix product [linalg.algs.blas3.gemm]

29.9.15.2 Symmetric, Hermitian, and triangular matrix-matrix product [linalg.algs.blas3.xxmm]

29.9.15.3 In-place triangular matrix-matrix product [linalg.algs.blas3.trmm]

29.9.15.4 Rank-k update of a symmetric or Hermitian matrix [linalg.algs.blas3.rankk]

29.9.15.5 Rank-2k update of a symmetric or Hermitian matrix [linalg.algs.blas3.rank2k]

29.9.15.6 Solve multiple triangular linear systems [linalg.algs.blas3.trsm]

29.9.15.7 Solve multiple triangular linear systems in-place [linalg.algs.blas3.inplacetrsm]

29.10 Data-parallel types [simd]

29.10.2 Exposition-only types, variables, and concepts [simd.expos]

29.10.2.1 Exposition-only helpers [simd.expos.defn]

29.10.3 Header <simd> synopsis [simd.syn]

29.10.4 simd type traits [simd.traits]

29.10.5 Load and store flags [simd.flags]

29.10.5.1 Class template simd_flags overview [simd.flags.overview]

29.10.5.2 simd_flags operators [simd.flags.oper]

29.10.6 Class template basic_simd [simd.class]

29.10.6.1 Class template basic_simd overview [simd.overview]

29.10.6.2 basic_simd constructors [simd.ctor]

29.10.6.3 basic_simd subscript operator [simd.subscr]

29.10.6.4 basic_simd unary operators [simd.unary]

29.10.7 basic_simd non-member operations [simd.nonmembers]

29.10.7.1 basic_simd binary operators [simd.binary]

29.10.7.2 basic_simd compound assignment [simd.cassign]

29.10.7.3 basic_simd compare operators [simd.comparison]

29.10.7.4 basic_simd exposition only conditional operators [simd.cond]

29.10.7.5 basic_simd reductions [simd.reductions]

29.10.7.6 basic_simd load and store functions [simd.loadstore]

29.10.7.7 basic_simd and basic_simd_mask creation [simd.creation]

29.10.7.9 Mathematical functions [simd.math]

29.10.8 Class template basic_simd_mask [simd.mask.class]

29.10.8.1 Class template basic_simd_mask overview [simd.mask.overview]

29.10.8.2 basic_simd_mask constructors [simd.mask.ctor]

29.10.8.3 basic_simd_mask subscript operator [simd.mask.subscr]

29.10.8.4 basic_simd_mask unary operators [simd.mask.unary]

29.10.8.5 basic_simd_mask conversion operators [simd.mask.conv]

29.10.9 Non-member operations [simd.mask.nonmembers]

29.10.9.1 basic_simd_mask binary operators [simd.mask.binary]

29.10.9.2 basic_simd_mask compound assignment [simd.mask.cassign]

29.10.9.3 basic_simd_mask comparisons [simd.mask.comparison]

29.10.9.4 basic_simd_mask exposition only conditional operators [simd.mask.cond]

29.10.9.5 basic_simd_mask reductions [simd.mask.reductions]

29.11 C compatibility [numerics.c]

29.11.1 Header <stdckdint.h> synopsis [stdckdint.h.syn]

29.11.2 Checked integer operations [numerics.c.ckdint]

30 Time library [time][time]

30.2 Header <chrono> synopsis [time.syn]

30.3 Cpp17Clock requirements [time.clock.req]

30.4 Time-related traits [time.traits]

30.4.1 treat_as_floating_point [time.traits.is.fp]

30.4.3 Specializations of common_type [time.traits.specializations]

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

30.7 Clocks [time.clock]

30.7.7 Class steady_clock [time.clock.steady]

30.7.8 Class high_resolution_clock [time.clock.hires]

30.7.10 time_point conversions [time.clock.cast]

30.7.10.1 Class template clock_time_conversion [time.clock.conv]

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

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

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

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

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

30.8 The civil calendar [time.cal]

30.8.2 Class last_spec [time.cal.last]

30.8.10 Class month_day_last [time.cal.mdlast]

30.8.18 Conventional syntax operators [time.cal.operators]

30.10 12/24 hours functions [time.12]

30.11 Time zones [time.zone]

30.11.2 Time zone database [time.zone.db]

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

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

30.11.3 Exception classes [time.zone.exception]

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

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

30.11.6 Class template zoned_traits [time.zone.zonedtraits]

30.12 Formatting [time.format]

30.14 Hash support [time.hash]

30.15 Header <ctime> synopsis [ctime.syn]

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

31.2 Iostreams requirements [iostreams.requirements]

31.2.3 Positioning type limitations [iostreams.limits.pos]

31.3 Forward declarations [iostream.forward]

31.3.1 Header <iosfwd> synopsis [iosfwd.syn]

31.4 Standard iostream objects [iostream.objects]

31.4.1 Header <iostream> synopsis [iostream.syn]

31.4.3 Narrow stream objects [narrow.stream.objects]

31.4.4 Wide stream objects [wide.stream.objects]

31.5 Iostreams base classes [iostreams.base]

31.5.1 Header <ios> synopsis [ios.syn]

31.5.2 Class ios_base [ios.base]

31.5.2.2 Types [ios.types]

31.5.2.2.1 Class ios_base​::​failure [ios.failure]

31.5.2.2.2 Type ios_base​::​fmtflags [ios.fmtflags]

31.5.2.2.3 Type ios_base​::​iostate [ios.iostate]

31.5.2.2.4 Type ios_base​::​openmode [ios.openmode]

31.5.2.2.5 Type ios_base​::​seekdir [ios.seekdir]

31.5.2.2.6 Class ios_base​::​Init [ios.init]

31.5.2.3 State functions [fmtflags.state]

31.5.2.6 Storage functions [ios.base.storage]

31.5.2.8 Constructors and destructor [ios.base.cons]

31.5.4 Class template basic_ios [ios]

31.5.4.3 Member functions [basic.ios.members]

31.5.4.4 Flags functions [iostate.flags]

31.5.5 ios_base manipulators [std.ios.manip]

31.5.5.1 fmtflags manipulators [fmtflags.manip]

31.5.5.2 adjustfield manipulators [adjustfield.manip]

31.5.5.3 basefield manipulators [basefield.manip]

31.5.5.4 floatfield manipulators [floatfield.manip]

31.5.6 Error reporting [error.reporting]

31.7 Formatting and manipulators [iostream.format]

31.7.1 Header <istream> synopsis [istream.syn]

31.7.2 Header <ostream> synopsis [ostream.syn]

31.7.3 Header <iomanip> synopsis [iomanip.syn]

31.7.4 Header <print> synopsis [print.syn]

31.7.5 Input streams [input.streams]

31.7.5.2 Class template basic_istream [istream]

31.7.5.2.3 Assignment and swap [istream.assign]

31.7.5.2.4 Class basic_istream​::​sentry [istream.sentry]

31.7.5.3 Formatted input functions [istream.formatted]

31.7.5.3.3 basic_istream​::​operator>> [istream.extractors]

31.7.5.4 Unformatted input functions [istream.unformatted]

31.7.5.5 Standard basic_istream manipulators [istream.manip]

31.7.5.6 Rvalue stream extraction [istream.rvalue]

31.7.6 Output streams [output.streams]

31.7.6.2 Class template basic_ostream [ostream]

31.7.6.2.3 Assignment and swap [ostream.assign]

31.7.6.2.4 Class basic_ostream​::​sentry [ostream.sentry]

31.7.6.3 Formatted output functions [ostream.formatted]

31.7.6.3.3 basic_ostream​::​operator<< [ostream.inserters]

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

31.7.6.4 Unformatted output functions [ostream.unformatted]

31.7.6.5 Standard basic_ostream manipulators [ostream.manip]

31.7.6.6 Rvalue stream insertion [ostream.rvalue]

31.7.7 Standard manipulators [std.manip]

31.7.8 Extended manipulators [ext.manip]

31.7.9 Quoted manipulators [quoted.manip]

31.7.10 Print functions [print.fun]

31.8 String-based streams [string.streams]

31.8.1 Header <sstream> synopsis [sstream.syn]

31.8.2 Class template basic_stringbuf [stringbuf]

31.8.2.3 Assignment and swap [stringbuf.assign]

31.8.2.4 Member functions [stringbuf.members]

31.8.2.5 Overridden virtual functions [stringbuf.virtuals]

31.9 Span-based streams [span.streams]

31.9.2 Header <spanstream> synopsis [spanstream.syn]

31.9.3 Class template basic_spanbuf [spanbuf]

31.9.3.3 Assignment and swap [spanbuf.assign]

31.9.3.4 Member functions [spanbuf.members]

31.9.3.5 Overridden virtual functions [spanbuf.virtuals]

31.10 File-based streams [file.streams]

31.10.1 Header <fstream> synopsis [fstream.syn]

31.10.2 Native handles [file.native]

31.10.3 Class template basic_filebuf [filebuf]

31.10.3.3 Assignment and swap [filebuf.assign]

31.10.3.4 Member functions [filebuf.members]

31.10.3.5 Overridden virtual functions [filebuf.virtuals]

31.10.6 Class template basic_fstream [fstream]

31.10.6.4 Member functions [fstream.members]

31.11 Synchronized output streams [syncstream]

31.11.1 Header <syncstream> synopsis [syncstream.syn]

31.12 File systems [filesystems]

31.12.2 Conformance [fs.conformance]

31.12.2.2 POSIX conformance [fs.conform.9945]

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

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

31.12.3 Requirements [fs.req]

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

31.12.5 Error reporting [fs.err.report]

31.12.8 Enumerations [fs.enum]

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

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

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

31.12.8.4 Enum class perms [fs.enum.perms]

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

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

31.12.13 Filesystem operation functions [fs.op.funcs]

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

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

31.13 C library files [c.files]

31.13.1 Header <cstdio> synopsis [cstdio.syn]

31.13.2 Header <cinttypes> synopsis [cinttypes.syn]

32 Concurrency support library [thread][thread]

32.2 Requirements [thread.req]

32.2.1 Template parameter names [thread.req.paramname]

32.2.4 Timing specifications [thread.req.timing]

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

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.2.5.5 Cpp17SharedLockable requirements [thread.req.lockable.shared]

32.2.5.6 Cpp17SharedTimedLockable requirements [thread.req.lockable.shared.timed]

32.3 Stop tokens [thread.stoptoken]

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

32.3.3 Stop token concepts [stoptoken.concepts]

32.3.4 Class stop_token [stoptoken]

32.3.4.2 Member functions [stoptoken.mem]

32.3.5 Class stop_source [stopsource]

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

32.3.5.3 Member functions [stopsource.mem]

32.3.6 Class template stop_callback [stopcallback]

32.3.6.2 Constructors and destructor [stopcallback.cons]

32.3.7 Class never_stop_token [stoptoken.never]

32.3.10 Class template inplace_stop_callback [stopcallback.inplace]

32.3.10.2 Constructors and destructor [stopcallback.inplace.cons]

32.5 Atomic operations [atomics]

32.5.2 Header <atomic> synopsis [atomics.syn]

32.5.3 Type aliases [atomics.alias]

32.5.4 Order and consistency [atomics.order]

32.5.5 Lock-free property [atomics.lockfree]

32.5.6 Waiting and notifying [atomics.wait]

32.5.7 Class template atomic_ref [atomics.ref.generic]

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

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

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

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

32.5.8 Class template atomic [atomics.types.generic]

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

32.5.8.3 Specializations for integers [atomics.types.int]

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

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

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

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

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

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

32.5.9 Non-member functions [atomics.nonmembers]

32.5.10 Flag type and operations [atomics.flag]

32.5.12 C compatibility [stdatomic.h.syn]

32.6 Mutual exclusion [thread.mutex]

32.6.2 Header <mutex> synopsis [mutex.syn]

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

32.6.6 Generic locking algorithms [thread.lock.algorithm]

32.7 Condition variables [thread.condition]

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

32.7.4 Class condition_variable [thread.condition.condvar]

32.8 Semaphore [thread.sema]

32.8.2 Header <semaphore> synopsis [semaphore.syn]

32.8.3 Class template counting_semaphore [thread.sema.cnt]

32.10 Futures [futures]

32.10.2 Header <future> synopsis [future.syn]

32.10.3 Error handling [futures.errors]

32.10.4 Class future_error [futures.future.error]

32.10.6 Class template promise [futures.promise]

32.10.7 Class template future [futures.unique.future]

32.10.8 Class template shared_future [futures.shared.future]

32.10.9 Function template async [futures.async]

32.11 Safe reclamation [saferecl]

32.11.3 Hazard pointers [saferecl.hp]

32.11.3.2 Header <hazard_pointer> synopsis [hazard.pointer.syn]

32.11.3.3 Class template hazard_pointer_obj_base [saferecl.hp.base]

33 Execution control library [exec][exec]

33.3 Asynchronous operations [exec.async.ops]

33.4 Header <execution> synopsis [execution.syn]

33.5 Queries [exec.queries]

33.5.1 forwarding_query [exec.fwd.env]

33.5.4 execution​::​get_env [exec.get.env]

33.5.5 execution​::​get_domain [exec.get.domain]

33.5.6 execution​::​get_scheduler [exec.get.scheduler]

33.5.7 execution​::​get_delegation_scheduler [exec.get.delegation.scheduler]

33.5.8 execution​::​get_forward_progress_guarantee [exec.get.fwd.progress]

33.5.9 execution​::​get_completion_scheduler [exec.get.compl.sched]

33.6 Schedulers [exec.sched]

33.7 Receivers [exec.recv]

33.7.1 Receiver concepts [exec.recv.concepts]

33.7.2 execution​::​set_value [exec.set.value]

33.7.3 execution​::​set_error [exec.set.error]

33.7.4 execution​::​set_stopped [exec.set.stopped]

33.8 Operation states [exec.opstate]

33.8.2 execution​::​start [exec.opstate.start]

33.9 Senders [exec.snd]

33.9.2 Exposition-only entities [exec.snd.expos]

33.9.3 Sender concepts [exec.snd.concepts]

33.9.4 Awaitable helpers [exec.awaitable]

33.9.5 execution​::​default_domain [exec.domain.default]

33.9.6 execution​::​transform_sender [exec.snd.transform]

33.9.7 execution​::​transform_env [exec.snd.transform.env]

33.9.8 execution​::​apply_sender [exec.snd.apply]

33.9.9 execution​::​get_completion_signatures [exec.getcomplsigs]

33.9.10 execution​::​connect [exec.connect]

33.9.11 Sender factories [exec.factories]

33.9.11.1 execution​::​schedule [exec.schedule]

33.9.11.2 execution​::​just, execution​::​just_error, execution​::​just_stopped [exec.just]

33.9.11.3 execution​::​read_env [exec.read.env]

33.9.12 Sender adaptors [exec.adapt]

33.9.12.2 Closure objects [exec.adapt.obj]

33.9.12.3 execution​::​starts_on [exec.starts.on]

33.9.12.4 execution​::​continues_on [exec.continues.on]

33.9.12.5 execution​::​schedule_from [exec.schedule.from]

33.9.12.6 execution​::​on [exec.on]

33.9.12.7 execution​::​then, execution​::​upon_error, execution​::​upon_stopped [exec.then]

33.9.12.8 execution​::​let_value, execution​::​let_error, execution​::​let_stopped [exec.let]

33.9.12.9 execution​::​bulk [exec.bulk]

33.9.12.10 execution​::​split [exec.split]

33.9.12.11 execution​::​when_all [exec.when.all]

33.9.12.12 execution​::​into_variant [exec.into.variant]

33.9.12.13 execution​::​stopped_as_optional [exec.stopped.opt]

33.9.12.14 execution​::​stopped_as_error [exec.stopped.err]

33.9.13 Sender consumers [exec.consumers]

33.9.13.1 this_thread​::​sync_wait [exec.sync.wait]

33.9.13.2 this_thread​::​sync_wait_with_variant [exec.sync.wait.var]

33.10 Sender/receiver utilities [exec.util]

33.10.1 execution​::​completion_signatures [exec.util.cmplsig]

33.10.2 execution​::​transform_completion_signatures [exec.util.cmplsig.trans]

33.11 Queryable utilities [exec.envs]

33.11.1 Class template prop [exec.prop]

33.11.2 Class template env [exec.env]

33.12 Execution contexts [exec.ctx]

33.12.1 execution​::​run_loop [exec.run.loop]

33.12.1.3 Constructor and destructor [exec.run.loop.ctor]

33.13 Coroutine utilities [exec.coro.util]

33.13.1 execution​::​as_awaitable [exec.as.awaitable]

33.13.2 execution​::​with_awaitable_senders [exec.with.awaitable.senders]

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

A.2 Keywords [gram.key]

A.3 Lexical conventions [gram.lex]

A.5 Expressions [gram.expr]

A.6 Statements [gram.stmt]

A.7 Declarations [gram.dcl]

A.10 Overloading [gram.over]

A.11 Templates [gram.temp]

A.12 Exception handling [gram.except]

A.13 Preprocessing directives [gram.cpp]

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

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

C.2 C++ and ISO C++ 2020 [diff.cpp20]

C.2.2 [lex]: lexical conventions [diff.cpp20.lex]

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

C.2.9 [mem]: memory management library [diff.cpp20.memory]

C.2.10 [utilities]: general utilities library [diff.cpp20.utilities]

C.2.13 [thread]: concurrency support library [diff.cpp20.thread]

C.7 C++ and C [diff.iso]

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

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

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

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

C.8 C standard library [diff.library]

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

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

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

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

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

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

C.8.3.7 Macro NULL [diff.null]

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

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

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

C.8.5.3 Memory allocation functions [diff.malloc]

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

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

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

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

D.5 Non-comma-separated ellipsis parameters [depr.ellipsis.comma]

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

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

D.8 Literal operator function declarations using an identifier [depr.lit]

D.9 template keyword before qualified names [depr.template.template]

D.10 has_denorm members in numeric_limits [depr.numeric.limits.has.denorm]

D.11 Deprecated C macros [depr.c.macros]

D.12 Deprecated error numbers [depr.cerrno]

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

D.14 Relational operators [depr.relops]

D.17 Deprecated iterator class template [depr.iterator]

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

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

D.20 Deprecated formatting [depr.format]

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

D.20.2 Formatting arguments [depr.format.arg]

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

D.22 Deprecated atomic operations [depr.atomics]

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

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

Annex E (informative) Conformance with UAX #31 [uaxid][uaxid]

E.2 R1 Default identifiers [uaxid.def]

E.2.2 R1a Restricted format characters [uaxid.def.rfmt]

E.2.3 R1b Stable identifiers [uaxid.def.stable]

E.3 R2 Immutable identifiers [uaxid.immutable]

E.4 R3 Pattern_White_Space and Pattern_Syntax characters [uaxid.pattern]

E.5 R4 Equivalent normalized identifiers [uaxid.eqn]

E.6 R5 Equivalent case-insensitive identifiers [uaxid.eqci]

E.7 R6 Filtered normalized identifiers [uaxid.filter]

E.8 R7 Filtered case-insensitive identifiers [uaxid.filterci]

E.9 R8 Hashtag identifiers [uaxid.hashtag]

Bibliography

Index

Index of grammar productions

Index of library headers

Index of library names

Index of library concepts

Index of implementation-defined behavior

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy