Working Draft
Programming Languages — C++
(Generated on 2026-07-26 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

Foreword

Introduction

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.4.10 Contract-assertion scope [basic.scope.contract]

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.6 Splice specifiers [basic.splice]

6.8 Memory and objects [basic.memobj]

6.8.1 Memory model [intro.memory]

6.8.2 Object model [intro.object]

6.8.5 Indeterminate and erroneous values [basic.indet]

6.8.6 Storage duration [basic.stc]

6.8.6.2 Static storage duration [basic.stc.static]

6.8.6.3 Thread storage duration [basic.stc.thread]

6.8.6.4 Automatic storage duration [basic.stc.auto]

6.8.7 Temporary objects [class.temporary]

6.9 Types [basic.types]

6.9.2 Trivially copyable types [basic.types.trivial]

6.9.3 Fundamental types [basic.fundamental]

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

6.9.5 Compound types [basic.compound]

6.9.7 Conversion ranks [conv.rank]

6.10 Program execution [basic.exec]

6.10.1 Sequential execution [intro.execution]

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

6.10.2.3 Forward progress [intro.progress]

6.10.3 Start and termination [basic.start]

6.10.3.2 Static initialization [basic.start.static]

6.10.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 evaluation [expr.const]

7.7.2 Core constant expressions [expr.const.core]

7.7.3 Constant expressions [expr.const.const]

7.7.4 Constant initialization [expr.const.init]

7.7.5 Immediate functions [expr.const.imm]

7.7.7 Further definitions [expr.const.defns]

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 Expansion statements [stmt.expand]

8.8 Jump statements [stmt.jump]

8.8.2 The break statement [stmt.break]

8.8.3 The continue statement [stmt.cont]

8.8.4 The return statement [stmt.return]

8.8.5 The co_return statement [stmt.return.coroutine]

8.8.6 The goto statement [stmt.goto]

8.9 Assertion statement [stmt.contract.assert]

8.10 Declaration statement [stmt.dcl]

8.11 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 Function contract specifiers [dcl.contract]

9.4.2 Referring to the result object [dcl.contract.res]

9.5 Initializers [dcl.init]

9.5.3 Character arrays [dcl.init.string]

9.5.5 List-initialization [dcl.init.list]

9.6 Function definitions [dcl.fct.def]

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

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

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

9.6.5 Replaceable function definitions [dcl.fct.def.replace]

9.7 Structured binding declarations [dcl.struct.bind]

9.8 Enumerations [enum]

9.8.1 Enumeration declarations [dcl.enum]

9.8.2 The using enum declaration [enum.udecl]

9.9 Namespaces [basic.namespace]

9.9.2 Namespace definition [namespace.def]

9.9.2.2 Unnamed namespaces [namespace.unnamed]

9.9.3 Namespace alias [namespace.alias]

9.9.4 Using namespace directive [namespace.udir]

9.10 The using declaration [namespace.udecl]

9.11 The asm declaration [dcl.asm]

9.13 Attributes [dcl.attr]

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

9.13.2 Alignment specifier [dcl.align]

9.13.3 Assumption attribute [dcl.attr.assume]

9.13.4 Deprecated attribute [dcl.attr.deprecated]

9.13.5 Fallthrough attribute [dcl.attr.fallthrough]

9.13.6 Indeterminate storage [dcl.attr.indet]

9.13.7 Likelihood attributes [dcl.attr.likelihood]

9.13.8 Maybe unused attribute [dcl.attr.unused]

9.13.9 Nodiscard attribute [dcl.attr.nodiscard]

9.13.10 Noreturn attribute [dcl.attr.noreturn]

9.13.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.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 designated 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.4.7.2 Defaulted function [over.inc.default]

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.2 Constraints [temp.constr.constr]

13.5.2.2 Logical operations [temp.constr.op]

13.5.2.3 Atomic constraints [temp.constr.atomic]

13.5.2.4 Concept-dependent constraints [temp.constr.concept]

13.5.2.5 Fold expanded constraint [temp.constr.fold]

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 splice specifiers [temp.dep.splice]

13.8.3.6 Dependent namespaces [temp.dep.namespace]

13.8.3.7 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.5 Module directive [cpp.module]

15.6 Header unit importation [cpp.import]

15.7 Macro replacement [cpp.replace]

15.7.2 Argument substitution [cpp.subst]

15.7.3 The # operator [cpp.stringize]

15.7.4 The ## operator [cpp.concat]

15.7.5 Rescanning and further replacement [cpp.rescan]

15.7.6 Scope of macro definitions [cpp.scope]

15.8 Line control [cpp.line]

15.9 Diagnostic directives [cpp.error]

15.10 Pragma directive [cpp.pragma]

15.11 Null directive [cpp.null]

15.12 Predefined macro names [cpp.predefined]

15.13 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 Properties of library classes [library.class.props]

16.4.6.12 Protection within classes [protection.within.classes]

16.4.6.13 Derived classes [derivation]

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

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

16.4.6.17 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 Contract-violation handling [support.contract]

17.10.1 Header <contracts> synopsis [contracts.syn]

17.10.3 Class contract_violation [support.contract.violation]

17.10.4 Invoke default handler [support.contract.invoke]

17.11 Initializer lists [support.initlist]

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

17.11.3 Initializer list constructors [support.initlist.cons]

17.11.4 Initializer list access [support.initlist.access]

17.12 Comparisons [cmp]

17.12.1 Header <compare> synopsis [compare.syn]

17.12.2 Comparison category types [cmp.categories]

17.12.2.2 Class partial_ordering [cmp.partialord]

17.12.2.3 Class weak_ordering [cmp.weakord]

17.12.2.4 Class strong_ordering [cmp.strongord]

17.12.3 Class template common_comparison_category [cmp.common]

17.12.4 Concept three_way_comparable [cmp.concept]

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

17.12.6 Comparison algorithms [cmp.alg]

17.12.7 Type Ordering [compare.type]

17.14 Other runtime support [support.runtime]

17.14.2 Header <cstdarg> synopsis [cstdarg.syn]

17.14.3 Header <csetjmp> synopsis [csetjmp.syn]

17.14.4 Header <csignal> synopsis [csignal.syn]

17.14.5 Signal handlers [support.signal]

17.15 C headers [support.c.headers]

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

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

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

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

17.15.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 Pointer tagging [ptrtag]

20.3.1 Pointer tagging limits [ptrtag.bits]

20.3.2 Class template pointer_tag_pair [ptrtag.pair]

20.3.2.3 Support for overaligned pointers [ptrtag.pair.overalign]

20.3.2.4 Tagged pointer operations [ptrtag.pair.tagops]

20.3.2.8 Tuple interface [ptrtag.pair.get]

20.4 Smart pointers [smartptr]

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

20.4.4 Smart pointer adaptors [smartptr.adapt]

20.4.4.1 Class template out_ptr_t [out.ptr.t]

20.4.4.2 Function template out_ptr [out.ptr]

20.4.4.3 Class template inout_ptr_t [inout.ptr.t]

20.4.4.4 Function template inout_ptr [inout.ptr]

20.6 Memory resources [mem.res]

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

20.6.2 Class memory_resource [mem.res.class]

20.6.2.2 Public member functions [mem.res.public]

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

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

20.6.5 Pool resource classes [mem.res.pool]

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

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

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

20.7 Class template scoped_allocator_adaptor [allocator.adaptor]

20.7.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.2.4 Structured binding support [intseq.binding]

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 Reflection [meta.reflection]

21.4.1 Header <meta> synopsis [meta.syn]

21.4.2 Checking string literals [meta.string.literal]

21.4.3 Promoting to static storage [meta.define.static]

21.4.5 Operator representations [meta.reflection.operators]

21.4.6 Reflection names and locations [meta.reflection.names]

21.4.8 Scope identification [meta.reflection.scope]

21.4.10 Member accessibility queries [meta.reflection.access.queries]

21.4.11 Reflection member queries [meta.reflection.member.queries]

21.4.12 Reflection layout queries [meta.reflection.layout]

21.4.15 Reflection substitution [meta.reflection.substitute]

21.4.16 Expression result reflection [meta.reflection.result]

21.4.17 Reflection class definition generation [meta.reflection.define.aggregate]

21.4.18 Reflection type traits [meta.reflection.traits]

21.5 Compile-time rational arithmetic [ratio]

21.5.2 Header <ratio> synopsis [ratio.syn]

21.5.3 Class template ratio [ratio.ratio]

21.5.4 Arithmetic on ratios [ratio.arithmetic]

21.5.5 Comparison of ratios [ratio.comparison]

21.5.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 Undefined behavior [utility.undefined]

22.2.10 Class template constant_wrapper [const.wrap.class]

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.5 No-value state indicator [optional.nullopt]

22.5.6 Class bad_optional_access [optional.bad.access]

22.5.7 Relational operators [optional.relops]

22.5.8 Comparison with nullopt [optional.nullops]

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

22.5.10 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 <hive> synopsis [hive.syn]

23.3.9 Class template hive [hive]

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

23.3.10 Header <list> synopsis [list.syn]

23.3.11 Class template list [list]

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

23.3.12 Header <vector> synopsis [vector.syn]

23.3.14 Specialization of vector for bool [vector.bool]

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

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

23.3.15 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 slice canonicalization [mdspan.sub.canonical]

23.7.3.7.6 subextents function [mdspan.sub.extents]

23.7.3.7.7 Specializations of submdspan_mapping [mdspan.sub.map]

23.7.3.7.7.1 Sliceable layout mapping requirements [mdspan.sub.map.sliceable]

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

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

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

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

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

23.7.3.7.8 submdspan function template [mdspan.sub.sub]

23.7.3.8 Multidimensional copy algorithms [mdspan.copy]

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 Alias 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​::​reserve_hint [range.prim.size.hint]

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

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

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

25.4 Range requirements [range.req]

25.4.3 Approximately sized ranges [range.approximately.sized]

25.4.4 Sized ranges [range.sized]

25.4.6 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 template filter_view​::​iterator [range.filter.iterator]

25.7.8.4 Class template 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.7.35 As input view [range.as.input]

25.7.35.2 Class template as_input_view [range.as.input.view]

25.7.35.3 Class template as_input_view​::​iterator [range.as.input.iterator]

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 Parallel 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.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 Euclidean norm of a vector [linalg.algs.blas1.nrm2]

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

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

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

29.9.13.13 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.5 Load and store flags [simd.flags]

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

29.10.6 Class template simd-iterator [simd.iterator]

29.10.7 Class template basic_vec [simd.class]

29.10.7.2 Constructors [simd.ctor]

29.10.7.3 Subscript operator [simd.subscr]

29.10.7.5 Unary operators [simd.unary]

29.10.8 basic_vec non-member operations [simd.nonmembers]

29.10.8.1 Binary operators [simd.binary]

29.10.8.2 Compound assignment [simd.cassign]

29.10.8.3 Comparison operators [simd.comparison]

29.10.8.4 Exposition-only conditional operators [simd.cond]

29.10.8.6 Load and store functions [simd.loadstore]

29.10.8.13 Mathematical functions [simd.math]

29.10.8.14 Bit manipulation [simd.bit]

29.10.10 basic_mask non-member operations [simd.mask.nonmembers]

29.10.10.2 Compound assignment [simd.mask.cassign]

29.10.10.4 Exposition-only conditional operators [simd.mask.cond]

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 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.2 forwarding_query [exec.fwd.env]

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

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

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

33.5.8 execution​::​get_start_scheduler [exec.get.start.scheduler]

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

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

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

33.5.12 execution​::​get_completion_domain [exec.get.compl.domain]

33.5.13 execution​::​get_await_completion_adaptor [exec.get.await.adapt]

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​::​indeterminate_domain [exec.domain.indeterminate]

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

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

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​::​write_env [exec.write.env]

33.9.12.4 execution​::​unstoppable [exec.unstoppable]

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

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

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

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

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

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

33.9.12.11 execution​::​bulk, execution​::​bulk_chunked, and execution​::​bulk_unchunked [exec.bulk]

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

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

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

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

33.9.12.16 execution​::​associate [exec.associate]

33.9.12.17 Exposition-only execution​::​stop-when [exec.stop.when]

33.9.12.18 execution​::​spawn_future [exec.spawn.future]

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.9.13.3 execution​::​spawn [exec.spawn]

33.10 Completion signatures [exec.cmplsig]

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]

33.13.3 execution​::​affine [exec.affine]

33.13.4 execution​::​inline_scheduler [exec.inline.scheduler]

33.13.5 execution​::​task_scheduler [exec.task.scheduler]

33.13.6 execution​::​task [exec.task]

33.13.6.2 Class template task [task.class]

33.13.6.4 Class template task​::​state [task.state]

33.13.6.5 Class task​::​promise_type [task.promise]

33.15 Parallel scheduler [exec.par.scheduler]

33.16 Namespace parallel_scheduler_replacement [exec.parschedrepl]

33.16.3 query_parallel_scheduler_backend [exec.parschedrepl.query]

33.16.4 Class parallel_scheduler_backend [exec.parschedrepl.psb]

Annex A  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  Implementation quantities [implimits][implimits]

Annex C  Compatibility [diff][diff]

C.1 C++ and ISO C++ 2026 [diff.cpp26]

C.1.2 Clause [basic]: basics [diff.cpp26.basic]

C.1.3 Clause [dcl]: declarations [diff.cpp26.dcl]

C.2 C++ and ISO C++ 2023 [diff.cpp23]

C.2.2 Clause [lex]: lexical conventions [diff.cpp23.lex]

C.2.3 Clause [expr]: expressions [diff.cpp23.expr]

C.2.4 Clause [dcl]: declarations [diff.cpp23.dcl.dcl]

C.2.5 Clause [temp]: templates [diff.cpp23.temp]

C.2.6 Clause [cpp]: preprocessing directives [diff.cpp23.cpp]

C.2.7 Clause [library]: library introduction [diff.cpp23.library]

C.2.8 Clause [mem]: memory management library [diff.cpp23.mem]

C.2.9 Clause [strings]: strings library [diff.cpp23.strings]

C.2.10 Clause [input.output]: input/output library [diff.cpp23.io]

C.2.11 Annex [depr]: compatibility features [diff.cpp23.depr]

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

C.3.2 Clause [lex]: lexical conventions [diff.cpp20.lex]

C.3.3 Clause [expr]: expressions [diff.cpp20.expr]

C.3.4 Clause [stmt]: statements [diff.cpp20.stmt]

C.3.5 Clause [dcl]: declarations [diff.cpp20.dcl]

C.3.6 Clause [over]: overloading [diff.cpp20.over]

C.3.7 Clause [temp]: templates [diff.cpp20.temp]

C.3.8 Clause [library]: library introduction [diff.cpp20.library]

C.3.9 Clause [concepts]: concepts library [diff.cpp20.concepts]

C.3.10 Clause [mem]: memory management library [diff.cpp20.memory]

C.3.11 Clause [utilities]: general utilities library [diff.cpp20.utilities]

C.3.12 Clause [strings]: strings library [diff.cpp20.strings]

C.3.13 Clause [containers]: containers library [diff.cpp20.containers]

C.3.14 Clause [thread]: concurrency support library [diff.cpp20.thread]

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

C.4.2 Clause [lex]: lexical conventions [diff.cpp17.lex]

C.4.3 Clause [basic]: basics [diff.cpp17.basic]

C.4.4 Clause [expr]: expressions [diff.cpp17.expr]

C.4.5 Clause [dcl]: declarations [diff.cpp17.dcl.dcl]

C.4.6 Clause [class]: classes [diff.cpp17.class]

C.4.7 Clause [over]: overloading [diff.cpp17.over]

C.4.8 Clause [temp]: templates [diff.cpp17.temp]

C.4.9 Clause [except]: exception handling [diff.cpp17.except]

C.4.10 Clause [library]: library introduction [diff.cpp17.library]

C.4.11 Clause [containers]: containers library [diff.cpp17.containers]

C.4.12 Clause [iterators]: iterators library [diff.cpp17.iterators]

C.4.13 Clause [algorithms]: algorithms library [diff.cpp17.alg.reqs]

C.4.14 Clause [input.output]: input/output library [diff.cpp17.input.output]

C.4.15 Annex [depr]: compatibility features [diff.cpp17.depr]

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

C.5.2 Clause [lex]: lexical conventions [diff.cpp14.lex]

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

C.5.4 Clause [dcl]: declarations [diff.cpp14.dcl.dcl]

C.5.5 Clause [class]: classes [diff.cpp14.class]

C.5.6 Clause [temp]: templates [diff.cpp14.temp]

C.5.7 Clause [except]: exception handling [diff.cpp14.except]

C.5.8 Clause [library]: library introduction [diff.cpp14.library]

C.5.9 Clause [utilities]: general utilities library [diff.cpp14.utilities]

C.5.10 Clause [strings]: strings library [diff.cpp14.string]

C.5.11 Clause [containers]: containers library [diff.cpp14.containers]

C.5.12 Annex [depr]: compatibility features [diff.cpp14.depr]

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

C.6.2 Clause [lex]: lexical conventions [diff.cpp11.lex]

C.6.3 Clause [basic]: basics [diff.cpp11.basic]

C.6.4 Clause [expr]: expressions [diff.cpp11.expr]

C.6.5 Clause [dcl]: declarations [diff.cpp11.dcl.dcl]

C.6.6 Clause [library]: library introduction [diff.cpp11.library]

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

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

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

C.7.3 Clause [expr]: expressions [diff.cpp03.expr]

C.7.4 Clause [dcl]: declarations [diff.cpp03.dcl.dcl]

C.7.5 Clause [class]: classes [diff.cpp03.class]

C.7.6 Clause [temp]: templates [diff.cpp03.temp]

C.7.7 Clause [library]: library introduction [diff.cpp03.library]

C.7.8 Clause [support]: language support library [diff.cpp03.language.support]

C.7.9 Clause [diagnostics]: diagnostics library [diff.cpp03.diagnostics]

C.7.10 Clause [utilities]: general utilities library [diff.cpp03.utilities]

C.7.11 Clause [strings]: strings library [diff.cpp03.strings]

C.7.12 Clause [containers]: containers library [diff.cpp03.containers]

C.7.13 Clause [algorithms]: algorithms library [diff.cpp03.algorithms]

C.7.14 Clause [numerics]: numerics library [diff.cpp03.numerics]

C.7.15 [localization]: localization library [diff.cpp03.locale]

C.7.16 Clause [input.output]: input/output library [diff.cpp03.input.output]

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

C.8.2 Clause [lex]: lexical conventions [diff.lex]

C.8.3 Clause [basic]: basics [diff.basic]

C.8.4 Clause [expr]: expressions [diff.expr]

C.8.5 Clause [stmt]: statements [diff.stat]

C.8.6 Clause [dcl]: declarations [diff.dcl]

C.8.7 Clause [class]: classes [diff.class]

C.8.8 Clause [cpp]: preprocessing directives [diff.cpp]

C.9 C standard library [diff.library]

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

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

C.9.3.1 Types char8_t, char16_t, and char32_t [diff.char16]

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

C.9.3.4 Macro NULL [diff.null]

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

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

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

C.9.5.3 Memory allocation functions [diff.malloc]

Annex D  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 vector<bool, Allocator> swap [depr.vector.bool.swap]

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

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

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

D.21 Deprecated formatting [depr.format]

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

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

D.22 Deprecated time formatting [depr.ctime]

D.23 Deprecated file systems [depr.filesystems]

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

D.23.2 Deprecated filesystem path format observers [depr.fs.path.obs]

D.24 Deprecated atomic operations [depr.atomics]

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

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

D.24.5 memory_order​::​consume [depr.atomics.order]

D.25 Deprecated signed char and unsigned char extraction [depr.istream.extractors]

D.26 Deprecated signed char and unsigned char insertion [depr.ostream.inserters]

Annex E  Conformance with UAX #31 [uaxid][uaxid]

E.2 R1 Default identifiers [uaxid.def]

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

Annex F  Core undefined behavior [ub][ub]

F.2 Clause [basic]: Basics [ub.basic]

F.3 Clause [expr]: Expressions [ub.expr]

F.4 Clause [stmt]: Statements [ub.stmt]

F.5 Clause [dcl]: Declarations [ub.dcl]

F.6 Clause [class]: Classes [ub.class]

F.7 Clause [temp]: Templates [ub.temp]

F.8 Clause [except]: Exception handling [ub.except]

Annex G  Ill-formed, no diagnostic required [ifndr][ifndr]

G.2 Clause [lex]: Lexical conventions [ifndr.lex]

G.3 Clause [basic]: Basics [ifndr.basic]

G.4 Clause [expr]: Expressions [ifndr.expr]

G.5 Clause [stmt]: Statements [ifndr.stmt]

G.6 Clause [dcl]: Declarations [ifndr.dcl]

G.7 Clause [module]: Modules [ifndr.module]

G.8 Clause [class]: Classes [ifndr.class]

G.9 Clause [over]: Overloading [ifndr.over]

G.10 Clause [temp]: Templates [ifndr.temp]

G.11 Clause [cpp]: Preprocessing directives [ifndr.cpp]

Bibliography

Index

Index of grammar productions

Index of library headers

Index of library names

Index of library concepts

Index of implementation-defined behavior