cppdraft_translate/cppdraft/cppdraft.md

Draft C++ Standard: Contents

# Working Draft  Programming Languages — C++

(Generated on 2025-10-06 from the [LaTeX sources](http://github.com/Eelis/draft/commit/9adde4bc1c62ec234483e63ea3b70a59724c745a) by [cxxdraft-htmlgen](https://github.com/Eelis/cxxdraft-htmlgen). This is *not* an ISO publication.  
 For historical versions of the document, see Tim Song's [cppwp](https://github.com/timsong-cpp/cppwp) page.)  
  
**Note: this is an early draft. It's known to be incomplet and incorrekt, and it has lots of bad formatting.**

  

# Contents

## 1 Scope [[intro.scope]](intro.scope)[[intro.scope]](intro.scope)

## 2 Normative references [[intro.refs]](intro.refs)[[intro.refs]](intro.refs)

## 3 Terms and definitions [[intro.defs]](intro.defs)[[intro.defs]](intro.defs)

## 4 General principles [[intro]](#intro)[[intro]](intro)

### 4.1 Implementation compliance [[intro.compliance]](intro.compliance)

#### 4.1.1 General [[intro.compliance.general]](intro.compliance.general)

#### 4.1.2 Abstract machine [[intro.abstract]](intro.abstract)

### 4.2 Structure of this document [[intro.structure]](intro.structure)

### 4.3 Syntax notation [[syntax]](syntax)

## 5 Lexical conventions [[lex]](#lex)[[lex]](lex)

### 5.1 Separate translation [[lex.separate]](lex.separate)

### 5.2 Phases of translation [[lex.phases]](lex.phases)

### 5.3 Characters [[lex.char]](lex.char)

#### 5.3.1 Character sets [[lex.charset]](lex.charset)

#### 5.3.2 Universal character names [[lex.universal.char]](lex.universal.char)

### 5.4 Comments [[lex.comment]](lex.comment)

### 5.5 Preprocessing tokens [[lex.pptoken]](lex.pptoken)

### 5.6 Header names [[lex.header]](lex.header)

### 5.7 Preprocessing numbers [[lex.ppnumber]](lex.ppnumber)

### 5.8 Operators and punctuators [[lex.operators]](lex.operators)

### 5.9 Alternative tokens [[lex.digraph]](lex.digraph)

### 5.10 Tokens [[lex.token]](lex.token)

### 5.11 Identifiers [[lex.name]](lex.name)

### 5.12 Keywords [[lex.key]](lex.key)

### 5.13 Literals [[lex.literal]](lex.literal)

#### 5.13.1 Kinds of literals [[lex.literal.kinds]](lex.literal.kinds)

#### 5.13.2 Integer literals [[lex.icon]](lex.icon)

#### 5.13.3 Character literals [[lex.ccon]](lex.ccon)

#### 5.13.4 Floating-point literals [[lex.fcon]](lex.fcon)

#### 5.13.5 String literals [[lex.string]](lex.string)

#### 5.13.6 Unevaluated strings [[lex.string.uneval]](lex.string.uneval)

#### 5.13.7 Boolean literals [[lex.bool]](lex.bool)

#### 5.13.8 Pointer literals [[lex.nullptr]](lex.nullptr)

#### 5.13.9 User-defined literals [[lex.ext]](lex.ext)

## 6 Basics [[basic]](#basic)[[basic]](basic)

### 6.1 Preamble [[basic.pre]](basic.pre)

### 6.2 Declarations and definitions [[basic.def]](basic.def)

### 6.3 One-definition rule [[basic.def.odr]](basic.def.odr)

### 6.4 Scope [[basic.scope]](basic.scope)

#### 6.4.1 General [[basic.scope.scope]](basic.scope.scope)

#### 6.4.2 Point of declaration [[basic.scope.pdecl]](basic.scope.pdecl)

#### 6.4.3 Block scope [[basic.scope.block]](basic.scope.block)

#### 6.4.4 Function parameter scope [[basic.scope.param]](basic.scope.param)

#### 6.4.5 Lambda scope [[basic.scope.lambda]](basic.scope.lambda)

#### 6.4.6 Namespace scope [[basic.scope.namespace]](basic.scope.namespace)

#### 6.4.7 Class scope [[basic.scope.class]](basic.scope.class)

#### 6.4.8 Enumeration scope [[basic.scope.enum]](basic.scope.enum)

#### 6.4.9 Template parameter scope [[basic.scope.temp]](basic.scope.temp)

#### 6.4.10 Contract-assertion scope [[basic.scope.contract]](basic.scope.contract)

### 6.5 Name lookup [[basic.lookup]](basic.lookup)

#### 6.5.1 General [[basic.lookup.general]](basic.lookup.general)

#### 6.5.2 Member name lookup [[class.member.lookup]](class.member.lookup)

#### 6.5.3 Unqualified name lookup [[basic.lookup.unqual]](basic.lookup.unqual)

#### 6.5.4 Argument-dependent name lookup [[basic.lookup.argdep]](basic.lookup.argdep)

#### 6.5.5 Qualified name lookup [[basic.lookup.qual]](basic.lookup.qual)

#### 6.5.5.1 General [[basic.lookup.qual.general]](basic.lookup.qual.general)

#### 6.5.5.2 Class members [[class.qual]](class.qual)

#### 6.5.5.3 Namespace members [[namespace.qual]](namespace.qual)

#### 6.5.6 Elaborated type specifiers [[basic.lookup.elab]](basic.lookup.elab)

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

### 6.6 Splice specifiers [[basic.splice]](basic.splice)

### 6.7 Program and linkage [[basic.link]](basic.link)

### 6.8 Memory and objects [[basic.memobj]](basic.memobj)

#### 6.8.1 Memory model [[intro.memory]](intro.memory)

#### 6.8.2 Object model [[intro.object]](intro.object)

#### 6.8.3 Alignment [[basic.align]](basic.align)

#### 6.8.4 Lifetime [[basic.life]](basic.life)

#### 6.8.5 Indeterminate and erroneous values [[basic.indet]](basic.indet)

#### 6.8.6 Storage duration [[basic.stc]](basic.stc)

#### 6.8.6.1 General [[basic.stc.general]](basic.stc.general)

#### 6.8.6.2 Static storage duration [[basic.stc.static]](basic.stc.static)

#### 6.8.6.3 Thread storage duration [[basic.stc.thread]](basic.stc.thread)

#### 6.8.6.4 Automatic storage duration [[basic.stc.auto]](basic.stc.auto)

#### 6.8.6.5 Dynamic storage duration [[basic.stc.dynamic]](basic.stc.dynamic)

#### 6.8.6.5.1 General [[basic.stc.dynamic.general]](basic.stc.dynamic.general)

#### 6.8.6.5.2 Allocation functions [[basic.stc.dynamic.allocation]](basic.stc.dynamic.allocation)

#### 6.8.6.5.3 Deallocation functions [[basic.stc.dynamic.deallocation]](basic.stc.dynamic.deallocation)

#### 6.8.7 Temporary objects [[class.temporary]](class.temporary)

### 6.9 Types [[basic.types]](basic.types)

#### 6.9.1 General [[basic.types.general]](basic.types.general)

#### 6.9.2 Fundamental types [[basic.fundamental]](basic.fundamental)

#### 6.9.3 Optional extended floating-point types [[basic.extended.fp]](basic.extended.fp)

#### 6.9.4 Compound types [[basic.compound]](basic.compound)

#### 6.9.5 CV-qualifiers [[basic.type.qualifier]](basic.type.qualifier)

#### 6.9.6 Conversion ranks [[conv.rank]](conv.rank)

### 6.10 Program execution [[basic.exec]](basic.exec)

#### 6.10.1 Sequential execution [[intro.execution]](intro.execution)

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

#### 6.10.2.1 General [[intro.multithread.general]](intro.multithread.general)

#### 6.10.2.2 Data races [[intro.races]](intro.races)

#### 6.10.2.3 Forward progress [[intro.progress]](intro.progress)

#### 6.10.3 Start and termination [[basic.start]](basic.start)

#### 6.10.3.1 main function [[basic.start.main]](basic.start.main)

#### 6.10.3.2 Static initialization [[basic.start.static]](basic.start.static)

#### 6.10.3.3 Dynamic initialization of non-block variables [[basic.start.dynamic]](basic.start.dynamic)

#### 6.10.3.4 Termination [[basic.start.term]](basic.start.term)

### 6.11 Contract assertions [[basic.contract]](basic.contract)

#### 6.11.1 General [[basic.contract.general]](basic.contract.general)

#### 6.11.2 Evaluation [[basic.contract.eval]](basic.contract.eval)

#### 6.11.3 Contract-violation handler [[basic.contract.handler]](basic.contract.handler)

## 7 Expressions [[expr]](#expr)[[expr]](expr)

### 7.1 Preamble [[expr.pre]](expr.pre)

### 7.2 Properties of expressions [[expr.prop]](expr.prop)

#### 7.2.1 Value category [[basic.lval]](basic.lval)

#### 7.2.2 Type [[expr.type]](expr.type)

#### 7.2.3 Context dependence [[expr.context]](expr.context)

### 7.3 Standard conversions [[conv]](conv)

#### 7.3.1 General [[conv.general]](conv.general)

#### 7.3.2 Lvalue-to-rvalue conversion [[conv.lval]](conv.lval)

#### 7.3.3 Array-to-pointer conversion [[conv.array]](conv.array)

#### 7.3.4 Function-to-pointer conversion [[conv.func]](conv.func)

#### 7.3.5 Temporary materialization conversion [[conv.rval]](conv.rval)

#### 7.3.6 Qualification conversions [[conv.qual]](conv.qual)

#### 7.3.7 Integral promotions [[conv.prom]](conv.prom)

#### 7.3.8 Floating-point promotion [[conv.fpprom]](conv.fpprom)

#### 7.3.9 Integral conversions [[conv.integral]](conv.integral)

#### 7.3.10 Floating-point conversions [[conv.double]](conv.double)

#### 7.3.11 Floating-integral conversions [[conv.fpint]](conv.fpint)

#### 7.3.12 Pointer conversions [[conv.ptr]](conv.ptr)

#### 7.3.13 Pointer-to-member conversions [[conv.mem]](conv.mem)

#### 7.3.14 Function pointer conversions [[conv.fctptr]](conv.fctptr)

#### 7.3.15 Boolean conversions [[conv.bool]](conv.bool)

### 7.4 Usual arithmetic conversions [[expr.arith.conv]](expr.arith.conv)

### 7.5 Primary expressions [[expr.prim]](expr.prim)

#### 7.5.1 Grammar [[expr.prim.grammar]](expr.prim.grammar)

#### 7.5.2 Literals [[expr.prim.literal]](expr.prim.literal)

#### 7.5.3 This [[expr.prim.this]](expr.prim.this)

#### 7.5.4 Parentheses [[expr.prim.paren]](expr.prim.paren)

#### 7.5.5 Names [[expr.prim.id]](expr.prim.id)

#### 7.5.5.1 General [[expr.prim.id.general]](expr.prim.id.general)

#### 7.5.5.2 Unqualified names [[expr.prim.id.unqual]](expr.prim.id.unqual)

#### 7.5.5.3 Qualified names [[expr.prim.id.qual]](expr.prim.id.qual)

#### 7.5.5.4 Pack indexing expression [[expr.prim.pack.index]](expr.prim.pack.index)

#### 7.5.5.5 Destruction [[expr.prim.id.dtor]](expr.prim.id.dtor)

#### 7.5.6 Lambda expressions [[expr.prim.lambda]](expr.prim.lambda)

#### 7.5.6.1 General [[expr.prim.lambda.general]](expr.prim.lambda.general)

#### 7.5.6.2 Closure types [[expr.prim.lambda.closure]](expr.prim.lambda.closure)

#### 7.5.6.3 Captures [[expr.prim.lambda.capture]](expr.prim.lambda.capture)

#### 7.5.7 Fold expressions [[expr.prim.fold]](expr.prim.fold)

#### 7.5.8 Requires expressions [[expr.prim.req]](expr.prim.req)

#### 7.5.8.1 General [[expr.prim.req.general]](expr.prim.req.general)

#### 7.5.8.2 Simple requirements [[expr.prim.req.simple]](expr.prim.req.simple)

#### 7.5.8.3 Type requirements [[expr.prim.req.type]](expr.prim.req.type)

#### 7.5.8.4 Compound requirements [[expr.prim.req.compound]](expr.prim.req.compound)

#### 7.5.8.5 Nested requirements [[expr.prim.req.nested]](expr.prim.req.nested)

#### 7.5.9 Expression splicing [[expr.prim.splice]](expr.prim.splice)

### 7.6 Compound expressions [[expr.compound]](expr.compound)

#### 7.6.1 Postfix expressions [[expr.post]](expr.post)

#### 7.6.1.1 General [[expr.post.general]](expr.post.general)

#### 7.6.1.2 Subscripting [[expr.sub]](expr.sub)

#### 7.6.1.3 Function call [[expr.call]](expr.call)

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

#### 7.6.1.5 Class member access [[expr.ref]](expr.ref)

#### 7.6.1.6 Increment and decrement [[expr.post.incr]](expr.post.incr)

#### 7.6.1.7 Dynamic cast [[expr.dynamic.cast]](expr.dynamic.cast)

#### 7.6.1.8 Type identification [[expr.typeid]](expr.typeid)

#### 7.6.1.9 Static cast [[expr.static.cast]](expr.static.cast)

#### 7.6.1.10 Reinterpret cast [[expr.reinterpret.cast]](expr.reinterpret.cast)

#### 7.6.1.11 Const cast [[expr.const.cast]](expr.const.cast)

#### 7.6.2 Unary expressions [[expr.unary]](expr.unary)

#### 7.6.2.1 General [[expr.unary.general]](expr.unary.general)

#### 7.6.2.2 Unary operators [[expr.unary.op]](expr.unary.op)

#### 7.6.2.3 Increment and decrement [[expr.pre.incr]](expr.pre.incr)

#### 7.6.2.4 Await [[expr.await]](expr.await)

#### 7.6.2.5 Sizeof [[expr.sizeof]](expr.sizeof)

#### 7.6.2.6 Alignof [[expr.alignof]](expr.alignof)

#### 7.6.2.7 noexcept operator [[expr.unary.noexcept]](expr.unary.noexcept)

#### 7.6.2.8 New [[expr.new]](expr.new)

#### 7.6.2.9 Delete [[expr.delete]](expr.delete)

#### 7.6.2.10 The reflection operator [[expr.reflect]](expr.reflect)

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

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

#### 7.6.5 Multiplicative operators [[expr.mul]](expr.mul)

#### 7.6.6 Additive operators [[expr.add]](expr.add)

#### 7.6.7 Shift operators [[expr.shift]](expr.shift)

#### 7.6.8 Three-way comparison operator [[expr.spaceship]](expr.spaceship)

#### 7.6.9 Relational operators [[expr.rel]](expr.rel)

#### 7.6.10 Equality operators [[expr.eq]](expr.eq)

#### 7.6.11 Bitwise AND operator [[expr.bit.and]](expr.bit.and)

#### 7.6.12 Bitwise exclusive OR operator [[expr.xor]](expr.xor)

#### 7.6.13 Bitwise inclusive OR operator [[expr.or]](expr.or)

#### 7.6.14 Logical AND operator [[expr.log.and]](expr.log.and)

#### 7.6.15 Logical OR operator [[expr.log.or]](expr.log.or)

#### 7.6.16 Conditional operator [[expr.cond]](expr.cond)

#### 7.6.17 Yielding a value [[expr.yield]](expr.yield)

#### 7.6.18 Throwing an exception [[expr.throw]](expr.throw)

#### 7.6.19 Assignment and compound assignment operators [[expr.assign]](expr.assign)

#### 7.6.20 Comma operator [[expr.comma]](expr.comma)

### 7.7 Constant expressions [[expr.const]](expr.const)

## 8 Statements [[stmt]](#stmt)[[stmt]](stmt)

### 8.1 Preamble [[stmt.pre]](stmt.pre)

### 8.2 Label [[stmt.label]](stmt.label)

### 8.3 Expression statement [[stmt.expr]](stmt.expr)

### 8.4 Compound statement or block [[stmt.block]](stmt.block)

### 8.5 Selection statements [[stmt.select]](stmt.select)

#### 8.5.1 General [[stmt.select.general]](stmt.select.general)

#### 8.5.2 The if statement [[stmt.if]](stmt.if)

#### 8.5.3 The switch statement [[stmt.switch]](stmt.switch)

### 8.6 Iteration statements [[stmt.iter]](stmt.iter)

#### 8.6.1 General [[stmt.iter.general]](stmt.iter.general)

#### 8.6.2 The while statement [[stmt.while]](stmt.while)

#### 8.6.3 The do statement [[stmt.do]](stmt.do)

#### 8.6.4 The for statement [[stmt.for]](stmt.for)

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

### 8.7 Expansion statements [[stmt.expand]](stmt.expand)

### 8.8 Jump statements [[stmt.jump]](stmt.jump)

#### 8.8.1 General [[stmt.jump.general]](stmt.jump.general)

#### 8.8.2 The break statement [[stmt.break]](stmt.break)

#### 8.8.3 The continue statement [[stmt.cont]](stmt.cont)

#### 8.8.4 The return statement [[stmt.return]](stmt.return)

#### 8.8.5 The co_return statement [[stmt.return.coroutine]](stmt.return.coroutine)

#### 8.8.6 The goto statement [[stmt.goto]](stmt.goto)

### 8.9 Assertion statement [[stmt.contract.assert]](stmt.contract.assert)

### 8.10 Declaration statement [[stmt.dcl]](stmt.dcl)

### 8.11 Ambiguity resolution [[stmt.ambig]](stmt.ambig)

## 9 Declarations [[dcl]](#dcl)[[dcl]](dcl)

### 9.1 Preamble [[dcl.pre]](dcl.pre)

### 9.2 Specifiers [[dcl.spec]](dcl.spec)

#### 9.2.1 General [[dcl.spec.general]](dcl.spec.general)

#### 9.2.2 Storage class specifiers [[dcl.stc]](dcl.stc)

#### 9.2.3 Function specifiers [[dcl.fct.spec]](dcl.fct.spec)

#### 9.2.4 The typedef specifier [[dcl.typedef]](dcl.typedef)

#### 9.2.5 The friend specifier [[dcl.friend]](dcl.friend)

#### 9.2.6 The constexpr and consteval specifiers [[dcl.constexpr]](dcl.constexpr)

#### 9.2.7 The constinit specifier [[dcl.constinit]](dcl.constinit)

#### 9.2.8 The inline specifier [[dcl.inline]](dcl.inline)

#### 9.2.9 Type specifiers [[dcl.type]](dcl.type)

#### 9.2.9.1 General [[dcl.type.general]](dcl.type.general)

#### 9.2.9.2 The *cv-qualifier**s* [[dcl.type.cv]](dcl.type.cv)

#### 9.2.9.3 Simple type specifiers [[dcl.type.simple]](dcl.type.simple)

#### 9.2.9.4 Pack indexing specifier [[dcl.type.pack.index]](dcl.type.pack.index)

#### 9.2.9.5 Elaborated type specifiers [[dcl.type.elab]](dcl.type.elab)

#### 9.2.9.6 Decltype specifiers [[dcl.type.decltype]](dcl.type.decltype)

#### 9.2.9.7 Placeholder type specifiers [[dcl.spec.auto]](dcl.spec.auto)

#### 9.2.9.7.1 General [[dcl.spec.auto.general]](dcl.spec.auto.general)

#### 9.2.9.7.2 Placeholder type deduction [[dcl.type.auto.deduct]](dcl.type.auto.deduct)

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

#### 9.2.9.9 Type splicing [[dcl.type.splice]](dcl.type.splice)

### 9.3 Declarators [[dcl.decl]](dcl.decl)

#### 9.3.1 General [[dcl.decl.general]](dcl.decl.general)

#### 9.3.2 Type names [[dcl.name]](dcl.name)

#### 9.3.3 Ambiguity resolution [[dcl.ambig.res]](dcl.ambig.res)

#### 9.3.4 Meaning of declarators [[dcl.meaning]](dcl.meaning)

#### 9.3.4.1 General [[dcl.meaning.general]](dcl.meaning.general)

#### 9.3.4.2 Pointers [[dcl.ptr]](dcl.ptr)

#### 9.3.4.3 References [[dcl.ref]](dcl.ref)

#### 9.3.4.4 Pointers to members [[dcl.mptr]](dcl.mptr)

#### 9.3.4.5 Arrays [[dcl.array]](dcl.array)

#### 9.3.4.6 Functions [[dcl.fct]](dcl.fct)

#### 9.3.4.7 Default arguments [[dcl.fct.default]](dcl.fct.default)

### 9.4 Function contract specifiers [[dcl.contract]](dcl.contract)

#### 9.4.1 General [[dcl.contract.func]](dcl.contract.func)

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

### 9.5 Initializers [[dcl.init]](dcl.init)

#### 9.5.1 General [[dcl.init.general]](dcl.init.general)

#### 9.5.2 Aggregates [[dcl.init.aggr]](dcl.init.aggr)

#### 9.5.3 Character arrays [[dcl.init.string]](dcl.init.string)

#### 9.5.4 References [[dcl.init.ref]](dcl.init.ref)

#### 9.5.5 List-initialization [[dcl.init.list]](dcl.init.list)

### 9.6 Function definitions [[dcl.fct.def]](dcl.fct.def)

#### 9.6.1 General [[dcl.fct.def.general]](dcl.fct.def.general)

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

#### 9.6.3 Deleted definitions [[dcl.fct.def.delete]](dcl.fct.def.delete)

#### 9.6.4 Coroutine definitions [[dcl.fct.def.coroutine]](dcl.fct.def.coroutine)

#### 9.6.5 Replaceable function definitions [[dcl.fct.def.replace]](dcl.fct.def.replace)

### 9.7 Structured binding declarations [[dcl.struct.bind]](dcl.struct.bind)

### 9.8 Enumerations [[enum]](enum)

#### 9.8.1 Enumeration declarations [[dcl.enum]](dcl.enum)

#### 9.8.2 The using enum declaration [[enum.udecl]](enum.udecl)

### 9.9 Namespaces [[basic.namespace]](basic.namespace)

#### 9.9.1 General [[basic.namespace.general]](basic.namespace.general)

#### 9.9.2 Namespace definition [[namespace.def]](namespace.def)

#### 9.9.2.1 General [[namespace.def.general]](namespace.def.general)

#### 9.9.2.2 Unnamed namespaces [[namespace.unnamed]](namespace.unnamed)

#### 9.9.3 Namespace alias [[namespace.alias]](namespace.alias)

#### 9.9.4 Using namespace directive [[namespace.udir]](namespace.udir)

### 9.10 The using declaration [[namespace.udecl]](namespace.udecl)

### 9.11 The asm declaration [[dcl.asm]](dcl.asm)

### 9.12 Linkage specifications [[dcl.link]](dcl.link)

### 9.13 Attributes [[dcl.attr]](dcl.attr)

#### 9.13.1 Attribute syntax and semantics [[dcl.attr.grammar]](dcl.attr.grammar)

#### 9.13.2 Alignment specifier [[dcl.align]](dcl.align)

#### 9.13.3 Assumption attribute [[dcl.attr.assume]](dcl.attr.assume)

#### 9.13.4 Deprecated attribute [[dcl.attr.deprecated]](dcl.attr.deprecated)

#### 9.13.5 Fallthrough attribute [[dcl.attr.fallthrough]](dcl.attr.fallthrough)

#### 9.13.6 Indeterminate storage [[dcl.attr.indet]](dcl.attr.indet)

#### 9.13.7 Likelihood attributes [[dcl.attr.likelihood]](dcl.attr.likelihood)

#### 9.13.8 Maybe unused attribute [[dcl.attr.unused]](dcl.attr.unused)

#### 9.13.9 Nodiscard attribute [[dcl.attr.nodiscard]](dcl.attr.nodiscard)

#### 9.13.10 Noreturn attribute [[dcl.attr.noreturn]](dcl.attr.noreturn)

#### 9.13.11 No unique address attribute [[dcl.attr.nouniqueaddr]](dcl.attr.nouniqueaddr)

#### 9.13.12 Annotations [[dcl.attr.annotation]](dcl.attr.annotation)

## 10 Modules [[module]](#module)[[module]](module)

### 10.1 Module units and purviews [[module.unit]](module.unit)

### 10.2 Export declaration [[module.interface]](module.interface)

### 10.3 Import declaration [[module.import]](module.import)

### 10.4 Global module fragment [[module.global.frag]](module.global.frag)

### 10.5 Private module fragment [[module.private.frag]](module.private.frag)

### 10.6 Instantiation context [[module.context]](module.context)

### 10.7 Reachability [[module.reach]](module.reach)

## 11 Classes [[class]](#class)[[class]](class)

### 11.1 Preamble [[class.pre]](class.pre)

### 11.2 Properties of classes [[class.prop]](class.prop)

### 11.3 Class names [[class.name]](class.name)

### 11.4 Class members [[class.mem]](class.mem)

#### 11.4.1 General [[class.mem.general]](class.mem.general)

#### 11.4.2 Member functions [[class.mfct]](class.mfct)

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

#### 11.4.4 Special member functions [[special]](special)

#### 11.4.5 Constructors [[class.ctor]](class.ctor)

#### 11.4.5.1 General [[class.ctor.general]](class.ctor.general)

#### 11.4.5.2 Default constructors [[class.default.ctor]](class.default.ctor)

#### 11.4.5.3 Copy/move constructors [[class.copy.ctor]](class.copy.ctor)

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

#### 11.4.7 Destructors [[class.dtor]](class.dtor)

#### 11.4.8 Conversions [[class.conv]](class.conv)

#### 11.4.8.1 General [[class.conv.general]](class.conv.general)

#### 11.4.8.2 Conversion by constructor [[class.conv.ctor]](class.conv.ctor)

#### 11.4.8.3 Conversion functions [[class.conv.fct]](class.conv.fct)

#### 11.4.9 Static members [[class.static]](class.static)

#### 11.4.9.1 General [[class.static.general]](class.static.general)

#### 11.4.9.2 Static member functions [[class.static.mfct]](class.static.mfct)

#### 11.4.9.3 Static data members [[class.static.data]](class.static.data)

#### 11.4.10 Bit-fields [[class.bit]](class.bit)

#### 11.4.11 Allocation and deallocation functions [[class.free]](class.free)

#### 11.4.12 Nested class declarations [[class.nest]](class.nest)

### 11.5 Unions [[class.union]](class.union)

#### 11.5.1 General [[class.union.general]](class.union.general)

#### 11.5.2 Anonymous unions [[class.union.anon]](class.union.anon)

### 11.6 Local class declarations [[class.local]](class.local)

### 11.7 Derived classes [[class.derived]](class.derived)

#### 11.7.1 General [[class.derived.general]](class.derived.general)

#### 11.7.2 Multiple base classes [[class.mi]](class.mi)

#### 11.7.3 Virtual functions [[class.virtual]](class.virtual)

#### 11.7.4 Abstract classes [[class.abstract]](class.abstract)

### 11.8 Member access control [[class.access]](class.access)

#### 11.8.1 General [[class.access.general]](class.access.general)

#### 11.8.2 Access specifiers [[class.access.spec]](class.access.spec)

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

#### 11.8.4 Friends [[class.friend]](class.friend)

#### 11.8.5 Protected member access [[class.protected]](class.protected)

#### 11.8.6 Access to virtual functions [[class.access.virt]](class.access.virt)

#### 11.8.7 Multiple access [[class.paths]](class.paths)

#### 11.8.8 Nested classes [[class.access.nest]](class.access.nest)

### 11.9 Initialization [[class.init]](class.init)

#### 11.9.1 General [[class.init.general]](class.init.general)

#### 11.9.2 Explicit initialization [[class.expl.init]](class.expl.init)

#### 11.9.3 Initializing bases and members [[class.base.init]](class.base.init)

#### 11.9.4 Initialization by inherited constructor [[class.inhctor.init]](class.inhctor.init)

#### 11.9.5 Construction and destruction [[class.cdtor]](class.cdtor)

#### 11.9.6 Copy/move elision [[class.copy.elision]](class.copy.elision)

### 11.10 Comparisons [[class.compare]](class.compare)

#### 11.10.1 Defaulted comparison operator functions [[class.compare.default]](class.compare.default)

#### 11.10.2 Equality operator [[class.eq]](class.eq)

#### 11.10.3 Three-way comparison [[class.spaceship]](class.spaceship)

#### 11.10.4 Secondary comparison operators [[class.compare.secondary]](class.compare.secondary)

## 12 Overloading [[over]](#over)[[over]](over)

### 12.1 Preamble [[over.pre]](over.pre)

### 12.2 Overload resolution [[over.match]](over.match)

#### 12.2.1 General [[over.match.general]](over.match.general)

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

#### 12.2.2.1 General [[over.match.funcs.general]](over.match.funcs.general)

#### 12.2.2.2 Function call syntax [[over.match.call]](over.match.call)

#### 12.2.2.2.1 General [[over.match.call.general]](over.match.call.general)

#### 12.2.2.2.2 Call to designated function [[over.call.func]](over.call.func)

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

#### 12.2.2.3 Operators in expressions [[over.match.oper]](over.match.oper)

#### 12.2.2.4 Initialization by constructor [[over.match.ctor]](over.match.ctor)

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

#### 12.2.2.6 Initialization by conversion function [[over.match.conv]](over.match.conv)

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

#### 12.2.2.8 Initialization by list-initialization [[over.match.list]](over.match.list)

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

#### 12.2.3 Viable functions [[over.match.viable]](over.match.viable)

#### 12.2.4 Best viable function [[over.match.best]](over.match.best)

#### 12.2.4.1 General [[over.match.best.general]](over.match.best.general)

#### 12.2.4.2 Implicit conversion sequences [[over.best.ics]](over.best.ics)

#### 12.2.4.2.1 General [[over.best.ics.general]](over.best.ics.general)

#### 12.2.4.2.2 Standard conversion sequences [[over.ics.scs]](over.ics.scs)

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

#### 12.2.4.2.4 Ellipsis conversion sequences [[over.ics.ellipsis]](over.ics.ellipsis)

#### 12.2.4.2.5 Reference binding [[over.ics.ref]](over.ics.ref)

#### 12.2.4.2.6 List-initialization sequence [[over.ics.list]](over.ics.list)

#### 12.2.4.3 Ranking implicit conversion sequences [[over.ics.rank]](over.ics.rank)

### 12.3 Address of an overload set [[over.over]](over.over)

### 12.4 Overloaded operators [[over.oper]](over.oper)

#### 12.4.1 General [[over.oper.general]](over.oper.general)

#### 12.4.2 Unary operators [[over.unary]](over.unary)

#### 12.4.3 Binary operators [[over.binary]](over.binary)

#### 12.4.3.1 General [[over.binary.general]](over.binary.general)

#### 12.4.3.2 Simple assignment [[over.assign]](over.assign)

#### 12.4.4 Function call [[over.call]](over.call)

#### 12.4.5 Subscripting [[over.sub]](over.sub)

#### 12.4.6 Class member access [[over.ref]](over.ref)

#### 12.4.7 Increment and decrement [[over.inc]](over.inc)

### 12.5 Built-in operators [[over.built]](over.built)

### 12.6 User-defined literals [[over.literal]](over.literal)

## 13 Templates [[temp]](#temp)[[temp]](temp)

### 13.1 Preamble [[temp.pre]](temp.pre)

### 13.2 Template parameters [[temp.param]](temp.param)

### 13.3 Names of template specializations [[temp.names]](temp.names)

### 13.4 Template arguments [[temp.arg]](temp.arg)

#### 13.4.1 General [[temp.arg.general]](temp.arg.general)

#### 13.4.2 Type template arguments [[temp.arg.type]](temp.arg.type)

#### 13.4.3 Constant template arguments [[temp.arg.nontype]](temp.arg.nontype)

#### 13.4.4 Template template arguments [[temp.arg.template]](temp.arg.template)

### 13.5 Template constraints [[temp.constr]](temp.constr)

#### 13.5.1 General [[temp.constr.general]](temp.constr.general)

#### 13.5.2 Constraints [[temp.constr.constr]](temp.constr.constr)

#### 13.5.2.1 General [[temp.constr.constr.general]](temp.constr.constr.general)

#### 13.5.2.2 Logical operations [[temp.constr.op]](temp.constr.op)

#### 13.5.2.3 Atomic constraints [[temp.constr.atomic]](temp.constr.atomic)

#### 13.5.2.4 Concept-dependent constraints [[temp.constr.concept]](temp.constr.concept)

#### 13.5.2.5 Fold expanded constraint [[temp.constr.fold]](temp.constr.fold)

#### 13.5.3 Constrained declarations [[temp.constr.decl]](temp.constr.decl)

#### 13.5.4 Constraint normalization [[temp.constr.normal]](temp.constr.normal)

#### 13.5.5 Partial ordering by constraints [[temp.constr.order]](temp.constr.order)

### 13.6 Type equivalence [[temp.type]](temp.type)

### 13.7 Template declarations [[temp.decls]](temp.decls)

#### 13.7.1 General [[temp.decls.general]](temp.decls.general)

#### 13.7.2 Class templates [[temp.class]](temp.class)

#### 13.7.2.1 General [[temp.class.general]](temp.class.general)

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

#### 13.7.2.3 Deduction guides [[temp.deduct.guide]](temp.deduct.guide)

#### 13.7.2.4 Member classes of class templates [[temp.mem.class]](temp.mem.class)

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

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

#### 13.7.3 Member templates [[temp.mem]](temp.mem)

#### 13.7.4 Variadic templates [[temp.variadic]](temp.variadic)

#### 13.7.5 Friends [[temp.friend]](temp.friend)

#### 13.7.6 Partial specialization [[temp.spec.partial]](temp.spec.partial)

#### 13.7.6.1 General [[temp.spec.partial.general]](temp.spec.partial.general)

#### 13.7.6.2 Matching of partial specializations [[temp.spec.partial.match]](temp.spec.partial.match)

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

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

#### 13.7.7 Function templates [[temp.fct]](temp.fct)

#### 13.7.7.1 General [[temp.fct.general]](temp.fct.general)

#### 13.7.7.2 Function template overloading [[temp.over.link]](temp.over.link)

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

#### 13.7.8 Alias templates [[temp.alias]](temp.alias)

#### 13.7.9 Concept definitions [[temp.concept]](temp.concept)

### 13.8 Name resolution [[temp.res]](temp.res)

#### 13.8.1 General [[temp.res.general]](temp.res.general)

#### 13.8.2 Locally declared names [[temp.local]](temp.local)

#### 13.8.3 Dependent names [[temp.dep]](temp.dep)

#### 13.8.3.1 General [[temp.dep.general]](temp.dep.general)

#### 13.8.3.2 Dependent types [[temp.dep.type]](temp.dep.type)

#### 13.8.3.3 Type-dependent expressions [[temp.dep.expr]](temp.dep.expr)

#### 13.8.3.4 Value-dependent expressions [[temp.dep.constexpr]](temp.dep.constexpr)

#### 13.8.3.5 Dependent splice specifiers [[temp.dep.splice]](temp.dep.splice)

#### 13.8.3.6 Dependent namespaces [[temp.dep.namespace]](temp.dep.namespace)

#### 13.8.3.7 Dependent template arguments [[temp.dep.temp]](temp.dep.temp)

#### 13.8.4 Dependent name resolution [[temp.dep.res]](temp.dep.res)

#### 13.8.4.1 Point of instantiation [[temp.point]](temp.point)

#### 13.8.4.2 Candidate functions [[temp.dep.candidate]](temp.dep.candidate)

### 13.9 Template instantiation and specialization [[temp.spec]](temp.spec)

#### 13.9.1 General [[temp.spec.general]](temp.spec.general)

#### 13.9.2 Implicit instantiation [[temp.inst]](temp.inst)

#### 13.9.3 Explicit instantiation [[temp.explicit]](temp.explicit)

#### 13.9.4 Explicit specialization [[temp.expl.spec]](temp.expl.spec)

### 13.10 Function template specializations [[temp.fct.spec]](temp.fct.spec)

#### 13.10.1 General [[temp.fct.spec.general]](temp.fct.spec.general)

#### 13.10.2 Explicit template argument specification [[temp.arg.explicit]](temp.arg.explicit)

#### 13.10.3 Template argument deduction [[temp.deduct]](temp.deduct)

#### 13.10.3.1 General [[temp.deduct.general]](temp.deduct.general)

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

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

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

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

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

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

#### 13.10.4 Overload resolution [[temp.over]](temp.over)

## 14 Exception handling [[except]](#except)[[except]](except)

### 14.1 Preamble [[except.pre]](except.pre)

### 14.2 Throwing an exception [[except.throw]](except.throw)

### 14.3 Stack unwinding [[except.ctor]](except.ctor)

### 14.4 Handling an exception [[except.handle]](except.handle)

### 14.5 Exception specifications [[except.spec]](except.spec)

### 14.6 Special functions [[except.special]](except.special)

#### 14.6.1 General [[except.special.general]](except.special.general)

#### 14.6.2 The std​::​terminate function [[except.terminate]](except.terminate)

## 15 Preprocessing directives [[cpp]](#cpp)[[cpp]](cpp)

### 15.1 Preamble [[cpp.pre]](cpp.pre)

### 15.2 Conditional inclusion [[cpp.cond]](cpp.cond)

### 15.3 Source file inclusion [[cpp.include]](cpp.include)

### 15.4 Resource inclusion [[cpp.embed]](cpp.embed)

#### 15.4.1 General [[cpp.embed.gen]](cpp.embed.gen)

#### 15.4.2 Embed parameters [[cpp.embed.param]](cpp.embed.param)

#### 15.4.2.1 limit parameter [[cpp.embed.param.limit]](cpp.embed.param.limit)

#### 15.4.2.2 prefix parameter [[cpp.embed.param.prefix]](cpp.embed.param.prefix)

#### 15.4.2.3 suffix parameter [[cpp.embed.param.suffix]](cpp.embed.param.suffix)

#### 15.4.2.4 if_empty parameter [[cpp.embed.param.if.empty]](cpp.embed.param.if.empty)

### 15.5 Module directive [[cpp.module]](cpp.module)

### 15.6 Header unit importation [[cpp.import]](cpp.import)

### 15.7 Macro replacement [[cpp.replace]](cpp.replace)

#### 15.7.1 General [[cpp.replace.general]](cpp.replace.general)

#### 15.7.2 Argument substitution [[cpp.subst]](cpp.subst)

#### 15.7.3 The # operator [[cpp.stringize]](cpp.stringize)

#### 15.7.4 The ## operator [[cpp.concat]](cpp.concat)

#### 15.7.5 Rescanning and further replacement [[cpp.rescan]](cpp.rescan)

#### 15.7.6 Scope of macro definitions [[cpp.scope]](cpp.scope)

### 15.8 Line control [[cpp.line]](cpp.line)

### 15.9 Diagnostic directives [[cpp.error]](cpp.error)

### 15.10 Pragma directive [[cpp.pragma]](cpp.pragma)

### 15.11 Null directive [[cpp.null]](cpp.null)

### 15.12 Predefined macro names [[cpp.predefined]](cpp.predefined)

### 15.13 Pragma operator [[cpp.pragma.op]](cpp.pragma.op)

## 16 Library introduction [[library]](#library)[[library]](library)

### 16.1 General [[library.general]](library.general)

### 16.2 The C standard library [[library.c]](library.c)

### 16.3 Method of description [[description]](description)

#### 16.3.1 General [[description.general]](description.general)

#### 16.3.2 Structure of each clause [[structure]](structure)

#### 16.3.2.1 Elements [[structure.elements]](structure.elements)

#### 16.3.2.2 Summary [[structure.summary]](structure.summary)

#### 16.3.2.3 Requirements [[structure.requirements]](structure.requirements)

#### 16.3.2.4 Detailed specifications [[structure.specifications]](structure.specifications)

#### 16.3.2.5 C library [[structure.see.also]](structure.see.also)

#### 16.3.3 Other conventions [[conventions]](conventions)

#### 16.3.3.1 General [[conventions.general]](conventions.general)

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

#### 16.3.3.3 Type descriptions [[type.descriptions]](type.descriptions)

#### 16.3.3.3.1 General [[type.descriptions.general]](type.descriptions.general)

#### 16.3.3.3.2 Enumerated types [[enumerated.types]](enumerated.types)

#### 16.3.3.3.3 Bitmask types [[bitmask.types]](bitmask.types)

#### 16.3.3.3.4 Character sequences [[character.seq]](character.seq)

#### 16.3.3.3.4.1 General [[character.seq.general]](character.seq.general)

#### 16.3.3.3.4.2 Byte strings [[byte.strings]](byte.strings)

#### 16.3.3.3.4.3 Multibyte strings [[multibyte.strings]](multibyte.strings)

#### 16.3.3.3.5 Customization Point Object types [[customization.point.object]](customization.point.object)

#### 16.3.3.4 Algorithm function objects [[alg.func.obj]](alg.func.obj)

#### 16.3.3.5 Functions within classes [[functions.within.classes]](functions.within.classes)

#### 16.3.3.6 Private members [[objects.within.classes]](objects.within.classes)

#### 16.3.3.7 Freestanding items [[freestanding.item]](freestanding.item)

### 16.4 Library-wide requirements [[requirements]](requirements)

#### 16.4.1 General [[requirements.general]](requirements.general)

#### 16.4.2 Library contents and organization [[organization]](organization)

#### 16.4.2.1 General [[organization.general]](organization.general)

#### 16.4.2.2 Library contents [[contents]](contents)

#### 16.4.2.3 Headers [[headers]](headers)

#### 16.4.2.4 Modules [[std.modules]](std.modules)

#### 16.4.2.5 Freestanding implementations [[compliance]](compliance)

#### 16.4.3 Using the library [[using]](using)

#### 16.4.3.1 Overview [[using.overview]](using.overview)

#### 16.4.3.2 Headers [[using.headers]](using.headers)

#### 16.4.3.3 Linkage [[using.linkage]](using.linkage)

#### 16.4.4 Requirements on types and expressions [[utility.requirements]](utility.requirements)

#### 16.4.4.1 General [[utility.requirements.general]](utility.requirements.general)

#### 16.4.4.2 Template argument requirements [[utility.arg.requirements]](utility.arg.requirements)

#### 16.4.4.3 Swappable requirements [[swappable.requirements]](swappable.requirements)

#### 16.4.4.4 *Cpp17NullablePointer* requirements [[nullablepointer.requirements]](nullablepointer.requirements)

#### 16.4.4.5 *Cpp17Hash* requirements [[hash.requirements]](hash.requirements)

#### 16.4.4.6 *Cpp17Allocator* requirements [[allocator.requirements]](allocator.requirements)

#### 16.4.4.6.1 General [[allocator.requirements.general]](allocator.requirements.general)

#### 16.4.4.6.2 Allocator completeness requirements [[allocator.requirements.completeness]](allocator.requirements.completeness)

#### 16.4.5 Constraints on programs [[constraints]](constraints)

#### 16.4.5.1 Overview [[constraints.overview]](constraints.overview)

#### 16.4.5.2 Namespace use [[namespace.constraints]](namespace.constraints)

#### 16.4.5.2.1 Namespace std [[namespace.std]](namespace.std)

#### 16.4.5.2.2 Namespace posix [[namespace.posix]](namespace.posix)

#### 16.4.5.2.3 Namespaces for future standardization [[namespace.future]](namespace.future)

#### 16.4.5.3 Reserved names [[reserved.names]](reserved.names)

#### 16.4.5.3.1 General [[reserved.names.general]](reserved.names.general)

#### 16.4.5.3.2 Zombie names [[zombie.names]](zombie.names)

#### 16.4.5.3.3 Macro names [[macro.names]](macro.names)

#### 16.4.5.3.4 External linkage [[extern.names]](extern.names)

#### 16.4.5.3.5 Types [[extern.types]](extern.types)

#### 16.4.5.3.6 User-defined literal suffixes [[usrlit.suffix]](usrlit.suffix)

#### 16.4.5.4 Headers [[alt.headers]](alt.headers)

#### 16.4.5.5 Derived classes [[derived.classes]](derived.classes)

#### 16.4.5.6 Replacement functions [[replacement.functions]](replacement.functions)

#### 16.4.5.7 Handler functions [[handler.functions]](handler.functions)

#### 16.4.5.8 Other functions [[res.on.functions]](res.on.functions)

#### 16.4.5.9 Function arguments [[res.on.arguments]](res.on.arguments)

#### 16.4.5.10 Library object access [[res.on.objects]](res.on.objects)

#### 16.4.5.11 Semantic requirements [[res.on.requirements]](res.on.requirements)

#### 16.4.6 Conforming implementations [[conforming]](conforming)

#### 16.4.6.1 Overview [[conforming.overview]](conforming.overview)

#### 16.4.6.2 Headers [[res.on.headers]](res.on.headers)

#### 16.4.6.3 Restrictions on macro definitions [[res.on.macro.definitions]](res.on.macro.definitions)

#### 16.4.6.4 Non-member functions [[global.functions]](global.functions)

#### 16.4.6.5 Member functions [[member.functions]](member.functions)

#### 16.4.6.6 Friend functions [[hidden.friends]](hidden.friends)

#### 16.4.6.7 Constexpr functions and constructors [[constexpr.functions]](constexpr.functions)

#### 16.4.6.8 Requirements for stable algorithms [[algorithm.stable]](algorithm.stable)

#### 16.4.6.9 Reentrancy [[reentrancy]](reentrancy)

#### 16.4.6.10 Data race avoidance [[res.on.data.races]](res.on.data.races)

#### 16.4.6.11 Properties of library classes [[library.class.props]](library.class.props)

#### 16.4.6.12 Protection within classes [[protection.within.classes]](protection.within.classes)

#### 16.4.6.13 Derived classes [[derivation]](derivation)

#### 16.4.6.14 Restrictions on exception handling [[res.on.exception.handling]](res.on.exception.handling)

#### 16.4.6.15 Contract assertions [[res.contract.assertions]](res.contract.assertions)

#### 16.4.6.16 Value of error codes [[value.error.codes]](value.error.codes)

#### 16.4.6.17 Moved-from state of library types [[lib.types.movedfrom]](lib.types.movedfrom)

## 17 Language support library [[support]](#support)[[support]](support)

### 17.1 General [[support.general]](support.general)

### 17.2 Common definitions [[support.types]](support.types)

#### 17.2.1 Header <cstddef> synopsis [[cstddef.syn]](cstddef.syn)

#### 17.2.2 Header <cstdlib> synopsis [[cstdlib.syn]](cstdlib.syn)

#### 17.2.3 Null pointers [[support.types.nullptr]](support.types.nullptr)

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

#### 17.2.5 byte type operations [[support.types.byteops]](support.types.byteops)

### 17.3 Implementation properties [[support.limits]](support.limits)

#### 17.3.1 General [[support.limits.general]](support.limits.general)

#### 17.3.2 Header <version> synopsis [[version.syn]](version.syn)

#### 17.3.3 Header <limits> synopsis [[limits.syn]](limits.syn)

#### 17.3.4 Enum float_round_style [[round.style]](round.style)

#### 17.3.5 Class template numeric_limits [[numeric.limits]](numeric.limits)

#### 17.3.5.1 General [[numeric.limits.general]](numeric.limits.general)

#### 17.3.5.2 numeric_limits members [[numeric.limits.members]](numeric.limits.members)

#### 17.3.5.3 numeric_limits specializations [[numeric.special]](numeric.special)

#### 17.3.6 Header <climits> synopsis [[climits.syn]](climits.syn)

#### 17.3.7 Header <cfloat> synopsis [[cfloat.syn]](cfloat.syn)

### 17.4 Arithmetic types [[support.arith.types]](support.arith.types)

#### 17.4.1 Header <cstdint> synopsis [[cstdint.syn]](cstdint.syn)

#### 17.4.2 Header <stdfloat> synopsis [[stdfloat.syn]](stdfloat.syn)

### 17.5 Startup and termination [[support.start.term]](support.start.term)

### 17.6 Dynamic memory management [[support.dynamic]](support.dynamic)

#### 17.6.1 General [[support.dynamic.general]](support.dynamic.general)

#### 17.6.2 Header <new> synopsis [[new.syn]](new.syn)

#### 17.6.3 Storage allocation and deallocation [[new.delete]](new.delete)

#### 17.6.3.1 General [[new.delete.general]](new.delete.general)

#### 17.6.3.2 Single-object forms [[new.delete.single]](new.delete.single)

#### 17.6.3.3 Array forms [[new.delete.array]](new.delete.array)

#### 17.6.3.4 Non-allocating forms [[new.delete.placement]](new.delete.placement)

#### 17.6.3.5 Data races [[new.delete.dataraces]](new.delete.dataraces)

#### 17.6.4 Storage allocation errors [[alloc.errors]](alloc.errors)

#### 17.6.4.1 Class bad_alloc [[bad.alloc]](bad.alloc)

#### 17.6.4.2 Class bad_array_new_length [[new.badlength]](new.badlength)

#### 17.6.4.3 Type new_handler [[new.handler]](new.handler)

#### 17.6.4.4 set_new_handler [[set.new.handler]](set.new.handler)

#### 17.6.4.5 get_new_handler [[get.new.handler]](get.new.handler)

#### 17.6.5 Pointer optimization barrier [[ptr.launder]](ptr.launder)

#### 17.6.6 Hardware interference size [[hardware.interference]](hardware.interference)

### 17.7 Type identification [[support.rtti]](support.rtti)

#### 17.7.1 General [[support.rtti.general]](support.rtti.general)

#### 17.7.2 Header <typeinfo> synopsis [[typeinfo.syn]](typeinfo.syn)

#### 17.7.3 Class type_info [[type.info]](type.info)

#### 17.7.4 Class bad_cast [[bad.cast]](bad.cast)

#### 17.7.5 Class bad_typeid [[bad.typeid]](bad.typeid)

#### 17.7.6 Header <typeindex> synopsis [[type.index.synopsis]](type.index.synopsis)

#### 17.7.7 Class type_index [[type.index]](type.index)

### 17.8 Source location [[support.srcloc]](support.srcloc)

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

#### 17.8.2 Class source_location [[support.srcloc.class]](support.srcloc.class)

#### 17.8.2.1 General [[support.srcloc.class.general]](support.srcloc.class.general)

#### 17.8.2.2 Creation [[support.srcloc.cons]](support.srcloc.cons)

#### 17.8.2.3 Observers [[support.srcloc.obs]](support.srcloc.obs)

### 17.9 Exception handling [[support.exception]](support.exception)

#### 17.9.1 General [[support.exception.general]](support.exception.general)

#### 17.9.2 Header <exception> synopsis [[exception.syn]](exception.syn)

#### 17.9.3 Class exception [[exception]](exception)

#### 17.9.4 Class bad_exception [[bad.exception]](bad.exception)

#### 17.9.5 Abnormal termination [[exception.terminate]](exception.terminate)

#### 17.9.5.1 Type terminate_handler [[terminate.handler]](terminate.handler)

#### 17.9.5.2 set_terminate [[set.terminate]](set.terminate)

#### 17.9.5.3 get_terminate [[get.terminate]](get.terminate)

#### 17.9.5.4 terminate [[terminate]](terminate)

#### 17.9.6 uncaught_exceptions [[uncaught.exceptions]](uncaught.exceptions)

#### 17.9.7 Exception propagation [[propagation]](propagation)

#### 17.9.8 nested_exception [[except.nested]](except.nested)

### 17.10 Contract-violation handling [[support.contract]](support.contract)

#### 17.10.1 Header <contracts> synopsis [[contracts.syn]](contracts.syn)

#### 17.10.2 Enumerations [[support.contract.enum]](support.contract.enum)

#### 17.10.3 Class contract_violation [[support.contract.violation]](support.contract.violation)

#### 17.10.4 Invoke default handler [[support.contract.invoke]](support.contract.invoke)

### 17.11 Initializer lists [[support.initlist]](support.initlist)

#### 17.11.1 General [[support.initlist.general]](support.initlist.general)

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

#### 17.11.3 Initializer list constructors [[support.initlist.cons]](support.initlist.cons)

#### 17.11.4 Initializer list access [[support.initlist.access]](support.initlist.access)

#### 17.11.5 Initializer list range access [[support.initlist.range]](support.initlist.range)

### 17.12 Comparisons [[cmp]](cmp)

#### 17.12.1 Header <compare> synopsis [[compare.syn]](compare.syn)

#### 17.12.2 Comparison category types [[cmp.categories]](cmp.categories)

#### 17.12.2.1 Preamble [[cmp.categories.pre]](cmp.categories.pre)

#### 17.12.2.2 Class partial_ordering [[cmp.partialord]](cmp.partialord)

#### 17.12.2.3 Class weak_ordering [[cmp.weakord]](cmp.weakord)

#### 17.12.2.4 Class strong_ordering [[cmp.strongord]](cmp.strongord)

#### 17.12.3 Class template common_comparison_category [[cmp.common]](cmp.common)

#### 17.12.4 Concept three_way_comparable [[cmp.concept]](cmp.concept)

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

#### 17.12.6 Comparison algorithms [[cmp.alg]](cmp.alg)

#### 17.12.7 Type Ordering [[compare.type]](compare.type)

### 17.13 Coroutines [[support.coroutine]](support.coroutine)

#### 17.13.1 General [[support.coroutine.general]](support.coroutine.general)

#### 17.13.2 Header <coroutine> synopsis [[coroutine.syn]](coroutine.syn)

#### 17.13.3 Coroutine traits [[coroutine.traits]](coroutine.traits)

#### 17.13.3.1 General [[coroutine.traits.general]](coroutine.traits.general)

#### 17.13.3.2 Class template coroutine_traits [[coroutine.traits.primary]](coroutine.traits.primary)

#### 17.13.4 Class template coroutine_handle [[coroutine.handle]](coroutine.handle)

#### 17.13.4.1 General [[coroutine.handle.general]](coroutine.handle.general)

#### 17.13.4.2 Construct/reset [[coroutine.handle.con]](coroutine.handle.con)

#### 17.13.4.3 Conversion [[coroutine.handle.conv]](coroutine.handle.conv)

#### 17.13.4.4 Export/import [[coroutine.handle.export.import]](coroutine.handle.export.import)

#### 17.13.4.5 Observers [[coroutine.handle.observers]](coroutine.handle.observers)

#### 17.13.4.6 Resumption [[coroutine.handle.resumption]](coroutine.handle.resumption)

#### 17.13.4.7 Promise access [[coroutine.handle.promise]](coroutine.handle.promise)

#### 17.13.4.8 Comparison operators [[coroutine.handle.compare]](coroutine.handle.compare)

#### 17.13.4.9 Hash support [[coroutine.handle.hash]](coroutine.handle.hash)

#### 17.13.5 No-op coroutines [[coroutine.noop]](coroutine.noop)

#### 17.13.5.1 Class noop_coroutine_promise [[coroutine.promise.noop]](coroutine.promise.noop)

#### 17.13.5.2 Class coroutine_handle<noop_coroutine_promise> [[coroutine.handle.noop]](coroutine.handle.noop)

#### 17.13.5.2.1 General [[coroutine.handle.noop.general]](coroutine.handle.noop.general)

#### 17.13.5.2.2 Conversion [[coroutine.handle.noop.conv]](coroutine.handle.noop.conv)

#### 17.13.5.2.3 Observers [[coroutine.handle.noop.observers]](coroutine.handle.noop.observers)

#### 17.13.5.2.4 Resumption [[coroutine.handle.noop.resumption]](coroutine.handle.noop.resumption)

#### 17.13.5.2.5 Promise access [[coroutine.handle.noop.promise]](coroutine.handle.noop.promise)

#### 17.13.5.2.6 Address [[coroutine.handle.noop.address]](coroutine.handle.noop.address)

#### 17.13.5.3 Function noop_coroutine [[coroutine.noop.coroutine]](coroutine.noop.coroutine)

#### 17.13.6 Trivial awaitables [[coroutine.trivial.awaitables]](coroutine.trivial.awaitables)

### 17.14 Other runtime support [[support.runtime]](support.runtime)

#### 17.14.1 General [[support.runtime.general]](support.runtime.general)

#### 17.14.2 Header <cstdarg> synopsis [[cstdarg.syn]](cstdarg.syn)

#### 17.14.3 Header <csetjmp> synopsis [[csetjmp.syn]](csetjmp.syn)

#### 17.14.4 Header <csignal> synopsis [[csignal.syn]](csignal.syn)

#### 17.14.5 Signal handlers [[support.signal]](support.signal)

### 17.15 C headers [[support.c.headers]](support.c.headers)

#### 17.15.1 General [[support.c.headers.general]](support.c.headers.general)

#### 17.15.2 Header <complex.h> synopsis [[complex.h.syn]](complex.h.syn)

#### 17.15.3 Header <iso646.h> synopsis [[iso646.h.syn]](iso646.h.syn)

#### 17.15.4 Header <stdalign.h> synopsis [[stdalign.h.syn]](stdalign.h.syn)

#### 17.15.5 Header <stdbool.h> synopsis [[stdbool.h.syn]](stdbool.h.syn)

#### 17.15.6 Header <tgmath.h> synopsis [[tgmath.h.syn]](tgmath.h.syn)

#### 17.15.7 Other C headers [[support.c.headers.other]](support.c.headers.other)

## 18 Concepts library [[concepts]](#concepts)[[concepts]](concepts)

### 18.1 General [[concepts.general]](concepts.general)

### 18.2 Equality preservation [[concepts.equality]](concepts.equality)

### 18.3 Header <concepts> synopsis [[concepts.syn]](concepts.syn)

### 18.4 Language-related concepts [[concepts.lang]](concepts.lang)

#### 18.4.1 General [[concepts.lang.general]](concepts.lang.general)

#### 18.4.2 Concept same_as [[concept.same]](concept.same)

#### 18.4.3 Concept derived_from [[concept.derived]](concept.derived)

#### 18.4.4 Concept convertible_to [[concept.convertible]](concept.convertible)

#### 18.4.5 Concept common_reference_with [[concept.commonref]](concept.commonref)

#### 18.4.6 Concept common_with [[concept.common]](concept.common)

#### 18.4.7 Arithmetic concepts [[concepts.arithmetic]](concepts.arithmetic)

#### 18.4.8 Concept assignable_from [[concept.assignable]](concept.assignable)

#### 18.4.9 Concept swappable [[concept.swappable]](concept.swappable)

#### 18.4.10 Concept destructible [[concept.destructible]](concept.destructible)

#### 18.4.11 Concept constructible_from [[concept.constructible]](concept.constructible)

#### 18.4.12 Concept default_initializable [[concept.default.init]](concept.default.init)

#### 18.4.13 Concept move_constructible [[concept.moveconstructible]](concept.moveconstructible)

#### 18.4.14 Concept copy_constructible [[concept.copyconstructible]](concept.copyconstructible)

### 18.5 Comparison concepts [[concepts.compare]](concepts.compare)

#### 18.5.1 General [[concepts.compare.general]](concepts.compare.general)

#### 18.5.2 Boolean testability [[concept.booleantestable]](concept.booleantestable)

#### 18.5.3 Comparison common types [[concept.comparisoncommontype]](concept.comparisoncommontype)

#### 18.5.4 Concept equality_comparable [[concept.equalitycomparable]](concept.equalitycomparable)

#### 18.5.5 Concept totally_ordered [[concept.totallyordered]](concept.totallyordered)

### 18.6 Object concepts [[concepts.object]](concepts.object)

### 18.7 Callable concepts [[concepts.callable]](concepts.callable)

#### 18.7.1 General [[concepts.callable.general]](concepts.callable.general)

#### 18.7.2 Concept invocable [[concept.invocable]](concept.invocable)

#### 18.7.3 Concept regular_invocable [[concept.regularinvocable]](concept.regularinvocable)

#### 18.7.4 Concept predicate [[concept.predicate]](concept.predicate)

#### 18.7.5 Concept relation [[concept.relation]](concept.relation)

#### 18.7.6 Concept equivalence_relation [[concept.equiv]](concept.equiv)

#### 18.7.7 Concept strict_weak_order [[concept.strictweakorder]](concept.strictweakorder)

## 19 Diagnostics library [[diagnostics]](#diagnostics)[[diagnostics]](diagnostics)

### 19.1 General [[diagnostics.general]](diagnostics.general)

### 19.2 Exception classes [[std.exceptions]](std.exceptions)

#### 19.2.1 General [[std.exceptions.general]](std.exceptions.general)

#### 19.2.2 Header <stdexcept> synopsis [[stdexcept.syn]](stdexcept.syn)

#### 19.2.3 Class logic_error [[logic.error]](logic.error)

#### 19.2.4 Class domain_error [[domain.error]](domain.error)

#### 19.2.5 Class invalid_argument [[invalid.argument]](invalid.argument)

#### 19.2.6 Class length_error [[length.error]](length.error)

#### 19.2.7 Class out_of_range [[out.of.range]](out.of.range)

#### 19.2.8 Class runtime_error [[runtime.error]](runtime.error)

#### 19.2.9 Class range_error [[range.error]](range.error)

#### 19.2.10 Class overflow_error [[overflow.error]](overflow.error)

#### 19.2.11 Class underflow_error [[underflow.error]](underflow.error)

### 19.3 Assertions [[assertions]](assertions)

#### 19.3.1 General [[assertions.general]](assertions.general)

#### 19.3.2 Header <cassert> synopsis [[cassert.syn]](cassert.syn)

#### 19.3.3 The assert macro [[assertions.assert]](assertions.assert)

### 19.4 Error numbers [[errno]](errno)

#### 19.4.1 General [[errno.general]](errno.general)

#### 19.4.2 Header <cerrno> synopsis [[cerrno.syn]](cerrno.syn)

### 19.5 System error support [[syserr]](syserr)

#### 19.5.1 General [[syserr.general]](syserr.general)

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

#### 19.5.3 Class error_category [[syserr.errcat]](syserr.errcat)

#### 19.5.3.1 Overview [[syserr.errcat.overview]](syserr.errcat.overview)

#### 19.5.3.2 Virtual members [[syserr.errcat.virtuals]](syserr.errcat.virtuals)

#### 19.5.3.3 Non-virtual members [[syserr.errcat.nonvirtuals]](syserr.errcat.nonvirtuals)

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

#### 19.5.3.5 Error category objects [[syserr.errcat.objects]](syserr.errcat.objects)

#### 19.5.4 Class error_code [[syserr.errcode]](syserr.errcode)

#### 19.5.4.1 Overview [[syserr.errcode.overview]](syserr.errcode.overview)

#### 19.5.4.2 Constructors [[syserr.errcode.constructors]](syserr.errcode.constructors)

#### 19.5.4.3 Modifiers [[syserr.errcode.modifiers]](syserr.errcode.modifiers)

#### 19.5.4.4 Observers [[syserr.errcode.observers]](syserr.errcode.observers)

#### 19.5.4.5 Non-member functions [[syserr.errcode.nonmembers]](syserr.errcode.nonmembers)

#### 19.5.5 Class error_condition [[syserr.errcondition]](syserr.errcondition)

#### 19.5.5.1 Overview [[syserr.errcondition.overview]](syserr.errcondition.overview)

#### 19.5.5.2 Constructors [[syserr.errcondition.constructors]](syserr.errcondition.constructors)

#### 19.5.5.3 Modifiers [[syserr.errcondition.modifiers]](syserr.errcondition.modifiers)

#### 19.5.5.4 Observers [[syserr.errcondition.observers]](syserr.errcondition.observers)

#### 19.5.5.5 Non-member functions [[syserr.errcondition.nonmembers]](syserr.errcondition.nonmembers)

#### 19.5.6 Comparison operator functions [[syserr.compare]](syserr.compare)

#### 19.5.7 System error hash support [[syserr.hash]](syserr.hash)

#### 19.5.8 Class system_error [[syserr.syserr]](syserr.syserr)

#### 19.5.8.1 Overview [[syserr.syserr.overview]](syserr.syserr.overview)

#### 19.5.8.2 Members [[syserr.syserr.members]](syserr.syserr.members)

### 19.6 Stacktrace [[stacktrace]](stacktrace)

#### 19.6.1 General [[stacktrace.general]](stacktrace.general)

#### 19.6.2 Header <stacktrace> synopsis [[stacktrace.syn]](stacktrace.syn)

#### 19.6.3 Class stacktrace_entry [[stacktrace.entry]](stacktrace.entry)

#### 19.6.3.1 Overview [[stacktrace.entry.overview]](stacktrace.entry.overview)

#### 19.6.3.2 Constructors [[stacktrace.entry.cons]](stacktrace.entry.cons)

#### 19.6.3.3 Observers [[stacktrace.entry.obs]](stacktrace.entry.obs)

#### 19.6.3.4 Query [[stacktrace.entry.query]](stacktrace.entry.query)

#### 19.6.3.5 Comparison [[stacktrace.entry.cmp]](stacktrace.entry.cmp)

#### 19.6.4 Class template basic_stacktrace [[stacktrace.basic]](stacktrace.basic)

#### 19.6.4.1 Overview [[stacktrace.basic.overview]](stacktrace.basic.overview)

#### 19.6.4.2 Creation and assignment [[stacktrace.basic.cons]](stacktrace.basic.cons)

#### 19.6.4.3 Observers [[stacktrace.basic.obs]](stacktrace.basic.obs)

#### 19.6.4.4 Comparisons [[stacktrace.basic.cmp]](stacktrace.basic.cmp)

#### 19.6.4.5 Modifiers [[stacktrace.basic.mod]](stacktrace.basic.mod)

#### 19.6.4.6 Non-member functions [[stacktrace.basic.nonmem]](stacktrace.basic.nonmem)

#### 19.6.5 Formatting support [[stacktrace.format]](stacktrace.format)

#### 19.6.6 Hash support [[stacktrace.basic.hash]](stacktrace.basic.hash)

### 19.7 Debugging [[debugging]](debugging)

#### 19.7.1 General [[debugging.general]](debugging.general)

#### 19.7.2 Header <debugging> synopsis [[debugging.syn]](debugging.syn)

#### 19.7.3 Utility [[debugging.utility]](debugging.utility)

## 20 Memory management library [[mem]](#mem)[[mem]](mem)

### 20.1 General [[mem.general]](mem.general)

### 20.2 Memory [[memory]](memory)

#### 20.2.1 General [[memory.general]](memory.general)

#### 20.2.2 Header <memory> synopsis [[memory.syn]](memory.syn)

#### 20.2.3 Pointer traits [[pointer.traits]](pointer.traits)

#### 20.2.3.1 General [[pointer.traits.general]](pointer.traits.general)

#### 20.2.3.2 Member types [[pointer.traits.types]](pointer.traits.types)

#### 20.2.3.3 Member functions [[pointer.traits.functions]](pointer.traits.functions)

#### 20.2.3.4 Optional members [[pointer.traits.optmem]](pointer.traits.optmem)

#### 20.2.4 Pointer conversion [[pointer.conversion]](pointer.conversion)

#### 20.2.5 Pointer alignment [[ptr.align]](ptr.align)

#### 20.2.6 Explicit lifetime management [[obj.lifetime]](obj.lifetime)

#### 20.2.7 Allocator argument tag [[allocator.tag]](allocator.tag)

#### 20.2.8 uses_allocator [[allocator.uses]](allocator.uses)

#### 20.2.8.1 uses_allocator trait [[allocator.uses.trait]](allocator.uses.trait)

#### 20.2.8.2 Uses-allocator construction [[allocator.uses.construction]](allocator.uses.construction)

#### 20.2.9 Allocator traits [[allocator.traits]](allocator.traits)

#### 20.2.9.1 General [[allocator.traits.general]](allocator.traits.general)

#### 20.2.9.2 Member types [[allocator.traits.types]](allocator.traits.types)

#### 20.2.9.3 Static member functions [[allocator.traits.members]](allocator.traits.members)

#### 20.2.9.4 Other [[allocator.traits.other]](allocator.traits.other)

#### 20.2.10 The default allocator [[default.allocator]](default.allocator)

#### 20.2.10.1 General [[default.allocator.general]](default.allocator.general)

#### 20.2.10.2 Members [[allocator.members]](allocator.members)

#### 20.2.10.3 Operators [[allocator.globals]](allocator.globals)

#### 20.2.11 addressof [[specialized.addressof]](specialized.addressof)

#### 20.2.12 C library memory allocation [[c.malloc]](c.malloc)

### 20.3 Smart pointers [[smartptr]](smartptr)

#### 20.3.1 Unique-ownership pointers [[unique.ptr]](unique.ptr)

#### 20.3.1.1 General [[unique.ptr.general]](unique.ptr.general)

#### 20.3.1.2 Default deleters [[unique.ptr.dltr]](unique.ptr.dltr)

#### 20.3.1.2.1 General [[unique.ptr.dltr.general]](unique.ptr.dltr.general)

#### 20.3.1.2.2 default_delete [[unique.ptr.dltr.dflt]](unique.ptr.dltr.dflt)

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

#### 20.3.1.3 unique_ptr for single objects [[unique.ptr.single]](unique.ptr.single)

#### 20.3.1.3.1 General [[unique.ptr.single.general]](unique.ptr.single.general)

#### 20.3.1.3.2 Constructors [[unique.ptr.single.ctor]](unique.ptr.single.ctor)

#### 20.3.1.3.3 Destructor [[unique.ptr.single.dtor]](unique.ptr.single.dtor)

#### 20.3.1.3.4 Assignment [[unique.ptr.single.asgn]](unique.ptr.single.asgn)

#### 20.3.1.3.5 Observers [[unique.ptr.single.observers]](unique.ptr.single.observers)

#### 20.3.1.3.6 Modifiers [[unique.ptr.single.modifiers]](unique.ptr.single.modifiers)

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

#### 20.3.1.4.1 General [[unique.ptr.runtime.general]](unique.ptr.runtime.general)

#### 20.3.1.4.2 Constructors [[unique.ptr.runtime.ctor]](unique.ptr.runtime.ctor)

#### 20.3.1.4.3 Assignment [[unique.ptr.runtime.asgn]](unique.ptr.runtime.asgn)

#### 20.3.1.4.4 Observers [[unique.ptr.runtime.observers]](unique.ptr.runtime.observers)

#### 20.3.1.4.5 Modifiers [[unique.ptr.runtime.modifiers]](unique.ptr.runtime.modifiers)

#### 20.3.1.5 Creation [[unique.ptr.create]](unique.ptr.create)

#### 20.3.1.6 Specialized algorithms [[unique.ptr.special]](unique.ptr.special)

#### 20.3.1.7 I/O [[unique.ptr.io]](unique.ptr.io)

#### 20.3.2 Shared-ownership pointers [[util.sharedptr]](util.sharedptr)

#### 20.3.2.1 Class bad_weak_ptr [[util.smartptr.weak.bad]](util.smartptr.weak.bad)

#### 20.3.2.2 Class template shared_ptr [[util.smartptr.shared]](util.smartptr.shared)

#### 20.3.2.2.1 General [[util.smartptr.shared.general]](util.smartptr.shared.general)

#### 20.3.2.2.2 Constructors [[util.smartptr.shared.const]](util.smartptr.shared.const)

#### 20.3.2.2.3 Destructor [[util.smartptr.shared.dest]](util.smartptr.shared.dest)

#### 20.3.2.2.4 Assignment [[util.smartptr.shared.assign]](util.smartptr.shared.assign)

#### 20.3.2.2.5 Modifiers [[util.smartptr.shared.mod]](util.smartptr.shared.mod)

#### 20.3.2.2.6 Observers [[util.smartptr.shared.obs]](util.smartptr.shared.obs)

#### 20.3.2.2.7 Creation [[util.smartptr.shared.create]](util.smartptr.shared.create)

#### 20.3.2.2.8 Comparison [[util.smartptr.shared.cmp]](util.smartptr.shared.cmp)

#### 20.3.2.2.9 Specialized algorithms [[util.smartptr.shared.spec]](util.smartptr.shared.spec)

#### 20.3.2.2.10 Casts [[util.smartptr.shared.cast]](util.smartptr.shared.cast)

#### 20.3.2.2.11 get_deleter [[util.smartptr.getdeleter]](util.smartptr.getdeleter)

#### 20.3.2.2.12 I/O [[util.smartptr.shared.io]](util.smartptr.shared.io)

#### 20.3.2.3 Class template weak_ptr [[util.smartptr.weak]](util.smartptr.weak)

#### 20.3.2.3.1 General [[util.smartptr.weak.general]](util.smartptr.weak.general)

#### 20.3.2.3.2 Constructors [[util.smartptr.weak.const]](util.smartptr.weak.const)

#### 20.3.2.3.3 Destructor [[util.smartptr.weak.dest]](util.smartptr.weak.dest)

#### 20.3.2.3.4 Assignment [[util.smartptr.weak.assign]](util.smartptr.weak.assign)

#### 20.3.2.3.5 Modifiers [[util.smartptr.weak.mod]](util.smartptr.weak.mod)

#### 20.3.2.3.6 Observers [[util.smartptr.weak.obs]](util.smartptr.weak.obs)

#### 20.3.2.3.7 Specialized algorithms [[util.smartptr.weak.spec]](util.smartptr.weak.spec)

#### 20.3.2.4 Class template owner_less [[util.smartptr.ownerless]](util.smartptr.ownerless)

#### 20.3.2.5 Struct owner_hash [[util.smartptr.owner.hash]](util.smartptr.owner.hash)

#### 20.3.2.6 Struct owner_equal [[util.smartptr.owner.equal]](util.smartptr.owner.equal)

#### 20.3.2.7 Class template enable_shared_from_this [[util.smartptr.enab]](util.smartptr.enab)

#### 20.3.3 Smart pointer hash support [[util.smartptr.hash]](util.smartptr.hash)

#### 20.3.4 Smart pointer adaptors [[smartptr.adapt]](smartptr.adapt)

#### 20.3.4.1 Class template out_ptr_t [[out.ptr.t]](out.ptr.t)

#### 20.3.4.2 Function template out_ptr [[out.ptr]](out.ptr)

#### 20.3.4.3 Class template inout_ptr_t [[inout.ptr.t]](inout.ptr.t)

#### 20.3.4.4 Function template inout_ptr [[inout.ptr]](inout.ptr)

### 20.4 Types for composite class design [[mem.composite.types]](mem.composite.types)

#### 20.4.1 Class template indirect [[indirect]](indirect)

#### 20.4.1.1 General [[indirect.general]](indirect.general)

#### 20.4.1.2 Synopsis [[indirect.syn]](indirect.syn)

#### 20.4.1.3 Constructors [[indirect.ctor]](indirect.ctor)

#### 20.4.1.4 Destructor [[indirect.dtor]](indirect.dtor)

#### 20.4.1.5 Assignment [[indirect.assign]](indirect.assign)

#### 20.4.1.6 Observers [[indirect.obs]](indirect.obs)

#### 20.4.1.7 Swap [[indirect.swap]](indirect.swap)

#### 20.4.1.8 Relational operators [[indirect.relops]](indirect.relops)

#### 20.4.1.9 Comparison with T [[indirect.comp.with.t]](indirect.comp.with.t)

#### 20.4.1.10 Hash support [[indirect.hash]](indirect.hash)

#### 20.4.2 Class template polymorphic [[polymorphic]](polymorphic)

#### 20.4.2.1 General [[polymorphic.general]](polymorphic.general)

#### 20.4.2.2 Synopsis [[polymorphic.syn]](polymorphic.syn)

#### 20.4.2.3 Constructors [[polymorphic.ctor]](polymorphic.ctor)

#### 20.4.2.4 Destructor [[polymorphic.dtor]](polymorphic.dtor)

#### 20.4.2.5 Assignment [[polymorphic.assign]](polymorphic.assign)

#### 20.4.2.6 Observers [[polymorphic.obs]](polymorphic.obs)

#### 20.4.2.7 Swap [[polymorphic.swap]](polymorphic.swap)

### 20.5 Memory resources [[mem.res]](mem.res)

#### 20.5.1 Header <memory_resource> synopsis [[mem.res.syn]](mem.res.syn)

#### 20.5.2 Class memory_resource [[mem.res.class]](mem.res.class)

#### 20.5.2.1 General [[mem.res.class.general]](mem.res.class.general)

#### 20.5.2.2 Public member functions [[mem.res.public]](mem.res.public)

#### 20.5.2.3 Private virtual member functions [[mem.res.private]](mem.res.private)

#### 20.5.2.4 Equality [[mem.res.eq]](mem.res.eq)

#### 20.5.3 Class template polymorphic_allocator [[mem.poly.allocator.class]](mem.poly.allocator.class)

#### 20.5.3.1 General [[mem.poly.allocator.class.general]](mem.poly.allocator.class.general)

#### 20.5.3.2 Constructors [[mem.poly.allocator.ctor]](mem.poly.allocator.ctor)

#### 20.5.3.3 Member functions [[mem.poly.allocator.mem]](mem.poly.allocator.mem)

#### 20.5.3.4 Equality [[mem.poly.allocator.eq]](mem.poly.allocator.eq)

#### 20.5.4 Access to program-wide memory_resource objects [[mem.res.global]](mem.res.global)

#### 20.5.5 Pool resource classes [[mem.res.pool]](mem.res.pool)

#### 20.5.5.1 Classes synchronized_pool_resource and unsynchronized_pool_resource [[mem.res.pool.overview]](mem.res.pool.overview)

#### 20.5.5.2 pool_options data members [[mem.res.pool.options]](mem.res.pool.options)

#### 20.5.5.3 Constructors and destructors [[mem.res.pool.ctor]](mem.res.pool.ctor)

#### 20.5.5.4 Members [[mem.res.pool.mem]](mem.res.pool.mem)

#### 20.5.6 Class monotonic_buffer_resource [[mem.res.monotonic.buffer]](mem.res.monotonic.buffer)

#### 20.5.6.1 General [[mem.res.monotonic.buffer.general]](mem.res.monotonic.buffer.general)

#### 20.5.6.2 Constructors and destructor [[mem.res.monotonic.buffer.ctor]](mem.res.monotonic.buffer.ctor)

#### 20.5.6.3 Members [[mem.res.monotonic.buffer.mem]](mem.res.monotonic.buffer.mem)

### 20.6 Class template scoped_allocator_adaptor [[allocator.adaptor]](allocator.adaptor)

#### 20.6.1 Header <scoped_allocator> synopsis [[allocator.adaptor.syn]](allocator.adaptor.syn)

#### 20.6.2 Member types [[allocator.adaptor.types]](allocator.adaptor.types)

#### 20.6.3 Constructors [[allocator.adaptor.cnstr]](allocator.adaptor.cnstr)

#### 20.6.4 Members [[allocator.adaptor.members]](allocator.adaptor.members)

#### 20.6.5 Operators [[scoped.adaptor.operators]](scoped.adaptor.operators)

## 21 Metaprogramming library [[meta]](#meta)[[meta]](meta)

### 21.1 General [[meta.general]](meta.general)

### 21.2 Compile-time integer sequences [[intseq]](intseq)

#### 21.2.1 General [[intseq.general]](intseq.general)

#### 21.2.2 Class template integer_sequence [[intseq.intseq]](intseq.intseq)

#### 21.2.3 Alias template make_integer_sequence [[intseq.make]](intseq.make)

### 21.3 Metaprogramming and type traits [[type.traits]](type.traits)

#### 21.3.1 General [[type.traits.general]](type.traits.general)

#### 21.3.2 Requirements [[meta.rqmts]](meta.rqmts)

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

#### 21.3.4 Helper classes [[meta.help]](meta.help)

#### 21.3.5 Class template constant_wrapper [[const.wrap.class]](const.wrap.class)

#### 21.3.6 Unary type traits [[meta.unary]](meta.unary)

#### 21.3.6.1 General [[meta.unary.general]](meta.unary.general)

#### 21.3.6.2 Primary type categories [[meta.unary.cat]](meta.unary.cat)

#### 21.3.6.3 Composite type traits [[meta.unary.comp]](meta.unary.comp)

#### 21.3.6.4 Type properties [[meta.unary.prop]](meta.unary.prop)

#### 21.3.7 Type property queries [[meta.unary.prop.query]](meta.unary.prop.query)

#### 21.3.8 Relationships between types [[meta.rel]](meta.rel)

#### 21.3.9 Transformations between types [[meta.trans]](meta.trans)

#### 21.3.9.1 General [[meta.trans.general]](meta.trans.general)

#### 21.3.9.2 Const-volatile modifications [[meta.trans.cv]](meta.trans.cv)

#### 21.3.9.3 Reference modifications [[meta.trans.ref]](meta.trans.ref)

#### 21.3.9.4 Sign modifications [[meta.trans.sign]](meta.trans.sign)

#### 21.3.9.5 Array modifications [[meta.trans.arr]](meta.trans.arr)

#### 21.3.9.6 Pointer modifications [[meta.trans.ptr]](meta.trans.ptr)

#### 21.3.9.7 Other transformations [[meta.trans.other]](meta.trans.other)

#### 21.3.10 Logical operator traits [[meta.logical]](meta.logical)

#### 21.3.11 Member relationships [[meta.member]](meta.member)

#### 21.3.12 Constant evaluation context [[meta.const.eval]](meta.const.eval)

### 21.4 Reflection [[meta.reflection]](meta.reflection)

#### 21.4.1 Header <meta> synopsis [[meta.syn]](meta.syn)

#### 21.4.2 Checking string literals [[meta.string.literal]](meta.string.literal)

#### 21.4.3 Promoting to static storage strings [[meta.define.static]](meta.define.static)

#### 21.4.4 Class exception [[meta.reflection.exception]](meta.reflection.exception)

#### 21.4.5 Operator representations [[meta.reflection.operators]](meta.reflection.operators)

#### 21.4.6 Reflection names and locations [[meta.reflection.names]](meta.reflection.names)

#### 21.4.7 Reflection queries [[meta.reflection.queries]](meta.reflection.queries)

#### 21.4.8 Access control context [[meta.reflection.access.context]](meta.reflection.access.context)

#### 21.4.9 Member accessibility queries [[meta.reflection.access.queries]](meta.reflection.access.queries)

#### 21.4.10 Reflection member queries [[meta.reflection.member.queries]](meta.reflection.member.queries)

#### 21.4.11 Reflection layout queries [[meta.reflection.layout]](meta.reflection.layout)

#### 21.4.12 Value extraction [[meta.reflection.extract]](meta.reflection.extract)

#### 21.4.13 Reflection substitution [[meta.reflection.substitute]](meta.reflection.substitute)

#### 21.4.14 Expression result reflection [[meta.reflection.result]](meta.reflection.result)

#### 21.4.15 Promoting to static storage arrays [[meta.reflection.array]](meta.reflection.array)

#### 21.4.16 Reflection class definition generation [[meta.reflection.define.aggregate]](meta.reflection.define.aggregate)

#### 21.4.17 Reflection type traits [[meta.reflection.traits]](meta.reflection.traits)

#### 21.4.18 Annotation reflection [[meta.reflection.annotation]](meta.reflection.annotation)

### 21.5 Compile-time rational arithmetic [[ratio]](ratio)

#### 21.5.1 General [[ratio.general]](ratio.general)

#### 21.5.2 Header <ratio> synopsis [[ratio.syn]](ratio.syn)

#### 21.5.3 Class template ratio [[ratio.ratio]](ratio.ratio)

#### 21.5.4 Arithmetic on ratios [[ratio.arithmetic]](ratio.arithmetic)

#### 21.5.5 Comparison of ratios [[ratio.comparison]](ratio.comparison)

#### 21.5.6 SI types for ratio [[ratio.si]](ratio.si)

## 22 General utilities library [[utilities]](#utilities)[[utilities]](utilities)

### 22.1 General [[utilities.general]](utilities.general)

### 22.2 Utility components [[utility]](utility)

#### 22.2.1 Header <utility> synopsis [[utility.syn]](utility.syn)

#### 22.2.2 swap [[utility.swap]](utility.swap)

#### 22.2.3 exchange [[utility.exchange]](utility.exchange)

#### 22.2.4 Forward/move helpers [[forward]](forward)

#### 22.2.5 Function template as_const [[utility.as.const]](utility.as.const)

#### 22.2.6 Function template declval [[declval]](declval)

#### 22.2.7 Integer comparison functions [[utility.intcmp]](utility.intcmp)

#### 22.2.8 Function template to_underlying [[utility.underlying]](utility.underlying)

#### 22.2.9 Undefined behavior [[utility.undefined]](utility.undefined)

### 22.3 Pairs [[pairs]](pairs)

#### 22.3.1 General [[pairs.general]](pairs.general)

#### 22.3.2 Class template pair [[pairs.pair]](pairs.pair)

#### 22.3.3 Specialized algorithms [[pairs.spec]](pairs.spec)

#### 22.3.4 Tuple-like access to pair [[pair.astuple]](pair.astuple)

#### 22.3.5 Piecewise construction [[pair.piecewise]](pair.piecewise)

### 22.4 Tuples [[tuple]](tuple)

#### 22.4.1 General [[tuple.general]](tuple.general)

#### 22.4.2 Header <tuple> synopsis [[tuple.syn]](tuple.syn)

#### 22.4.3 Concept *tuple-like* [[tuple.like]](tuple.like)

#### 22.4.4 Class template tuple [[tuple.tuple]](tuple.tuple)

#### 22.4.4.1 General [[tuple.tuple.general]](tuple.tuple.general)

#### 22.4.4.2 Construction [[tuple.cnstr]](tuple.cnstr)

#### 22.4.4.3 Assignment [[tuple.assign]](tuple.assign)

#### 22.4.4.4 swap [[tuple.swap]](tuple.swap)

#### 22.4.5 Tuple creation functions [[tuple.creation]](tuple.creation)

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

#### 22.4.7 Tuple helper classes [[tuple.helper]](tuple.helper)

#### 22.4.8 Element access [[tuple.elem]](tuple.elem)

#### 22.4.9 Relational operators [[tuple.rel]](tuple.rel)

#### 22.4.10 common_reference related specializations [[tuple.common.ref]](tuple.common.ref)

#### 22.4.11 Tuple traits [[tuple.traits]](tuple.traits)

#### 22.4.12 Tuple specialized algorithms [[tuple.special]](tuple.special)

### 22.5 Optional objects [[optional]](optional)

#### 22.5.1 General [[optional.general]](optional.general)

#### 22.5.2 Header <optional> synopsis [[optional.syn]](optional.syn)

#### 22.5.3 Class template optional [[optional.optional]](optional.optional)

#### 22.5.3.1 General [[optional.optional.general]](optional.optional.general)

#### 22.5.3.2 Constructors [[optional.ctor]](optional.ctor)

#### 22.5.3.3 Destructor [[optional.dtor]](optional.dtor)

#### 22.5.3.4 Assignment [[optional.assign]](optional.assign)

#### 22.5.3.5 Swap [[optional.swap]](optional.swap)

#### 22.5.3.6 Iterator support [[optional.iterators]](optional.iterators)

#### 22.5.3.7 Observers [[optional.observe]](optional.observe)

#### 22.5.3.8 Monadic operations [[optional.monadic]](optional.monadic)

#### 22.5.3.9 Modifiers [[optional.mod]](optional.mod)

#### 22.5.4 Partial specialization of optional for reference types [[optional.optional.ref]](optional.optional.ref)

#### 22.5.4.1 General [[optional.optional.ref.general]](optional.optional.ref.general)

#### 22.5.4.2 Constructors [[optional.ref.ctor]](optional.ref.ctor)

#### 22.5.4.3 Assignment [[optional.ref.assign]](optional.ref.assign)

#### 22.5.4.4 Swap [[optional.ref.swap]](optional.ref.swap)

#### 22.5.4.5 Iterator support [[optional.ref.iterators]](optional.ref.iterators)

#### 22.5.4.6 Observers [[optional.ref.observe]](optional.ref.observe)

#### 22.5.4.7 Monadic operations [[optional.ref.monadic]](optional.ref.monadic)

#### 22.5.4.8 Modifiers [[optional.ref.mod]](optional.ref.mod)

#### 22.5.4.9 Exposition only helper functions [[optional.ref.expos]](optional.ref.expos)

#### 22.5.5 No-value state indicator [[optional.nullopt]](optional.nullopt)

#### 22.5.6 Class bad_optional_access [[optional.bad.access]](optional.bad.access)

#### 22.5.7 Relational operators [[optional.relops]](optional.relops)

#### 22.5.8 Comparison with nullopt [[optional.nullops]](optional.nullops)

#### 22.5.9 Comparison with T [[optional.comp.with.t]](optional.comp.with.t)

#### 22.5.10 Specialized algorithms [[optional.specalg]](optional.specalg)

#### 22.5.11 Hash support [[optional.hash]](optional.hash)

### 22.6 Variants [[variant]](variant)

#### 22.6.1 General [[variant.general]](variant.general)

#### 22.6.2 Header <variant> synopsis [[variant.syn]](variant.syn)

#### 22.6.3 Class template variant [[variant.variant]](variant.variant)

#### 22.6.3.1 General [[variant.variant.general]](variant.variant.general)

#### 22.6.3.2 Constructors [[variant.ctor]](variant.ctor)

#### 22.6.3.3 Destructor [[variant.dtor]](variant.dtor)

#### 22.6.3.4 Assignment [[variant.assign]](variant.assign)

#### 22.6.3.5 Modifiers [[variant.mod]](variant.mod)

#### 22.6.3.6 Value status [[variant.status]](variant.status)

#### 22.6.3.7 Swap [[variant.swap]](variant.swap)

#### 22.6.4 variant helper classes [[variant.helper]](variant.helper)

#### 22.6.5 Value access [[variant.get]](variant.get)

#### 22.6.6 Relational operators [[variant.relops]](variant.relops)

#### 22.6.7 Visitation [[variant.visit]](variant.visit)

#### 22.6.8 Class monostate [[variant.monostate]](variant.monostate)

#### 22.6.9 monostate relational operators [[variant.monostate.relops]](variant.monostate.relops)

#### 22.6.10 Specialized algorithms [[variant.specalg]](variant.specalg)

#### 22.6.11 Class bad_variant_access [[variant.bad.access]](variant.bad.access)

#### 22.6.12 Hash support [[variant.hash]](variant.hash)

### 22.7 Storage for any type [[any]](any)

#### 22.7.1 General [[any.general]](any.general)

#### 22.7.2 Header <any> synopsis [[any.synop]](any.synop)

#### 22.7.3 Class bad_any_cast [[any.bad.any.cast]](any.bad.any.cast)

#### 22.7.4 Class any [[any.class]](any.class)

#### 22.7.4.1 General [[any.class.general]](any.class.general)

#### 22.7.4.2 Construction and destruction [[any.cons]](any.cons)

#### 22.7.4.3 Assignment [[any.assign]](any.assign)

#### 22.7.4.4 Modifiers [[any.modifiers]](any.modifiers)

#### 22.7.4.5 Observers [[any.observers]](any.observers)

#### 22.7.5 Non-member functions [[any.nonmembers]](any.nonmembers)

### 22.8 Expected objects [[expected]](expected)

#### 22.8.1 General [[expected.general]](expected.general)

#### 22.8.2 Header <expected> synopsis [[expected.syn]](expected.syn)

#### 22.8.3 Class template unexpected [[expected.unexpected]](expected.unexpected)

#### 22.8.3.1 General [[expected.un.general]](expected.un.general)

#### 22.8.3.2 Constructors [[expected.un.cons]](expected.un.cons)

#### 22.8.3.3 Observers [[expected.un.obs]](expected.un.obs)

#### 22.8.3.4 Swap [[expected.un.swap]](expected.un.swap)

#### 22.8.3.5 Equality operator [[expected.un.eq]](expected.un.eq)

#### 22.8.4 Class template bad_expected_access [[expected.bad]](expected.bad)

#### 22.8.5 Class template specialization bad_expected_access<void> [[expected.bad.void]](expected.bad.void)

#### 22.8.6 Class template expected [[expected.expected]](expected.expected)

#### 22.8.6.1 General [[expected.object.general]](expected.object.general)

#### 22.8.6.2 Constructors [[expected.object.cons]](expected.object.cons)

#### 22.8.6.3 Destructor [[expected.object.dtor]](expected.object.dtor)

#### 22.8.6.4 Assignment [[expected.object.assign]](expected.object.assign)

#### 22.8.6.5 Swap [[expected.object.swap]](expected.object.swap)

#### 22.8.6.6 Observers [[expected.object.obs]](expected.object.obs)

#### 22.8.6.7 Monadic operations [[expected.object.monadic]](expected.object.monadic)

#### 22.8.6.8 Equality operators [[expected.object.eq]](expected.object.eq)

#### 22.8.7 Partial specialization of expected for void types [[expected.void]](expected.void)

#### 22.8.7.1 General [[expected.void.general]](expected.void.general)

#### 22.8.7.2 Constructors [[expected.void.cons]](expected.void.cons)

#### 22.8.7.3 Destructor [[expected.void.dtor]](expected.void.dtor)

#### 22.8.7.4 Assignment [[expected.void.assign]](expected.void.assign)

#### 22.8.7.5 Swap [[expected.void.swap]](expected.void.swap)

#### 22.8.7.6 Observers [[expected.void.obs]](expected.void.obs)

#### 22.8.7.7 Monadic operations [[expected.void.monadic]](expected.void.monadic)

#### 22.8.7.8 Equality operators [[expected.void.eq]](expected.void.eq)

### 22.9 Bitsets [[bitset]](bitset)

#### 22.9.1 Header <bitset> synopsis [[bitset.syn]](bitset.syn)

#### 22.9.2 Class template bitset [[template.bitset]](template.bitset)

#### 22.9.2.1 General [[template.bitset.general]](template.bitset.general)

#### 22.9.2.2 Constructors [[bitset.cons]](bitset.cons)

#### 22.9.2.3 Members [[bitset.members]](bitset.members)

#### 22.9.3 bitset hash support [[bitset.hash]](bitset.hash)

#### 22.9.4 bitset operators [[bitset.operators]](bitset.operators)

### 22.10 Function objects [[function.objects]](function.objects)

#### 22.10.1 General [[function.objects.general]](function.objects.general)

#### 22.10.2 Header <functional> synopsis [[functional.syn]](functional.syn)

#### 22.10.3 Definitions [[func.def]](func.def)

#### 22.10.4 Requirements [[func.require]](func.require)

#### 22.10.5 invoke functions [[func.invoke]](func.invoke)

#### 22.10.6 Class template reference_wrapper [[refwrap]](refwrap)

#### 22.10.6.1 General [[refwrap.general]](refwrap.general)

#### 22.10.6.2 Constructors [[refwrap.const]](refwrap.const)

#### 22.10.6.3 Assignment [[refwrap.assign]](refwrap.assign)

#### 22.10.6.4 Access [[refwrap.access]](refwrap.access)

#### 22.10.6.5 Invocation [[refwrap.invoke]](refwrap.invoke)

#### 22.10.6.6 Comparisons [[refwrap.comparisons]](refwrap.comparisons)

#### 22.10.6.7 Helper functions [[refwrap.helpers]](refwrap.helpers)

#### 22.10.6.8 common_reference related specializations [[refwrap.common.ref]](refwrap.common.ref)

#### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations)

#### 22.10.7.1 General [[arithmetic.operations.general]](arithmetic.operations.general)

#### 22.10.7.2 Class template plus [[arithmetic.operations.plus]](arithmetic.operations.plus)

#### 22.10.7.3 Class template minus [[arithmetic.operations.minus]](arithmetic.operations.minus)

#### 22.10.7.4 Class template multiplies [[arithmetic.operations.multiplies]](arithmetic.operations.multiplies)

#### 22.10.7.5 Class template divides [[arithmetic.operations.divides]](arithmetic.operations.divides)

#### 22.10.7.6 Class template modulus [[arithmetic.operations.modulus]](arithmetic.operations.modulus)

#### 22.10.7.7 Class template negate [[arithmetic.operations.negate]](arithmetic.operations.negate)

#### 22.10.8 Comparisons [[comparisons]](comparisons)

#### 22.10.8.1 General [[comparisons.general]](comparisons.general)

#### 22.10.8.2 Class template equal_to [[comparisons.equal.to]](comparisons.equal.to)

#### 22.10.8.3 Class template not_equal_to [[comparisons.not.equal.to]](comparisons.not.equal.to)

#### 22.10.8.4 Class template greater [[comparisons.greater]](comparisons.greater)

#### 22.10.8.5 Class template less [[comparisons.less]](comparisons.less)

#### 22.10.8.6 Class template greater_equal [[comparisons.greater.equal]](comparisons.greater.equal)

#### 22.10.8.7 Class template less_equal [[comparisons.less.equal]](comparisons.less.equal)

#### 22.10.8.8 Class compare_three_way [[comparisons.three.way]](comparisons.three.way)

#### 22.10.9 Concept-constrained comparisons [[range.cmp]](range.cmp)

#### 22.10.10 Logical operations [[logical.operations]](logical.operations)

#### 22.10.10.1 General [[logical.operations.general]](logical.operations.general)

#### 22.10.10.2 Class template logical_and [[logical.operations.and]](logical.operations.and)

#### 22.10.10.3 Class template logical_or [[logical.operations.or]](logical.operations.or)

#### 22.10.10.4 Class template logical_not [[logical.operations.not]](logical.operations.not)

#### 22.10.11 Bitwise operations [[bitwise.operations]](bitwise.operations)

#### 22.10.11.1 General [[bitwise.operations.general]](bitwise.operations.general)

#### 22.10.11.2 Class template bit_and [[bitwise.operations.and]](bitwise.operations.and)

#### 22.10.11.3 Class template bit_or [[bitwise.operations.or]](bitwise.operations.or)

#### 22.10.11.4 Class template bit_xor [[bitwise.operations.xor]](bitwise.operations.xor)

#### 22.10.11.5 Class template bit_not [[bitwise.operations.not]](bitwise.operations.not)

#### 22.10.12 Class identity [[func.identity]](func.identity)

#### 22.10.13 Function template not_fn [[func.not.fn]](func.not.fn)

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

#### 22.10.15 Function object binders [[func.bind]](func.bind)

#### 22.10.15.1 General [[func.bind.general]](func.bind.general)

#### 22.10.15.2 Class template is_bind_expression [[func.bind.isbind]](func.bind.isbind)

#### 22.10.15.3 Class template is_placeholder [[func.bind.isplace]](func.bind.isplace)

#### 22.10.15.4 Function template bind [[func.bind.bind]](func.bind.bind)

#### 22.10.15.5 Placeholders [[func.bind.place]](func.bind.place)

#### 22.10.16 Function template mem_fn [[func.memfn]](func.memfn)

#### 22.10.17 Polymorphic function wrappers [[func.wrap]](func.wrap)

#### 22.10.17.1 General [[func.wrap.general]](func.wrap.general)

#### 22.10.17.2 Class bad_function_call [[func.wrap.badcall]](func.wrap.badcall)

#### 22.10.17.3 Class template function [[func.wrap.func]](func.wrap.func)

#### 22.10.17.3.1 General [[func.wrap.func.general]](func.wrap.func.general)

#### 22.10.17.3.2 Constructors and destructor [[func.wrap.func.con]](func.wrap.func.con)

#### 22.10.17.3.3 Modifiers [[func.wrap.func.mod]](func.wrap.func.mod)

#### 22.10.17.3.4 Capacity [[func.wrap.func.cap]](func.wrap.func.cap)

#### 22.10.17.3.5 Invocation [[func.wrap.func.inv]](func.wrap.func.inv)

#### 22.10.17.3.6 Target access [[func.wrap.func.targ]](func.wrap.func.targ)

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

#### 22.10.17.3.8 Specialized algorithms [[func.wrap.func.alg]](func.wrap.func.alg)

#### 22.10.17.4 Move-only wrapper [[func.wrap.move]](func.wrap.move)

#### 22.10.17.4.1 General [[func.wrap.move.general]](func.wrap.move.general)

#### 22.10.17.4.2 Class template move_only_function [[func.wrap.move.class]](func.wrap.move.class)

#### 22.10.17.4.3 Constructors, assignments, and destructor [[func.wrap.move.ctor]](func.wrap.move.ctor)

#### 22.10.17.4.4 Invocation [[func.wrap.move.inv]](func.wrap.move.inv)

#### 22.10.17.4.5 Utility [[func.wrap.move.util]](func.wrap.move.util)

#### 22.10.17.5 Copyable wrapper [[func.wrap.copy]](func.wrap.copy)

#### 22.10.17.5.1 General [[func.wrap.copy.general]](func.wrap.copy.general)

#### 22.10.17.5.2 Class template copyable_function [[func.wrap.copy.class]](func.wrap.copy.class)

#### 22.10.17.5.3 Constructors, assignments, and destructor [[func.wrap.copy.ctor]](func.wrap.copy.ctor)

#### 22.10.17.5.4 Invocation [[func.wrap.copy.inv]](func.wrap.copy.inv)

#### 22.10.17.5.5 Utility [[func.wrap.copy.util]](func.wrap.copy.util)

#### 22.10.17.6 Non-owning wrapper [[func.wrap.ref]](func.wrap.ref)

#### 22.10.17.6.1 General [[func.wrap.ref.general]](func.wrap.ref.general)

#### 22.10.17.6.2 Class template function_ref [[func.wrap.ref.class]](func.wrap.ref.class)

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

#### 22.10.17.6.4 Invocation [[func.wrap.ref.inv]](func.wrap.ref.inv)

#### 22.10.17.6.5 Deduction guides [[func.wrap.ref.deduct]](func.wrap.ref.deduct)

#### 22.10.18 Searchers [[func.search]](func.search)

#### 22.10.18.1 General [[func.search.general]](func.search.general)

#### 22.10.18.2 Class template default_searcher [[func.search.default]](func.search.default)

#### 22.10.18.3 Class template boyer_moore_searcher [[func.search.bm]](func.search.bm)

#### 22.10.18.4 Class template boyer_moore_horspool_searcher [[func.search.bmh]](func.search.bmh)

#### 22.10.19 Class template hash [[unord.hash]](unord.hash)

### 22.11 Bit manipulation [[bit]](bit)

#### 22.11.1 General [[bit.general]](bit.general)

#### 22.11.2 Header <bit> synopsis [[bit.syn]](bit.syn)

#### 22.11.3 Function template bit_cast [[bit.cast]](bit.cast)

#### 22.11.4 byteswap [[bit.byteswap]](bit.byteswap)

#### 22.11.5 Integral powers of 2 [[bit.pow.two]](bit.pow.two)

#### 22.11.6 Rotating [[bit.rotate]](bit.rotate)

#### 22.11.7 Counting [[bit.count]](bit.count)

#### 22.11.8 Endian [[bit.endian]](bit.endian)

### 22.12 Header <stdbit.h> synopsis [[stdbit.h.syn]](stdbit.h.syn)

## 23 Containers library [[containers]](#containers)[[containers]](containers)

### 23.1 General [[containers.general]](containers.general)

### 23.2 Requirements [[container.requirements]](container.requirements)

#### 23.2.1 Preamble [[container.requirements.pre]](container.requirements.pre)

#### 23.2.2 General containers [[container.requirements.general]](container.requirements.general)

#### 23.2.2.1 Introduction [[container.intro.reqmts]](container.intro.reqmts)

#### 23.2.2.2 Container requirements [[container.reqmts]](container.reqmts)

#### 23.2.2.3 Reversible container requirements [[container.rev.reqmts]](container.rev.reqmts)

#### 23.2.2.4 Optional container requirements [[container.opt.reqmts]](container.opt.reqmts)

#### 23.2.2.5 Allocator-aware containers [[container.alloc.reqmts]](container.alloc.reqmts)

#### 23.2.3 Container data races [[container.requirements.dataraces]](container.requirements.dataraces)

#### 23.2.4 Sequence containers [[sequence.reqmts]](sequence.reqmts)

#### 23.2.5 Node handles [[container.node]](container.node)

#### 23.2.5.1 Overview [[container.node.overview]](container.node.overview)

#### 23.2.5.2 Constructors, copy, and assignment [[container.node.cons]](container.node.cons)

#### 23.2.5.3 Destructor [[container.node.dtor]](container.node.dtor)

#### 23.2.5.4 Observers [[container.node.observers]](container.node.observers)

#### 23.2.5.5 Modifiers [[container.node.modifiers]](container.node.modifiers)

#### 23.2.6 Insert return type [[container.insert.return]](container.insert.return)

#### 23.2.7 Associative containers [[associative.reqmts]](associative.reqmts)

#### 23.2.7.1 General [[associative.reqmts.general]](associative.reqmts.general)

#### 23.2.7.2 Exception safety guarantees [[associative.reqmts.except]](associative.reqmts.except)

#### 23.2.8 Unordered associative containers [[unord.req]](unord.req)

#### 23.2.8.1 General [[unord.req.general]](unord.req.general)

#### 23.2.8.2 Exception safety guarantees [[unord.req.except]](unord.req.except)

### 23.3 Sequence containers [[sequences]](sequences)

#### 23.3.1 General [[sequences.general]](sequences.general)

#### 23.3.2 Header <array> synopsis [[array.syn]](array.syn)

#### 23.3.3 Class template array [[array]](array)

#### 23.3.3.1 Overview [[array.overview]](array.overview)

#### 23.3.3.2 Constructors, copy, and assignment [[array.cons]](array.cons)

#### 23.3.3.3 Member functions [[array.members]](array.members)

#### 23.3.3.4 Specialized algorithms [[array.special]](array.special)

#### 23.3.3.5 Zero-sized arrays [[array.zero]](array.zero)

#### 23.3.3.6 Array creation functions [[array.creation]](array.creation)

#### 23.3.3.7 Tuple interface [[array.tuple]](array.tuple)

#### 23.3.4 Header <deque> synopsis [[deque.syn]](deque.syn)

#### 23.3.5 Class template deque [[deque]](deque)

#### 23.3.5.1 Overview [[deque.overview]](deque.overview)

#### 23.3.5.2 Constructors, copy, and assignment [[deque.cons]](deque.cons)

#### 23.3.5.3 Capacity [[deque.capacity]](deque.capacity)

#### 23.3.5.4 Modifiers [[deque.modifiers]](deque.modifiers)

#### 23.3.5.5 Erasure [[deque.erasure]](deque.erasure)

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

#### 23.3.7 Class template forward_list [[forward.list]](forward.list)

#### 23.3.7.1 Overview [[forward.list.overview]](forward.list.overview)

#### 23.3.7.2 Constructors, copy, and assignment [[forward.list.cons]](forward.list.cons)

#### 23.3.7.3 Iterators [[forward.list.iter]](forward.list.iter)

#### 23.3.7.4 Element access [[forward.list.access]](forward.list.access)

#### 23.3.7.5 Modifiers [[forward.list.modifiers]](forward.list.modifiers)

#### 23.3.7.6 Operations [[forward.list.ops]](forward.list.ops)

#### 23.3.7.7 Erasure [[forward.list.erasure]](forward.list.erasure)

#### 23.3.8 Header <hive> synopsis [[hive.syn]](hive.syn)

#### 23.3.9 Class template hive [[hive]](hive)

#### 23.3.9.1 Overview [[hive.overview]](hive.overview)

#### 23.3.9.2 Constructors, copy, and assignment [[hive.cons]](hive.cons)

#### 23.3.9.3 Capacity [[hive.capacity]](hive.capacity)

#### 23.3.9.4 Modifiers [[hive.modifiers]](hive.modifiers)

#### 23.3.9.5 Operations [[hive.operations]](hive.operations)

#### 23.3.9.6 Erasure [[hive.erasure]](hive.erasure)

#### 23.3.10 Header <list> synopsis [[list.syn]](list.syn)

#### 23.3.11 Class template list [[list]](list)

#### 23.3.11.1 Overview [[list.overview]](list.overview)

#### 23.3.11.2 Constructors, copy, and assignment [[list.cons]](list.cons)

#### 23.3.11.3 Capacity [[list.capacity]](list.capacity)

#### 23.3.11.4 Modifiers [[list.modifiers]](list.modifiers)

#### 23.3.11.5 Operations [[list.ops]](list.ops)

#### 23.3.11.6 Erasure [[list.erasure]](list.erasure)

#### 23.3.12 Header <vector> synopsis [[vector.syn]](vector.syn)

#### 23.3.13 Class template vector [[vector]](vector)

#### 23.3.13.1 Overview [[vector.overview]](vector.overview)

#### 23.3.13.2 Constructors [[vector.cons]](vector.cons)

#### 23.3.13.3 Capacity [[vector.capacity]](vector.capacity)

#### 23.3.13.4 Data [[vector.data]](vector.data)

#### 23.3.13.5 Modifiers [[vector.modifiers]](vector.modifiers)

#### 23.3.13.6 Erasure [[vector.erasure]](vector.erasure)

#### 23.3.14 Specialization of vector for bool [[vector.bool]](vector.bool)

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

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

#### 23.3.15 Header <inplace_vector> synopsis [[inplace.vector.syn]](inplace.vector.syn)

#### 23.3.16 Class template inplace_vector [[inplace.vector]](inplace.vector)

#### 23.3.16.1 Overview [[inplace.vector.overview]](inplace.vector.overview)

#### 23.3.16.2 Constructors [[inplace.vector.cons]](inplace.vector.cons)

#### 23.3.16.3 Capacity [[inplace.vector.capacity]](inplace.vector.capacity)

#### 23.3.16.4 Data [[inplace.vector.data]](inplace.vector.data)

#### 23.3.16.5 Modifiers [[inplace.vector.modifiers]](inplace.vector.modifiers)

#### 23.3.16.6 Erasure [[inplace.vector.erasure]](inplace.vector.erasure)

### 23.4 Associative containers [[associative]](associative)

#### 23.4.1 General [[associative.general]](associative.general)

#### 23.4.2 Header <map> synopsis [[associative.map.syn]](associative.map.syn)

#### 23.4.3 Class template map [[map]](map)

#### 23.4.3.1 Overview [[map.overview]](map.overview)

#### 23.4.3.2 Constructors, copy, and assignment [[map.cons]](map.cons)

#### 23.4.3.3 Element access [[map.access]](map.access)

#### 23.4.3.4 Modifiers [[map.modifiers]](map.modifiers)

#### 23.4.3.5 Erasure [[map.erasure]](map.erasure)

#### 23.4.4 Class template multimap [[multimap]](multimap)

#### 23.4.4.1 Overview [[multimap.overview]](multimap.overview)

#### 23.4.4.2 Constructors [[multimap.cons]](multimap.cons)

#### 23.4.4.3 Modifiers [[multimap.modifiers]](multimap.modifiers)

#### 23.4.4.4 Erasure [[multimap.erasure]](multimap.erasure)

#### 23.4.5 Header <set> synopsis [[associative.set.syn]](associative.set.syn)

#### 23.4.6 Class template set [[set]](set)

#### 23.4.6.1 Overview [[set.overview]](set.overview)

#### 23.4.6.2 Constructors, copy, and assignment [[set.cons]](set.cons)

#### 23.4.6.3 Erasure [[set.erasure]](set.erasure)

#### 23.4.6.4 Modifiers [[set.modifiers]](set.modifiers)

#### 23.4.7 Class template multiset [[multiset]](multiset)

#### 23.4.7.1 Overview [[multiset.overview]](multiset.overview)

#### 23.4.7.2 Constructors [[multiset.cons]](multiset.cons)

#### 23.4.7.3 Erasure [[multiset.erasure]](multiset.erasure)

### 23.5 Unordered associative containers [[unord]](unord)

#### 23.5.1 General [[unord.general]](unord.general)

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

#### 23.5.3 Class template unordered_map [[unord.map]](unord.map)

#### 23.5.3.1 Overview [[unord.map.overview]](unord.map.overview)

#### 23.5.3.2 Constructors [[unord.map.cnstr]](unord.map.cnstr)

#### 23.5.3.3 Element access [[unord.map.elem]](unord.map.elem)

#### 23.5.3.4 Modifiers [[unord.map.modifiers]](unord.map.modifiers)

#### 23.5.3.5 Erasure [[unord.map.erasure]](unord.map.erasure)

#### 23.5.4 Class template unordered_multimap [[unord.multimap]](unord.multimap)

#### 23.5.4.1 Overview [[unord.multimap.overview]](unord.multimap.overview)

#### 23.5.4.2 Constructors [[unord.multimap.cnstr]](unord.multimap.cnstr)

#### 23.5.4.3 Modifiers [[unord.multimap.modifiers]](unord.multimap.modifiers)

#### 23.5.4.4 Erasure [[unord.multimap.erasure]](unord.multimap.erasure)

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

#### 23.5.6 Class template unordered_set [[unord.set]](unord.set)

#### 23.5.6.1 Overview [[unord.set.overview]](unord.set.overview)

#### 23.5.6.2 Constructors [[unord.set.cnstr]](unord.set.cnstr)

#### 23.5.6.3 Erasure [[unord.set.erasure]](unord.set.erasure)

#### 23.5.6.4 Modifiers [[unord.set.modifiers]](unord.set.modifiers)

#### 23.5.7 Class template unordered_multiset [[unord.multiset]](unord.multiset)

#### 23.5.7.1 Overview [[unord.multiset.overview]](unord.multiset.overview)

#### 23.5.7.2 Constructors [[unord.multiset.cnstr]](unord.multiset.cnstr)

#### 23.5.7.3 Erasure [[unord.multiset.erasure]](unord.multiset.erasure)

### 23.6 Container adaptors [[container.adaptors]](container.adaptors)

#### 23.6.1 General [[container.adaptors.general]](container.adaptors.general)

#### 23.6.2 Header <queue> synopsis [[queue.syn]](queue.syn)

#### 23.6.3 Class template queue [[queue]](queue)

#### 23.6.3.1 Definition [[queue.defn]](queue.defn)

#### 23.6.3.2 Constructors [[queue.cons]](queue.cons)

#### 23.6.3.3 Constructors with allocators [[queue.cons.alloc]](queue.cons.alloc)

#### 23.6.3.4 Modifiers [[queue.mod]](queue.mod)

#### 23.6.3.5 Operators [[queue.ops]](queue.ops)

#### 23.6.3.6 Specialized algorithms [[queue.special]](queue.special)

#### 23.6.4 Class template priority_queue [[priority.queue]](priority.queue)

#### 23.6.4.1 Overview [[priqueue.overview]](priqueue.overview)

#### 23.6.4.2 Constructors [[priqueue.cons]](priqueue.cons)

#### 23.6.4.3 Constructors with allocators [[priqueue.cons.alloc]](priqueue.cons.alloc)

#### 23.6.4.4 Members [[priqueue.members]](priqueue.members)

#### 23.6.4.5 Specialized algorithms [[priqueue.special]](priqueue.special)

#### 23.6.5 Header <stack> synopsis [[stack.syn]](stack.syn)

#### 23.6.6 Class template stack [[stack]](stack)

#### 23.6.6.1 General [[stack.general]](stack.general)

#### 23.6.6.2 Definition [[stack.defn]](stack.defn)

#### 23.6.6.3 Constructors [[stack.cons]](stack.cons)

#### 23.6.6.4 Constructors with allocators [[stack.cons.alloc]](stack.cons.alloc)

#### 23.6.6.5 Modifiers [[stack.mod]](stack.mod)

#### 23.6.6.6 Operators [[stack.ops]](stack.ops)

#### 23.6.6.7 Specialized algorithms [[stack.special]](stack.special)

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

#### 23.6.8 Class template flat_map [[flat.map]](flat.map)

#### 23.6.8.1 Overview [[flat.map.overview]](flat.map.overview)

#### 23.6.8.2 Definition [[flat.map.defn]](flat.map.defn)

#### 23.6.8.3 Constructors [[flat.map.cons]](flat.map.cons)

#### 23.6.8.4 Constructors with allocators [[flat.map.cons.alloc]](flat.map.cons.alloc)

#### 23.6.8.5 Capacity [[flat.map.capacity]](flat.map.capacity)

#### 23.6.8.6 Access [[flat.map.access]](flat.map.access)

#### 23.6.8.7 Modifiers [[flat.map.modifiers]](flat.map.modifiers)

#### 23.6.8.8 Erasure [[flat.map.erasure]](flat.map.erasure)

#### 23.6.9 Class template flat_multimap [[flat.multimap]](flat.multimap)

#### 23.6.9.1 Overview [[flat.multimap.overview]](flat.multimap.overview)

#### 23.6.9.2 Definition [[flat.multimap.defn]](flat.multimap.defn)

#### 23.6.9.3 Constructors [[flat.multimap.cons]](flat.multimap.cons)

#### 23.6.9.4 Constructors with allocators [[flat.multimap.cons.alloc]](flat.multimap.cons.alloc)

#### 23.6.9.5 Erasure [[flat.multimap.erasure]](flat.multimap.erasure)

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

#### 23.6.11 Class template flat_set [[flat.set]](flat.set)

#### 23.6.11.1 Overview [[flat.set.overview]](flat.set.overview)

#### 23.6.11.2 Definition [[flat.set.defn]](flat.set.defn)

#### 23.6.11.3 Constructors [[flat.set.cons]](flat.set.cons)

#### 23.6.11.4 Constructors with allocators [[flat.set.cons.alloc]](flat.set.cons.alloc)

#### 23.6.11.5 Modifiers [[flat.set.modifiers]](flat.set.modifiers)

#### 23.6.11.6 Erasure [[flat.set.erasure]](flat.set.erasure)

#### 23.6.12 Class template flat_multiset [[flat.multiset]](flat.multiset)

#### 23.6.12.1 Overview [[flat.multiset.overview]](flat.multiset.overview)

#### 23.6.12.2 Definition [[flat.multiset.defn]](flat.multiset.defn)

#### 23.6.12.3 Constructors [[flat.multiset.cons]](flat.multiset.cons)

#### 23.6.12.4 Constructors with allocators [[flat.multiset.cons.alloc]](flat.multiset.cons.alloc)

#### 23.6.12.5 Modifiers [[flat.multiset.modifiers]](flat.multiset.modifiers)

#### 23.6.12.6 Erasure [[flat.multiset.erasure]](flat.multiset.erasure)

#### 23.6.13 Container adaptors formatting [[container.adaptors.format]](container.adaptors.format)

### 23.7 Views [[views]](views)

#### 23.7.1 General [[views.general]](views.general)

#### 23.7.2 Contiguous access [[views.contiguous]](views.contiguous)

#### 23.7.2.1 Header <span> synopsis [[span.syn]](span.syn)

#### 23.7.2.2 Class template span [[views.span]](views.span)

#### 23.7.2.2.1 Overview [[span.overview]](span.overview)

#### 23.7.2.2.2 Constructors, copy, and assignment [[span.cons]](span.cons)

#### 23.7.2.2.3 Deduction guides [[span.deduct]](span.deduct)

#### 23.7.2.2.4 Subviews [[span.sub]](span.sub)

#### 23.7.2.2.5 Observers [[span.obs]](span.obs)

#### 23.7.2.2.6 Element access [[span.elem]](span.elem)

#### 23.7.2.2.7 Iterator support [[span.iterators]](span.iterators)

#### 23.7.2.3 Views of object representation [[span.objectrep]](span.objectrep)

#### 23.7.3 Multidimensional access [[views.multidim]](views.multidim)

#### 23.7.3.1 Overview [[mdspan.overview]](mdspan.overview)

#### 23.7.3.2 Header <mdspan> synopsis [[mdspan.syn]](mdspan.syn)

#### 23.7.3.3 Class template extents [[mdspan.extents]](mdspan.extents)

#### 23.7.3.3.1 Overview [[mdspan.extents.overview]](mdspan.extents.overview)

#### 23.7.3.3.2 Exposition-only helpers [[mdspan.extents.expo]](mdspan.extents.expo)

#### 23.7.3.3.3 Constructors [[mdspan.extents.cons]](mdspan.extents.cons)

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

#### 23.7.3.3.5 Comparison operators [[mdspan.extents.cmp]](mdspan.extents.cmp)

#### 23.7.3.3.6 Alias template dextents [[mdspan.extents.dextents]](mdspan.extents.dextents)

#### 23.7.3.3.7 Alias template dims [[mdspan.extents.dims]](mdspan.extents.dims)

#### 23.7.3.4 Layout mapping [[mdspan.layout]](mdspan.layout)

#### 23.7.3.4.1 General [[mdspan.layout.general]](mdspan.layout.general)

#### 23.7.3.4.2 Requirements [[mdspan.layout.reqmts]](mdspan.layout.reqmts)

#### 23.7.3.4.3 Layout mapping policy requirements [[mdspan.layout.policy.reqmts]](mdspan.layout.policy.reqmts)

#### 23.7.3.4.4 Layout mapping policies [[mdspan.layout.policy.overview]](mdspan.layout.policy.overview)

#### 23.7.3.4.5 Class template layout_left​::​mapping [[mdspan.layout.left]](mdspan.layout.left)

#### 23.7.3.4.5.1 Overview [[mdspan.layout.left.overview]](mdspan.layout.left.overview)

#### 23.7.3.4.5.2 Constructors [[mdspan.layout.left.cons]](mdspan.layout.left.cons)

#### 23.7.3.4.5.3 Observers [[mdspan.layout.left.obs]](mdspan.layout.left.obs)

#### 23.7.3.4.6 Class template layout_right​::​mapping [[mdspan.layout.right]](mdspan.layout.right)

#### 23.7.3.4.6.1 Overview [[mdspan.layout.right.overview]](mdspan.layout.right.overview)

#### 23.7.3.4.6.2 Constructors [[mdspan.layout.right.cons]](mdspan.layout.right.cons)

#### 23.7.3.4.6.3 Observers [[mdspan.layout.right.obs]](mdspan.layout.right.obs)

#### 23.7.3.4.7 Class template layout_stride​::​mapping [[mdspan.layout.stride]](mdspan.layout.stride)

#### 23.7.3.4.7.1 Overview [[mdspan.layout.stride.overview]](mdspan.layout.stride.overview)

#### 23.7.3.4.7.2 Exposition-only helpers [[mdspan.layout.stride.expo]](mdspan.layout.stride.expo)

#### 23.7.3.4.7.3 Constructors [[mdspan.layout.stride.cons]](mdspan.layout.stride.cons)

#### 23.7.3.4.7.4 Observers [[mdspan.layout.stride.obs]](mdspan.layout.stride.obs)

#### 23.7.3.4.8 Class template layout_left_padded​::​mapping [[mdspan.layout.leftpad]](mdspan.layout.leftpad)

#### 23.7.3.4.8.1 Overview [[mdspan.layout.leftpad.overview]](mdspan.layout.leftpad.overview)

#### 23.7.3.4.8.2 Exposition-only members [[mdspan.layout.leftpad.expo]](mdspan.layout.leftpad.expo)

#### 23.7.3.4.8.3 Constructors [[mdspan.layout.leftpad.cons]](mdspan.layout.leftpad.cons)

#### 23.7.3.4.8.4 Observers [[mdspan.layout.leftpad.obs]](mdspan.layout.leftpad.obs)

#### 23.7.3.4.9 Class template layout_right_padded​::​mapping [[mdspan.layout.rightpad]](mdspan.layout.rightpad)

#### 23.7.3.4.9.1 Overview [[mdspan.layout.rightpad.overview]](mdspan.layout.rightpad.overview)

#### 23.7.3.4.9.2 Exposition-only members [[mdspan.layout.rightpad.expo]](mdspan.layout.rightpad.expo)

#### 23.7.3.4.9.3 Constructors [[mdspan.layout.rightpad.cons]](mdspan.layout.rightpad.cons)

#### 23.7.3.4.9.4 Observers [[mdspan.layout.rightpad.obs]](mdspan.layout.rightpad.obs)

#### 23.7.3.5 Accessor policy [[mdspan.accessor]](mdspan.accessor)

#### 23.7.3.5.1 General [[mdspan.accessor.general]](mdspan.accessor.general)

#### 23.7.3.5.2 Requirements [[mdspan.accessor.reqmts]](mdspan.accessor.reqmts)

#### 23.7.3.5.3 Class template default_accessor [[mdspan.accessor.default]](mdspan.accessor.default)

#### 23.7.3.5.3.1 Overview [[mdspan.accessor.default.overview]](mdspan.accessor.default.overview)

#### 23.7.3.5.3.2 Members [[mdspan.accessor.default.members]](mdspan.accessor.default.members)

#### 23.7.3.5.4 Class template aligned_accessor [[mdspan.accessor.aligned]](mdspan.accessor.aligned)

#### 23.7.3.5.4.1 Overview [[mdspan.accessor.aligned.overview]](mdspan.accessor.aligned.overview)

#### 23.7.3.5.4.2 Members [[mdspan.accessor.aligned.members]](mdspan.accessor.aligned.members)

#### 23.7.3.6 Class template mdspan [[mdspan.mdspan]](mdspan.mdspan)

#### 23.7.3.6.1 Overview [[mdspan.mdspan.overview]](mdspan.mdspan.overview)

#### 23.7.3.6.2 Constructors [[mdspan.mdspan.cons]](mdspan.mdspan.cons)

#### 23.7.3.6.3 Members [[mdspan.mdspan.members]](mdspan.mdspan.members)

#### 23.7.3.7 submdspan [[mdspan.sub]](mdspan.sub)

#### 23.7.3.7.1 Overview [[mdspan.sub.overview]](mdspan.sub.overview)

#### 23.7.3.7.2 strided_slice [[mdspan.sub.strided.slice]](mdspan.sub.strided.slice)

#### 23.7.3.7.3 submdspan_mapping_result [[mdspan.sub.map.result]](mdspan.sub.map.result)

#### 23.7.3.7.4 Exposition-only helpers [[mdspan.sub.helpers]](mdspan.sub.helpers)

#### 23.7.3.7.5 submdspan_extents function [[mdspan.sub.extents]](mdspan.sub.extents)

#### 23.7.3.7.6 Specializations of submdspan_mapping [[mdspan.sub.map]](mdspan.sub.map)

#### 23.7.3.7.6.1 Common [[mdspan.sub.map.common]](mdspan.sub.map.common)

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

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

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

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

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

#### 23.7.3.7.7 submdspan function template [[mdspan.sub.sub]](mdspan.sub.sub)

## 24 Iterators library [[iterators]](#iterators)[[iterators]](iterators)

### 24.1 General [[iterators.general]](iterators.general)

### 24.2 Header <iterator> synopsis [[iterator.synopsis]](iterator.synopsis)

### 24.3 Iterator requirements [[iterator.requirements]](iterator.requirements)

#### 24.3.1 General [[iterator.requirements.general]](iterator.requirements.general)

#### 24.3.2 Associated types [[iterator.assoc.types]](iterator.assoc.types)

#### 24.3.2.1 Incrementable traits [[incrementable.traits]](incrementable.traits)

#### 24.3.2.2 Indirectly readable traits [[readable.traits]](readable.traits)

#### 24.3.2.3 Iterator traits [[iterator.traits]](iterator.traits)

#### 24.3.3 Customization point objects [[iterator.cust]](iterator.cust)

#### 24.3.3.1 ranges​::​iter_move [[iterator.cust.move]](iterator.cust.move)

#### 24.3.3.2 ranges​::​iter_swap [[iterator.cust.swap]](iterator.cust.swap)

#### 24.3.4 Iterator concepts [[iterator.concepts]](iterator.concepts)

#### 24.3.4.1 General [[iterator.concepts.general]](iterator.concepts.general)

#### 24.3.4.2 Concept indirectly_readable [[iterator.concept.readable]](iterator.concept.readable)

#### 24.3.4.3 Concept indirectly_writable [[iterator.concept.writable]](iterator.concept.writable)

#### 24.3.4.4 Concept weakly_incrementable [[iterator.concept.winc]](iterator.concept.winc)

#### 24.3.4.5 Concept incrementable [[iterator.concept.inc]](iterator.concept.inc)

#### 24.3.4.6 Concept input_or_output_iterator [[iterator.concept.iterator]](iterator.concept.iterator)

#### 24.3.4.7 Concept sentinel_for [[iterator.concept.sentinel]](iterator.concept.sentinel)

#### 24.3.4.8 Concept sized_sentinel_for [[iterator.concept.sizedsentinel]](iterator.concept.sizedsentinel)

#### 24.3.4.9 Concept input_iterator [[iterator.concept.input]](iterator.concept.input)

#### 24.3.4.10 Concept output_iterator [[iterator.concept.output]](iterator.concept.output)

#### 24.3.4.11 Concept forward_iterator [[iterator.concept.forward]](iterator.concept.forward)

#### 24.3.4.12 Concept bidirectional_iterator [[iterator.concept.bidir]](iterator.concept.bidir)

#### 24.3.4.13 Concept random_access_iterator [[iterator.concept.random.access]](iterator.concept.random.access)

#### 24.3.4.14 Concept contiguous_iterator [[iterator.concept.contiguous]](iterator.concept.contiguous)

#### 24.3.5 C++17 iterator requirements [[iterator.cpp17]](iterator.cpp17)

#### 24.3.5.1 General [[iterator.cpp17.general]](iterator.cpp17.general)

#### 24.3.5.2 *Cpp17Iterator* [[iterator.iterators]](iterator.iterators)

#### 24.3.5.3 Input iterators [[input.iterators]](input.iterators)

#### 24.3.5.4 Output iterators [[output.iterators]](output.iterators)

#### 24.3.5.5 Forward iterators [[forward.iterators]](forward.iterators)

#### 24.3.5.6 Bidirectional iterators [[bidirectional.iterators]](bidirectional.iterators)

#### 24.3.5.7 Random access iterators [[random.access.iterators]](random.access.iterators)

#### 24.3.6 Indirect callable requirements [[indirectcallable]](indirectcallable)

#### 24.3.6.1 General [[indirectcallable.general]](indirectcallable.general)

#### 24.3.6.2 Indirect callable traits [[indirectcallable.traits]](indirectcallable.traits)

#### 24.3.6.3 Indirect callables [[indirectcallable.indirectinvocable]](indirectcallable.indirectinvocable)

#### 24.3.6.4 Alias template projected [[projected]](projected)

#### 24.3.7 Common algorithm requirements [[alg.req]](alg.req)

#### 24.3.7.1 General [[alg.req.general]](alg.req.general)

#### 24.3.7.2 Concept indirectly_movable [[alg.req.ind.move]](alg.req.ind.move)

#### 24.3.7.3 Concept indirectly_copyable [[alg.req.ind.copy]](alg.req.ind.copy)

#### 24.3.7.4 Concept indirectly_swappable [[alg.req.ind.swap]](alg.req.ind.swap)

#### 24.3.7.5 Concept indirectly_comparable [[alg.req.ind.cmp]](alg.req.ind.cmp)

#### 24.3.7.6 Concept permutable [[alg.req.permutable]](alg.req.permutable)

#### 24.3.7.7 Concept mergeable [[alg.req.mergeable]](alg.req.mergeable)

#### 24.3.7.8 Concept sortable [[alg.req.sortable]](alg.req.sortable)

### 24.4 Iterator primitives [[iterator.primitives]](iterator.primitives)

#### 24.4.1 General [[iterator.primitives.general]](iterator.primitives.general)

#### 24.4.2 Standard iterator tags [[std.iterator.tags]](std.iterator.tags)

#### 24.4.3 Iterator operations [[iterator.operations]](iterator.operations)

#### 24.4.4 Range iterator operations [[range.iter.ops]](range.iter.ops)

#### 24.4.4.1 General [[range.iter.ops.general]](range.iter.ops.general)

#### 24.4.4.2 ranges​::​advance [[range.iter.op.advance]](range.iter.op.advance)

#### 24.4.4.3 ranges​::​distance [[range.iter.op.distance]](range.iter.op.distance)

#### 24.4.4.4 ranges​::​next [[range.iter.op.next]](range.iter.op.next)

#### 24.4.4.5 ranges​::​prev [[range.iter.op.prev]](range.iter.op.prev)

### 24.5 Iterator adaptors [[predef.iterators]](predef.iterators)

#### 24.5.1 Reverse iterators [[reverse.iterators]](reverse.iterators)

#### 24.5.1.1 General [[reverse.iterators.general]](reverse.iterators.general)

#### 24.5.1.2 Class template reverse_iterator [[reverse.iterator]](reverse.iterator)

#### 24.5.1.3 Requirements [[reverse.iter.requirements]](reverse.iter.requirements)

#### 24.5.1.4 Construction and assignment [[reverse.iter.cons]](reverse.iter.cons)

#### 24.5.1.5 Conversion [[reverse.iter.conv]](reverse.iter.conv)

#### 24.5.1.6 Element access [[reverse.iter.elem]](reverse.iter.elem)

#### 24.5.1.7 Navigation [[reverse.iter.nav]](reverse.iter.nav)

#### 24.5.1.8 Comparisons [[reverse.iter.cmp]](reverse.iter.cmp)

#### 24.5.1.9 Non-member functions [[reverse.iter.nonmember]](reverse.iter.nonmember)

#### 24.5.2 Insert iterators [[insert.iterators]](insert.iterators)

#### 24.5.2.1 General [[insert.iterators.general]](insert.iterators.general)

#### 24.5.2.2 Class template back_insert_iterator [[back.insert.iterator]](back.insert.iterator)

#### 24.5.2.2.1 General [[back.insert.iter.general]](back.insert.iter.general)

#### 24.5.2.2.2 Operations [[back.insert.iter.ops]](back.insert.iter.ops)

#### 24.5.2.2.3 back_inserter [[back.inserter]](back.inserter)

#### 24.5.2.3 Class template front_insert_iterator [[front.insert.iterator]](front.insert.iterator)

#### 24.5.2.3.1 General [[front.insert.iter.general]](front.insert.iter.general)

#### 24.5.2.3.2 Operations [[front.insert.iter.ops]](front.insert.iter.ops)

#### 24.5.2.3.3 front_inserter [[front.inserter]](front.inserter)

#### 24.5.2.4 Class template insert_iterator [[insert.iterator]](insert.iterator)

#### 24.5.2.4.1 General [[insert.iter.general]](insert.iter.general)

#### 24.5.2.4.2 Operations [[insert.iter.ops]](insert.iter.ops)

#### 24.5.2.4.3 inserter [[inserter]](inserter)

#### 24.5.3 Constant iterators and sentinels [[const.iterators]](const.iterators)

#### 24.5.3.1 General [[const.iterators.general]](const.iterators.general)

#### 24.5.3.2 Alias templates [[const.iterators.alias]](const.iterators.alias)

#### 24.5.3.3 Class template basic_const_iterator [[const.iterators.iterator]](const.iterators.iterator)

#### 24.5.3.4 Member types [[const.iterators.types]](const.iterators.types)

#### 24.5.3.5 Operations [[const.iterators.ops]](const.iterators.ops)

#### 24.5.4 Move iterators and sentinels [[move.iterators]](move.iterators)

#### 24.5.4.1 General [[move.iterators.general]](move.iterators.general)

#### 24.5.4.2 Class template move_iterator [[move.iterator]](move.iterator)

#### 24.5.4.3 Requirements [[move.iter.requirements]](move.iter.requirements)

#### 24.5.4.4 Construction and assignment [[move.iter.cons]](move.iter.cons)

#### 24.5.4.5 Conversion [[move.iter.op.conv]](move.iter.op.conv)

#### 24.5.4.6 Element access [[move.iter.elem]](move.iter.elem)

#### 24.5.4.7 Navigation [[move.iter.nav]](move.iter.nav)

#### 24.5.4.8 Comparisons [[move.iter.op.comp]](move.iter.op.comp)

#### 24.5.4.9 Non-member functions [[move.iter.nonmember]](move.iter.nonmember)

#### 24.5.4.10 Class template move_sentinel [[move.sentinel]](move.sentinel)

#### 24.5.4.11 Operations [[move.sent.ops]](move.sent.ops)

#### 24.5.5 Common iterators [[iterators.common]](iterators.common)

#### 24.5.5.1 Class template common_iterator [[common.iterator]](common.iterator)

#### 24.5.5.2 Associated types [[common.iter.types]](common.iter.types)

#### 24.5.5.3 Constructors and conversions [[common.iter.const]](common.iter.const)

#### 24.5.5.4 Accessors [[common.iter.access]](common.iter.access)

#### 24.5.5.5 Navigation [[common.iter.nav]](common.iter.nav)

#### 24.5.5.6 Comparisons [[common.iter.cmp]](common.iter.cmp)

#### 24.5.5.7 Customizations [[common.iter.cust]](common.iter.cust)

#### 24.5.6 Default sentinel [[default.sentinel]](default.sentinel)

#### 24.5.7 Counted iterators [[iterators.counted]](iterators.counted)

#### 24.5.7.1 Class template counted_iterator [[counted.iterator]](counted.iterator)

#### 24.5.7.2 Constructors and conversions [[counted.iter.const]](counted.iter.const)

#### 24.5.7.3 Accessors [[counted.iter.access]](counted.iter.access)

#### 24.5.7.4 Element access [[counted.iter.elem]](counted.iter.elem)

#### 24.5.7.5 Navigation [[counted.iter.nav]](counted.iter.nav)

#### 24.5.7.6 Comparisons [[counted.iter.cmp]](counted.iter.cmp)

#### 24.5.7.7 Customizations [[counted.iter.cust]](counted.iter.cust)

#### 24.5.8 Unreachable sentinel [[unreachable.sentinel]](unreachable.sentinel)

### 24.6 Stream iterators [[stream.iterators]](stream.iterators)

#### 24.6.1 General [[stream.iterators.general]](stream.iterators.general)

#### 24.6.2 Class template istream_iterator [[istream.iterator]](istream.iterator)

#### 24.6.2.1 General [[istream.iterator.general]](istream.iterator.general)

#### 24.6.2.2 Constructors and destructor [[istream.iterator.cons]](istream.iterator.cons)

#### 24.6.2.3 Operations [[istream.iterator.ops]](istream.iterator.ops)

#### 24.6.3 Class template ostream_iterator [[ostream.iterator]](ostream.iterator)

#### 24.6.3.1 General [[ostream.iterator.general]](ostream.iterator.general)

#### 24.6.3.2 Constructors and destructor [[ostream.iterator.cons.des]](ostream.iterator.cons.des)

#### 24.6.3.3 Operations [[ostream.iterator.ops]](ostream.iterator.ops)

#### 24.6.4 Class template istreambuf_iterator [[istreambuf.iterator]](istreambuf.iterator)

#### 24.6.4.1 General [[istreambuf.iterator.general]](istreambuf.iterator.general)

#### 24.6.4.2 Class istreambuf_iterator​::​*proxy* [[istreambuf.iterator.proxy]](istreambuf.iterator.proxy)

#### 24.6.4.3 Constructors [[istreambuf.iterator.cons]](istreambuf.iterator.cons)

#### 24.6.4.4 Operations [[istreambuf.iterator.ops]](istreambuf.iterator.ops)

#### 24.6.5 Class template ostreambuf_iterator [[ostreambuf.iterator]](ostreambuf.iterator)

#### 24.6.5.1 General [[ostreambuf.iterator.general]](ostreambuf.iterator.general)

#### 24.6.5.2 Constructors [[ostreambuf.iter.cons]](ostreambuf.iter.cons)

#### 24.6.5.3 Operations [[ostreambuf.iter.ops]](ostreambuf.iter.ops)

### 24.7 Range access [[iterator.range]](iterator.range)

## 25 Ranges library [[ranges]](#ranges)[[ranges]](ranges)

### 25.1 General [[ranges.general]](ranges.general)

### 25.2 Header <ranges> synopsis [[ranges.syn]](ranges.syn)

### 25.3 Range access [[range.access]](range.access)

#### 25.3.1 General [[range.access.general]](range.access.general)

#### 25.3.2 ranges​::​begin [[range.access.begin]](range.access.begin)

#### 25.3.3 ranges​::​end [[range.access.end]](range.access.end)

#### 25.3.4 ranges​::​cbegin [[range.access.cbegin]](range.access.cbegin)

#### 25.3.5 ranges​::​cend [[range.access.cend]](range.access.cend)

#### 25.3.6 ranges​::​rbegin [[range.access.rbegin]](range.access.rbegin)

#### 25.3.7 ranges​::​rend [[range.access.rend]](range.access.rend)

#### 25.3.8 ranges​::​crbegin [[range.access.crbegin]](range.access.crbegin)

#### 25.3.9 ranges​::​crend [[range.access.crend]](range.access.crend)

#### 25.3.10 ranges​::​size [[range.prim.size]](range.prim.size)

#### 25.3.11 ranges​::​ssize [[range.prim.ssize]](range.prim.ssize)

#### 25.3.12 ranges​::​reserve_hint [[range.prim.size.hint]](range.prim.size.hint)

#### 25.3.13 ranges​::​empty [[range.prim.empty]](range.prim.empty)

#### 25.3.14 ranges​::​data [[range.prim.data]](range.prim.data)

#### 25.3.15 ranges​::​cdata [[range.prim.cdata]](range.prim.cdata)

### 25.4 Range requirements [[range.req]](range.req)

#### 25.4.1 General [[range.req.general]](range.req.general)

#### 25.4.2 Ranges [[range.range]](range.range)

#### 25.4.3 Approximately sized ranges [[range.approximately.sized]](range.approximately.sized)

#### 25.4.4 Sized ranges [[range.sized]](range.sized)

#### 25.4.5 Views [[range.view]](range.view)

#### 25.4.6 Other range refinements [[range.refinements]](range.refinements)

### 25.5 Range utilities [[range.utility]](range.utility)

#### 25.5.1 General [[range.utility.general]](range.utility.general)

#### 25.5.2 Helper concepts [[range.utility.helpers]](range.utility.helpers)

#### 25.5.3 View interface [[view.interface]](view.interface)

#### 25.5.3.1 General [[view.interface.general]](view.interface.general)

#### 25.5.3.2 Members [[view.interface.members]](view.interface.members)

#### 25.5.4 Sub-ranges [[range.subrange]](range.subrange)

#### 25.5.4.1 General [[range.subrange.general]](range.subrange.general)

#### 25.5.4.2 Constructors and conversions [[range.subrange.ctor]](range.subrange.ctor)

#### 25.5.4.3 Accessors [[range.subrange.access]](range.subrange.access)

#### 25.5.5 Dangling iterator handling [[range.dangling]](range.dangling)

#### 25.5.6 Class template elements_of [[range.elementsof]](range.elementsof)

#### 25.5.7 Range conversions [[range.utility.conv]](range.utility.conv)

#### 25.5.7.1 General [[range.utility.conv.general]](range.utility.conv.general)

#### 25.5.7.2 ranges​::​to [[range.utility.conv.to]](range.utility.conv.to)

#### 25.5.7.3 ranges​::​to adaptors [[range.utility.conv.adaptors]](range.utility.conv.adaptors)

### 25.6 Range factories [[range.factories]](range.factories)

#### 25.6.1 General [[range.factories.general]](range.factories.general)

#### 25.6.2 Empty view [[range.empty]](range.empty)

#### 25.6.2.1 Overview [[range.empty.overview]](range.empty.overview)

#### 25.6.2.2 Class template empty_view [[range.empty.view]](range.empty.view)

#### 25.6.3 Single view [[range.single]](range.single)

#### 25.6.3.1 Overview [[range.single.overview]](range.single.overview)

#### 25.6.3.2 Class template single_view [[range.single.view]](range.single.view)

#### 25.6.4 Iota view [[range.iota]](range.iota)

#### 25.6.4.1 Overview [[range.iota.overview]](range.iota.overview)

#### 25.6.4.2 Class template iota_view [[range.iota.view]](range.iota.view)

#### 25.6.4.3 Class iota_view​::​*iterator* [[range.iota.iterator]](range.iota.iterator)

#### 25.6.4.4 Class iota_view​::​*sentinel* [[range.iota.sentinel]](range.iota.sentinel)

#### 25.6.5 Repeat view [[range.repeat]](range.repeat)

#### 25.6.5.1 Overview [[range.repeat.overview]](range.repeat.overview)

#### 25.6.5.2 Class template repeat_view [[range.repeat.view]](range.repeat.view)

#### 25.6.5.3 Class repeat_view​::​*iterator* [[range.repeat.iterator]](range.repeat.iterator)

#### 25.6.6 Istream view [[range.istream]](range.istream)

#### 25.6.6.1 Overview [[range.istream.overview]](range.istream.overview)

#### 25.6.6.2 Class template basic_istream_view [[range.istream.view]](range.istream.view)

#### 25.6.6.3 Class basic_istream_view​::​*iterator* [[range.istream.iterator]](range.istream.iterator)

### 25.7 Range adaptors [[range.adaptors]](range.adaptors)

#### 25.7.1 General [[range.adaptors.general]](range.adaptors.general)

#### 25.7.2 Range adaptor objects [[range.adaptor.object]](range.adaptor.object)

#### 25.7.3 Movable wrapper [[range.move.wrap]](range.move.wrap)

#### 25.7.4 Non-propagating cache [[range.nonprop.cache]](range.nonprop.cache)

#### 25.7.5 Range adaptor helpers [[range.adaptor.helpers]](range.adaptor.helpers)

#### 25.7.6 All view [[range.all]](range.all)

#### 25.7.6.1 General [[range.all.general]](range.all.general)

#### 25.7.6.2 Class template ref_view [[range.ref.view]](range.ref.view)

#### 25.7.6.3 Class template owning_view [[range.owning.view]](range.owning.view)

#### 25.7.7 As rvalue view [[range.as.rvalue]](range.as.rvalue)

#### 25.7.7.1 Overview [[range.as.rvalue.overview]](range.as.rvalue.overview)

#### 25.7.7.2 Class template as_rvalue_view [[range.as.rvalue.view]](range.as.rvalue.view)

#### 25.7.8 Filter view [[range.filter]](range.filter)

#### 25.7.8.1 Overview [[range.filter.overview]](range.filter.overview)

#### 25.7.8.2 Class template filter_view [[range.filter.view]](range.filter.view)

#### 25.7.8.3 Class filter_view​::​*iterator* [[range.filter.iterator]](range.filter.iterator)

#### 25.7.8.4 Class filter_view​::​*sentinel* [[range.filter.sentinel]](range.filter.sentinel)

#### 25.7.9 Transform view [[range.transform]](range.transform)

#### 25.7.9.1 Overview [[range.transform.overview]](range.transform.overview)

#### 25.7.9.2 Class template transform_view [[range.transform.view]](range.transform.view)

#### 25.7.9.3 Class template transform_view​::​*iterator* [[range.transform.iterator]](range.transform.iterator)

#### 25.7.9.4 Class template transform_view​::​*sentinel* [[range.transform.sentinel]](range.transform.sentinel)

#### 25.7.10 Take view [[range.take]](range.take)

#### 25.7.10.1 Overview [[range.take.overview]](range.take.overview)

#### 25.7.10.2 Class template take_view [[range.take.view]](range.take.view)

#### 25.7.10.3 Class template take_view​::​*sentinel* [[range.take.sentinel]](range.take.sentinel)

#### 25.7.11 Take while view [[range.take.while]](range.take.while)

#### 25.7.11.1 Overview [[range.take.while.overview]](range.take.while.overview)

#### 25.7.11.2 Class template take_while_view [[range.take.while.view]](range.take.while.view)

#### 25.7.11.3 Class template take_while_view​::​*sentinel* [[range.take.while.sentinel]](range.take.while.sentinel)

#### 25.7.12 Drop view [[range.drop]](range.drop)

#### 25.7.12.1 Overview [[range.drop.overview]](range.drop.overview)

#### 25.7.12.2 Class template drop_view [[range.drop.view]](range.drop.view)

#### 25.7.13 Drop while view [[range.drop.while]](range.drop.while)

#### 25.7.13.1 Overview [[range.drop.while.overview]](range.drop.while.overview)

#### 25.7.13.2 Class template drop_while_view [[range.drop.while.view]](range.drop.while.view)

#### 25.7.14 Join view [[range.join]](range.join)

#### 25.7.14.1 Overview [[range.join.overview]](range.join.overview)

#### 25.7.14.2 Class template join_view [[range.join.view]](range.join.view)

#### 25.7.14.3 Class template join_view​::​*iterator* [[range.join.iterator]](range.join.iterator)

#### 25.7.14.4 Class template join_view​::​*sentinel* [[range.join.sentinel]](range.join.sentinel)

#### 25.7.15 Join with view [[range.join.with]](range.join.with)

#### 25.7.15.1 Overview [[range.join.with.overview]](range.join.with.overview)

#### 25.7.15.2 Class template join_with_view [[range.join.with.view]](range.join.with.view)

#### 25.7.15.3 Class template join_with_view​::​*iterator* [[range.join.with.iterator]](range.join.with.iterator)

#### 25.7.15.4 Class template join_with_view​::​*sentinel* [[range.join.with.sentinel]](range.join.with.sentinel)

#### 25.7.16 Lazy split view [[range.lazy.split]](range.lazy.split)

#### 25.7.16.1 Overview [[range.lazy.split.overview]](range.lazy.split.overview)

#### 25.7.16.2 Class template lazy_split_view [[range.lazy.split.view]](range.lazy.split.view)

#### 25.7.16.3 Class template lazy_split_view​::​*outer-iterator* [[range.lazy.split.outer]](range.lazy.split.outer)

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

#### 25.7.16.5 Class template lazy_split_view​::​*inner-iterator* [[range.lazy.split.inner]](range.lazy.split.inner)

#### 25.7.17 Split view [[range.split]](range.split)

#### 25.7.17.1 Overview [[range.split.overview]](range.split.overview)

#### 25.7.17.2 Class template split_view [[range.split.view]](range.split.view)

#### 25.7.17.3 Class split_view​::​*iterator* [[range.split.iterator]](range.split.iterator)

#### 25.7.17.4 Class split_view​::​*sentinel* [[range.split.sentinel]](range.split.sentinel)

#### 25.7.18 Concat view [[range.concat]](range.concat)

#### 25.7.18.1 Overview [[range.concat.overview]](range.concat.overview)

#### 25.7.18.2 Class template concat_view [[range.concat.view]](range.concat.view)

#### 25.7.18.3 Class concat_view​::​*iterator* [[range.concat.iterator]](range.concat.iterator)

#### 25.7.19 Counted view [[range.counted]](range.counted)

#### 25.7.20 Common view [[range.common]](range.common)

#### 25.7.20.1 Overview [[range.common.overview]](range.common.overview)

#### 25.7.20.2 Class template common_view [[range.common.view]](range.common.view)

#### 25.7.21 Reverse view [[range.reverse]](range.reverse)

#### 25.7.21.1 Overview [[range.reverse.overview]](range.reverse.overview)

#### 25.7.21.2 Class template reverse_view [[range.reverse.view]](range.reverse.view)

#### 25.7.22 As const view [[range.as.const]](range.as.const)

#### 25.7.22.1 Overview [[range.as.const.overview]](range.as.const.overview)

#### 25.7.22.2 Class template as_const_view [[range.as.const.view]](range.as.const.view)

#### 25.7.23 Elements view [[range.elements]](range.elements)

#### 25.7.23.1 Overview [[range.elements.overview]](range.elements.overview)

#### 25.7.23.2 Class template elements_view [[range.elements.view]](range.elements.view)

#### 25.7.23.3 Class template elements_view​::​*iterator* [[range.elements.iterator]](range.elements.iterator)

#### 25.7.23.4 Class template elements_view​::​*sentinel* [[range.elements.sentinel]](range.elements.sentinel)

#### 25.7.24 Enumerate view [[range.enumerate]](range.enumerate)

#### 25.7.24.1 Overview [[range.enumerate.overview]](range.enumerate.overview)

#### 25.7.24.2 Class template enumerate_view [[range.enumerate.view]](range.enumerate.view)

#### 25.7.24.3 Class template enumerate_view​::​*iterator* [[range.enumerate.iterator]](range.enumerate.iterator)

#### 25.7.24.4 Class template enumerate_view​::​*sentinel* [[range.enumerate.sentinel]](range.enumerate.sentinel)

#### 25.7.25 Zip view [[range.zip]](range.zip)

#### 25.7.25.1 Overview [[range.zip.overview]](range.zip.overview)

#### 25.7.25.2 Class template zip_view [[range.zip.view]](range.zip.view)

#### 25.7.25.3 Class template zip_view​::​*iterator* [[range.zip.iterator]](range.zip.iterator)

#### 25.7.25.4 Class template zip_view​::​*sentinel* [[range.zip.sentinel]](range.zip.sentinel)

#### 25.7.26 Zip transform view [[range.zip.transform]](range.zip.transform)

#### 25.7.26.1 Overview [[range.zip.transform.overview]](range.zip.transform.overview)

#### 25.7.26.2 Class template zip_transform_view [[range.zip.transform.view]](range.zip.transform.view)

#### 25.7.26.3 Class template zip_transform_view​::​*iterator* [[range.zip.transform.iterator]](range.zip.transform.iterator)

#### 25.7.26.4 Class template zip_transform_view​::​*sentinel* [[range.zip.transform.sentinel]](range.zip.transform.sentinel)

#### 25.7.27 Adjacent view [[range.adjacent]](range.adjacent)

#### 25.7.27.1 Overview [[range.adjacent.overview]](range.adjacent.overview)

#### 25.7.27.2 Class template adjacent_view [[range.adjacent.view]](range.adjacent.view)

#### 25.7.27.3 Class template adjacent_view​::​*iterator* [[range.adjacent.iterator]](range.adjacent.iterator)

#### 25.7.27.4 Class template adjacent_view​::​*sentinel* [[range.adjacent.sentinel]](range.adjacent.sentinel)

#### 25.7.28 Adjacent transform view [[range.adjacent.transform]](range.adjacent.transform)

#### 25.7.28.1 Overview [[range.adjacent.transform.overview]](range.adjacent.transform.overview)

#### 25.7.28.2 Class template adjacent_transform_view [[range.adjacent.transform.view]](range.adjacent.transform.view)

#### 25.7.28.3 Class template adjacent_transform_view​::​*iterator* [[range.adjacent.transform.iterator]](range.adjacent.transform.iterator)

#### 25.7.28.4 Class template adjacent_transform_view​::​*sentinel* [[range.adjacent.transform.sentinel]](range.adjacent.transform.sentinel)

#### 25.7.29 Chunk view [[range.chunk]](range.chunk)

#### 25.7.29.1 Overview [[range.chunk.overview]](range.chunk.overview)

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

#### 25.7.29.3 Class chunk_view​::​*outer-iterator* [[range.chunk.outer.iter]](range.chunk.outer.iter)

#### 25.7.29.4 Class chunk_view​::​*outer-iterator*​::​value_type [[range.chunk.outer.value]](range.chunk.outer.value)

#### 25.7.29.5 Class chunk_view​::​*inner-iterator* [[range.chunk.inner.iter]](range.chunk.inner.iter)

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

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

#### 25.7.30 Slide view [[range.slide]](range.slide)

#### 25.7.30.1 Overview [[range.slide.overview]](range.slide.overview)

#### 25.7.30.2 Class template slide_view [[range.slide.view]](range.slide.view)

#### 25.7.30.3 Class template slide_view​::​*iterator* [[range.slide.iterator]](range.slide.iterator)

#### 25.7.30.4 Class slide_view​::​*sentinel* [[range.slide.sentinel]](range.slide.sentinel)

#### 25.7.31 Chunk by view [[range.chunk.by]](range.chunk.by)

#### 25.7.31.1 Overview [[range.chunk.by.overview]](range.chunk.by.overview)

#### 25.7.31.2 Class template chunk_by_view [[range.chunk.by.view]](range.chunk.by.view)

#### 25.7.31.3 Class chunk_by_view​::​*iterator* [[range.chunk.by.iter]](range.chunk.by.iter)

#### 25.7.32 Stride view [[range.stride]](range.stride)

#### 25.7.32.1 Overview [[range.stride.overview]](range.stride.overview)

#### 25.7.32.2 Class template stride_view [[range.stride.view]](range.stride.view)

#### 25.7.32.3 Class template stride_view​::​*iterator* [[range.stride.iterator]](range.stride.iterator)

#### 25.7.33 Cartesian product view [[range.cartesian]](range.cartesian)

#### 25.7.33.1 Overview [[range.cartesian.overview]](range.cartesian.overview)

#### 25.7.33.2 Class template cartesian_product_view [[range.cartesian.view]](range.cartesian.view)

#### 25.7.33.3 Class template cartesian_product_view​::​*iterator* [[range.cartesian.iterator]](range.cartesian.iterator)

#### 25.7.34 Cache latest view [[range.cache.latest]](range.cache.latest)

#### 25.7.34.1 Overview [[range.cache.latest.overview]](range.cache.latest.overview)

#### 25.7.34.2 Class template cache_latest_view [[range.cache.latest.view]](range.cache.latest.view)

#### 25.7.34.3 Class cache_latest_view​::​*iterator* [[range.cache.latest.iterator]](range.cache.latest.iterator)

#### 25.7.34.4 Class cache_latest_view​::​*sentinel* [[range.cache.latest.sentinel]](range.cache.latest.sentinel)

#### 25.7.35 To input view [[range.to.input]](range.to.input)

#### 25.7.35.1 Overview [[range.to.input.overview]](range.to.input.overview)

#### 25.7.35.2 Class template to_input_view [[range.to.input.view]](range.to.input.view)

#### 25.7.35.3 Class template to_input_view​::​*iterator* [[range.to.input.iterator]](range.to.input.iterator)

### 25.8 Range generators [[coro.generator]](coro.generator)

#### 25.8.1 Overview [[coroutine.generator.overview]](coroutine.generator.overview)

#### 25.8.2 Header <generator> synopsis [[generator.syn]](generator.syn)

#### 25.8.3 Class template generator [[coro.generator.class]](coro.generator.class)

#### 25.8.4 Members [[coro.generator.members]](coro.generator.members)

#### 25.8.5 Class generator​::​promise_type [[coro.generator.promise]](coro.generator.promise)

#### 25.8.6 Class generator​::​*iterator* [[coro.generator.iterator]](coro.generator.iterator)

## 26 Algorithms library [[algorithms]](#algorithms)[[algorithms]](algorithms)

### 26.1 General [[algorithms.general]](algorithms.general)

### 26.2 Algorithms requirements [[algorithms.requirements]](algorithms.requirements)

### 26.3 Parallel algorithms [[algorithms.parallel]](algorithms.parallel)

#### 26.3.1 Preamble [[algorithms.parallel.defns]](algorithms.parallel.defns)

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

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

#### 26.3.4 Parallel algorithm exceptions [[algorithms.parallel.exceptions]](algorithms.parallel.exceptions)

#### 26.3.5 Parallel algorithm overloads [[algorithms.parallel.overloads]](algorithms.parallel.overloads)

#### 26.3.6 Execution policies [[execpol]](execpol)

#### 26.3.6.1 General [[execpol.general]](execpol.general)

#### 26.3.6.2 Execution policy type trait [[execpol.type]](execpol.type)

#### 26.3.6.3 Sequenced execution policy [[execpol.seq]](execpol.seq)

#### 26.3.6.4 Parallel execution policy [[execpol.par]](execpol.par)

#### 26.3.6.5 Parallel and unsequenced execution policy [[execpol.parunseq]](execpol.parunseq)

#### 26.3.6.6 Unsequenced execution policy [[execpol.unseq]](execpol.unseq)

#### 26.3.6.7 Execution policy objects [[execpol.objects]](execpol.objects)

### 26.4 Header <algorithm> synopsis [[algorithm.syn]](algorithm.syn)

### 26.5 Algorithm result types [[algorithms.results]](algorithms.results)

### 26.6 Non-modifying sequence operations [[alg.nonmodifying]](alg.nonmodifying)

#### 26.6.1 All of [[alg.all.of]](alg.all.of)

#### 26.6.2 Any of [[alg.any.of]](alg.any.of)

#### 26.6.3 None of [[alg.none.of]](alg.none.of)

#### 26.6.4 Contains [[alg.contains]](alg.contains)

#### 26.6.5 For each [[alg.foreach]](alg.foreach)

#### 26.6.6 Find [[alg.find]](alg.find)

#### 26.6.7 Find last [[alg.find.last]](alg.find.last)

#### 26.6.8 Find end [[alg.find.end]](alg.find.end)

#### 26.6.9 Find first [[alg.find.first.of]](alg.find.first.of)

#### 26.6.10 Adjacent find [[alg.adjacent.find]](alg.adjacent.find)

#### 26.6.11 Count [[alg.count]](alg.count)

#### 26.6.12 Mismatch [[alg.mismatch]](alg.mismatch)

#### 26.6.13 Equal [[alg.equal]](alg.equal)

#### 26.6.14 Is permutation [[alg.is.permutation]](alg.is.permutation)

#### 26.6.15 Search [[alg.search]](alg.search)

#### 26.6.16 Starts with [[alg.starts.with]](alg.starts.with)

#### 26.6.17 Ends with [[alg.ends.with]](alg.ends.with)

#### 26.6.18 Fold [[alg.fold]](alg.fold)

### 26.7 Mutating sequence operations [[alg.modifying.operations]](alg.modifying.operations)

#### 26.7.1 Copy [[alg.copy]](alg.copy)

#### 26.7.2 Move [[alg.move]](alg.move)

#### 26.7.3 Swap [[alg.swap]](alg.swap)

#### 26.7.4 Transform [[alg.transform]](alg.transform)

#### 26.7.5 Replace [[alg.replace]](alg.replace)

#### 26.7.6 Fill [[alg.fill]](alg.fill)

#### 26.7.7 Generate [[alg.generate]](alg.generate)

#### 26.7.8 Remove [[alg.remove]](alg.remove)

#### 26.7.9 Unique [[alg.unique]](alg.unique)

#### 26.7.10 Reverse [[alg.reverse]](alg.reverse)

#### 26.7.11 Rotate [[alg.rotate]](alg.rotate)

#### 26.7.12 Sample [[alg.random.sample]](alg.random.sample)

#### 26.7.13 Shuffle [[alg.random.shuffle]](alg.random.shuffle)

#### 26.7.14 Shift [[alg.shift]](alg.shift)

### 26.8 Sorting and related operations [[alg.sorting]](alg.sorting)

#### 26.8.1 General [[alg.sorting.general]](alg.sorting.general)

#### 26.8.2 Sorting [[alg.sort]](alg.sort)

#### 26.8.2.1 sort [[sort]](sort)

#### 26.8.2.2 stable_sort [[stable.sort]](stable.sort)

#### 26.8.2.3 partial_sort [[partial.sort]](partial.sort)

#### 26.8.2.4 partial_sort_copy [[partial.sort.copy]](partial.sort.copy)

#### 26.8.2.5 is_sorted [[is.sorted]](is.sorted)

#### 26.8.3 Nth element [[alg.nth.element]](alg.nth.element)

#### 26.8.4 Binary search [[alg.binary.search]](alg.binary.search)

#### 26.8.4.1 General [[alg.binary.search.general]](alg.binary.search.general)

#### 26.8.4.2 lower_bound [[lower.bound]](lower.bound)

#### 26.8.4.3 upper_bound [[upper.bound]](upper.bound)

#### 26.8.4.4 equal_range [[equal.range]](equal.range)

#### 26.8.4.5 binary_search [[binary.search]](binary.search)

#### 26.8.5 Partitions [[alg.partitions]](alg.partitions)

#### 26.8.6 Merge [[alg.merge]](alg.merge)

#### 26.8.7 Set operations on sorted structures [[alg.set.operations]](alg.set.operations)

#### 26.8.7.1 General [[alg.set.operations.general]](alg.set.operations.general)

#### 26.8.7.2 includes [[includes]](includes)

#### 26.8.7.3 set_union [[set.union]](set.union)

#### 26.8.7.4 set_intersection [[set.intersection]](set.intersection)

#### 26.8.7.5 set_difference [[set.difference]](set.difference)

#### 26.8.7.6 set_symmetric_difference [[set.symmetric.difference]](set.symmetric.difference)

#### 26.8.8 Heap operations [[alg.heap.operations]](alg.heap.operations)

#### 26.8.8.1 General [[alg.heap.operations.general]](alg.heap.operations.general)

#### 26.8.8.2 push_heap [[push.heap]](push.heap)

#### 26.8.8.3 pop_heap [[pop.heap]](pop.heap)

#### 26.8.8.4 make_heap [[make.heap]](make.heap)

#### 26.8.8.5 sort_heap [[sort.heap]](sort.heap)

#### 26.8.8.6 is_heap [[is.heap]](is.heap)

#### 26.8.9 Minimum and maximum [[alg.min.max]](alg.min.max)

#### 26.8.10 Bounded value [[alg.clamp]](alg.clamp)

#### 26.8.11 Lexicographical comparison [[alg.lex.comparison]](alg.lex.comparison)

#### 26.8.12 Three-way comparison algorithms [[alg.three.way]](alg.three.way)

#### 26.8.13 Permutation generators [[alg.permutation.generators]](alg.permutation.generators)

### 26.9 Header <numeric> synopsis [[numeric.ops.overview]](numeric.ops.overview)

### 26.10 Generalized numeric operations [[numeric.ops]](numeric.ops)

#### 26.10.1 General [[numeric.ops.general]](numeric.ops.general)

#### 26.10.2 Definitions [[numerics.defns]](numerics.defns)

#### 26.10.3 Accumulate [[accumulate]](accumulate)

#### 26.10.4 Reduce [[reduce]](reduce)

#### 26.10.5 Inner product [[inner.product]](inner.product)

#### 26.10.6 Transform reduce [[transform.reduce]](transform.reduce)

#### 26.10.7 Partial sum [[partial.sum]](partial.sum)

#### 26.10.8 Exclusive scan [[exclusive.scan]](exclusive.scan)

#### 26.10.9 Inclusive scan [[inclusive.scan]](inclusive.scan)

#### 26.10.10 Transform exclusive scan [[transform.exclusive.scan]](transform.exclusive.scan)

#### 26.10.11 Transform inclusive scan [[transform.inclusive.scan]](transform.inclusive.scan)

#### 26.10.12 Adjacent difference [[adjacent.difference]](adjacent.difference)

#### 26.10.13 Iota [[numeric.iota]](numeric.iota)

#### 26.10.14 Greatest common divisor [[numeric.ops.gcd]](numeric.ops.gcd)

#### 26.10.15 Least common multiple [[numeric.ops.lcm]](numeric.ops.lcm)

#### 26.10.16 Midpoint [[numeric.ops.midpoint]](numeric.ops.midpoint)

#### 26.10.17 Saturation arithmetic [[numeric.sat]](numeric.sat)

#### 26.10.17.1 Arithmetic functions [[numeric.sat.func]](numeric.sat.func)

#### 26.10.17.2 Casting [[numeric.sat.cast]](numeric.sat.cast)

### 26.11 Specialized <memory> algorithms [[specialized.algorithms]](specialized.algorithms)

#### 26.11.1 General [[specialized.algorithms.general]](specialized.algorithms.general)

#### 26.11.2 Special memory concepts [[special.mem.concepts]](special.mem.concepts)

#### 26.11.3 uninitialized_default_construct [[uninitialized.construct.default]](uninitialized.construct.default)

#### 26.11.4 uninitialized_value_construct [[uninitialized.construct.value]](uninitialized.construct.value)

#### 26.11.5 uninitialized_copy [[uninitialized.copy]](uninitialized.copy)

#### 26.11.6 uninitialized_move [[uninitialized.move]](uninitialized.move)

#### 26.11.7 uninitialized_fill [[uninitialized.fill]](uninitialized.fill)

#### 26.11.8 construct_at [[specialized.construct]](specialized.construct)

#### 26.11.9 destroy [[specialized.destroy]](specialized.destroy)

### 26.12 Specialized <random> algorithms [[alg.rand]](alg.rand)

#### 26.12.1 General [[alg.rand.general]](alg.rand.general)

#### 26.12.2 generate_random [[alg.rand.generate]](alg.rand.generate)

### 26.13 C library algorithms [[alg.c.library]](alg.c.library)

## 27 Strings library [[strings]](#strings)[[strings]](strings)

### 27.1 General [[strings.general]](strings.general)

### 27.2 Character traits [[char.traits]](char.traits)

#### 27.2.1 General [[char.traits.general]](char.traits.general)

#### 27.2.2 Character traits requirements [[char.traits.require]](char.traits.require)

#### 27.2.3 Traits typedefs [[char.traits.typedefs]](char.traits.typedefs)

#### 27.2.4 char_traits specializations [[char.traits.specializations]](char.traits.specializations)

#### 27.2.4.1 General [[char.traits.specializations.general]](char.traits.specializations.general)

#### 27.2.4.2 struct char_traits<char> [[char.traits.specializations.char]](char.traits.specializations.char)

#### 27.2.4.3 struct char_traits<char8_t> [[char.traits.specializations.char8.t]](char.traits.specializations.char8.t)

#### 27.2.4.4 struct char_traits<char16_t> [[char.traits.specializations.char16.t]](char.traits.specializations.char16.t)

#### 27.2.4.5 struct char_traits<char32_t> [[char.traits.specializations.char32.t]](char.traits.specializations.char32.t)

#### 27.2.4.6 struct char_traits<wchar_t> [[char.traits.specializations.wchar.t]](char.traits.specializations.wchar.t)

### 27.3 String view classes [[string.view]](string.view)

#### 27.3.1 General [[string.view.general]](string.view.general)

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

#### 27.3.3 Class template basic_string_view [[string.view.template]](string.view.template)

#### 27.3.3.1 General [[string.view.template.general]](string.view.template.general)

#### 27.3.3.2 Construction and assignment [[string.view.cons]](string.view.cons)

#### 27.3.3.3 Deduction guides [[string.view.deduct]](string.view.deduct)

#### 27.3.3.4 Iterator support [[string.view.iterators]](string.view.iterators)

#### 27.3.3.5 Capacity [[string.view.capacity]](string.view.capacity)

#### 27.3.3.6 Element access [[string.view.access]](string.view.access)

#### 27.3.3.7 Modifiers [[string.view.modifiers]](string.view.modifiers)

#### 27.3.3.8 String operations [[string.view.ops]](string.view.ops)

#### 27.3.3.9 Searching [[string.view.find]](string.view.find)

#### 27.3.4 Non-member comparison functions [[string.view.comparison]](string.view.comparison)

#### 27.3.5 Inserters and extractors [[string.view.io]](string.view.io)

#### 27.3.6 Hash support [[string.view.hash]](string.view.hash)

#### 27.3.7 Suffix for basic_string_view literals [[string.view.literals]](string.view.literals)

### 27.4 String classes [[string.classes]](string.classes)

#### 27.4.1 General [[string.classes.general]](string.classes.general)

#### 27.4.2 Header <string> synopsis [[string.syn]](string.syn)

#### 27.4.3 Class template basic_string [[basic.string]](basic.string)

#### 27.4.3.1 General [[basic.string.general]](basic.string.general)

#### 27.4.3.2 General requirements [[string.require]](string.require)

#### 27.4.3.3 Constructors and assignment operators [[string.cons]](string.cons)

#### 27.4.3.4 Iterator support [[string.iterators]](string.iterators)

#### 27.4.3.5 Capacity [[string.capacity]](string.capacity)

#### 27.4.3.6 Element access [[string.access]](string.access)

#### 27.4.3.7 Modifiers [[string.modifiers]](string.modifiers)

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

#### 27.4.3.7.2 basic_string​::​append [[string.append]](string.append)

#### 27.4.3.7.3 basic_string​::​assign [[string.assign]](string.assign)

#### 27.4.3.7.4 basic_string​::​insert [[string.insert]](string.insert)

#### 27.4.3.7.5 basic_string​::​erase [[string.erase]](string.erase)

#### 27.4.3.7.6 basic_string​::​replace [[string.replace]](string.replace)

#### 27.4.3.7.7 basic_string​::​copy [[string.copy]](string.copy)

#### 27.4.3.7.8 basic_string​::​swap [[string.swap]](string.swap)

#### 27.4.3.8 String operations [[string.ops]](string.ops)

#### 27.4.3.8.1 Accessors [[string.accessors]](string.accessors)

#### 27.4.3.8.2 Searching [[string.find]](string.find)

#### 27.4.3.8.3 basic_string​::​substr [[string.substr]](string.substr)

#### 27.4.3.8.4 basic_string​::​compare [[string.compare]](string.compare)

#### 27.4.3.8.5 basic_string​::​starts_with [[string.starts.with]](string.starts.with)

#### 27.4.3.8.6 basic_string​::​ends_with [[string.ends.with]](string.ends.with)

#### 27.4.3.8.7 basic_string​::​contains [[string.contains]](string.contains)

#### 27.4.4 Non-member functions [[string.nonmembers]](string.nonmembers)

#### 27.4.4.1 operator+ [[string.op.plus]](string.op.plus)

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

#### 27.4.4.3 swap [[string.special]](string.special)

#### 27.4.4.4 Inserters and extractors [[string.io]](string.io)

#### 27.4.4.5 Erasure [[string.erasure]](string.erasure)

#### 27.4.5 Numeric conversions [[string.conversions]](string.conversions)

#### 27.4.6 Hash support [[basic.string.hash]](basic.string.hash)

#### 27.4.7 Suffix for basic_string literals [[basic.string.literals]](basic.string.literals)

### 27.5 Null-terminated sequence utilities [[c.strings]](c.strings)

#### 27.5.1 Header <cstring> synopsis [[cstring.syn]](cstring.syn)

## 28 Text processing library [[text]](#text)[[text]](text)

### 28.1 General [[text.general]](text.general)

### 28.2 Primitive numeric conversions [[charconv]](charconv)

#### 28.2.1 Header <charconv> synopsis [[charconv.syn]](charconv.syn)

#### 28.2.2 Primitive numeric output conversion [[charconv.to.chars]](charconv.to.chars)

#### 28.2.3 Primitive numeric input conversion [[charconv.from.chars]](charconv.from.chars)

### 28.3 Localization library [[localization]](localization)

#### 28.3.1 General [[localization.general]](localization.general)

#### 28.3.2 Header <locale> synopsis [[locale.syn]](locale.syn)

#### 28.3.3 Locales [[locales]](locales)

#### 28.3.3.1 Class locale [[locale]](locale)

#### 28.3.3.1.1 General [[locale.general]](locale.general)

#### 28.3.3.1.2 Types [[locale.types]](locale.types)

#### 28.3.3.1.2.1 Type locale​::​category [[locale.category]](locale.category)

#### 28.3.3.1.2.2 Class locale​::​facet [[locale.facet]](locale.facet)

#### 28.3.3.1.2.3 Class locale​::​id [[locale.id]](locale.id)

#### 28.3.3.1.3 Constructors and destructor [[locale.cons]](locale.cons)

#### 28.3.3.1.4 Members [[locale.members]](locale.members)

#### 28.3.3.1.5 Operators [[locale.operators]](locale.operators)

#### 28.3.3.1.6 Static members [[locale.statics]](locale.statics)

#### 28.3.3.2 locale globals [[locale.global.templates]](locale.global.templates)

#### 28.3.3.3 Convenience interfaces [[locale.convenience]](locale.convenience)

#### 28.3.3.3.1 Character classification [[classification]](classification)

#### 28.3.3.3.2 Character conversions [[conversions.character]](conversions.character)

#### 28.3.4 Standard locale categories [[locale.categories]](locale.categories)

#### 28.3.4.1 General [[locale.categories.general]](locale.categories.general)

#### 28.3.4.2 The ctype category [[category.ctype]](category.ctype)

#### 28.3.4.2.1 General [[category.ctype.general]](category.ctype.general)

#### 28.3.4.2.2 Class template ctype [[locale.ctype]](locale.ctype)

#### 28.3.4.2.2.1 General [[locale.ctype.general]](locale.ctype.general)

#### 28.3.4.2.2.2 ctype members [[locale.ctype.members]](locale.ctype.members)

#### 28.3.4.2.2.3 ctype virtual functions [[locale.ctype.virtuals]](locale.ctype.virtuals)

#### 28.3.4.2.3 Class template ctype_byname [[locale.ctype.byname]](locale.ctype.byname)

#### 28.3.4.2.4 ctype<char> specialization [[facet.ctype.special]](facet.ctype.special)

#### 28.3.4.2.4.1 General [[facet.ctype.special.general]](facet.ctype.special.general)

#### 28.3.4.2.4.2 Destructor [[facet.ctype.char.dtor]](facet.ctype.char.dtor)

#### 28.3.4.2.4.3 Members [[facet.ctype.char.members]](facet.ctype.char.members)

#### 28.3.4.2.4.4 Static members [[facet.ctype.char.statics]](facet.ctype.char.statics)

#### 28.3.4.2.4.5 Virtual functions [[facet.ctype.char.virtuals]](facet.ctype.char.virtuals)

#### 28.3.4.2.5 Class template codecvt [[locale.codecvt]](locale.codecvt)

#### 28.3.4.2.5.1 General [[locale.codecvt.general]](locale.codecvt.general)

#### 28.3.4.2.5.2 Members [[locale.codecvt.members]](locale.codecvt.members)

#### 28.3.4.2.5.3 Virtual functions [[locale.codecvt.virtuals]](locale.codecvt.virtuals)

#### 28.3.4.2.6 Class template codecvt_byname [[locale.codecvt.byname]](locale.codecvt.byname)

#### 28.3.4.3 The numeric category [[category.numeric]](category.numeric)

#### 28.3.4.3.1 General [[category.numeric.general]](category.numeric.general)

#### 28.3.4.3.2 Class template num_get [[locale.num.get]](locale.num.get)

#### 28.3.4.3.2.1 General [[locale.num.get.general]](locale.num.get.general)

#### 28.3.4.3.2.2 Members [[facet.num.get.members]](facet.num.get.members)

#### 28.3.4.3.2.3 Virtual functions [[facet.num.get.virtuals]](facet.num.get.virtuals)

#### 28.3.4.3.3 Class template num_put [[locale.nm.put]](locale.nm.put)

#### 28.3.4.3.3.1 General [[locale.nm.put.general]](locale.nm.put.general)

#### 28.3.4.3.3.2 Members [[facet.num.put.members]](facet.num.put.members)

#### 28.3.4.3.3.3 Virtual functions [[facet.num.put.virtuals]](facet.num.put.virtuals)

#### 28.3.4.4 The numeric punctuation facet [[facet.numpunct]](facet.numpunct)

#### 28.3.4.4.1 Class template numpunct [[locale.numpunct]](locale.numpunct)

#### 28.3.4.4.1.1 General [[locale.numpunct.general]](locale.numpunct.general)

#### 28.3.4.4.1.2 Members [[facet.numpunct.members]](facet.numpunct.members)

#### 28.3.4.4.1.3 Virtual functions [[facet.numpunct.virtuals]](facet.numpunct.virtuals)

#### 28.3.4.4.2 Class template numpunct_byname [[locale.numpunct.byname]](locale.numpunct.byname)

#### 28.3.4.5 The collate category [[category.collate]](category.collate)

#### 28.3.4.5.1 Class template collate [[locale.collate]](locale.collate)

#### 28.3.4.5.1.1 General [[locale.collate.general]](locale.collate.general)

#### 28.3.4.5.1.2 Members [[locale.collate.members]](locale.collate.members)

#### 28.3.4.5.1.3 Virtual functions [[locale.collate.virtuals]](locale.collate.virtuals)

#### 28.3.4.5.2 Class template collate_byname [[locale.collate.byname]](locale.collate.byname)

#### 28.3.4.6 The time category [[category.time]](category.time)

#### 28.3.4.6.1 General [[category.time.general]](category.time.general)

#### 28.3.4.6.2 Class template time_get [[locale.time.get]](locale.time.get)

#### 28.3.4.6.2.1 General [[locale.time.get.general]](locale.time.get.general)

#### 28.3.4.6.2.2 Members [[locale.time.get.members]](locale.time.get.members)

#### 28.3.4.6.2.3 Virtual functions [[locale.time.get.virtuals]](locale.time.get.virtuals)

#### 28.3.4.6.3 Class template time_get_byname [[locale.time.get.byname]](locale.time.get.byname)

#### 28.3.4.6.4 Class template time_put [[locale.time.put]](locale.time.put)

#### 28.3.4.6.4.1 General [[locale.time.put.general]](locale.time.put.general)

#### 28.3.4.6.4.2 Members [[locale.time.put.members]](locale.time.put.members)

#### 28.3.4.6.4.3 Virtual functions [[locale.time.put.virtuals]](locale.time.put.virtuals)

#### 28.3.4.6.5 Class template time_put_byname [[locale.time.put.byname]](locale.time.put.byname)

#### 28.3.4.7 The monetary category [[category.monetary]](category.monetary)

#### 28.3.4.7.1 General [[category.monetary.general]](category.monetary.general)

#### 28.3.4.7.2 Class template money_get [[locale.money.get]](locale.money.get)

#### 28.3.4.7.2.1 General [[locale.money.get.general]](locale.money.get.general)

#### 28.3.4.7.2.2 Members [[locale.money.get.members]](locale.money.get.members)

#### 28.3.4.7.2.3 Virtual functions [[locale.money.get.virtuals]](locale.money.get.virtuals)

#### 28.3.4.7.3 Class template money_put [[locale.money.put]](locale.money.put)

#### 28.3.4.7.3.1 General [[locale.money.put.general]](locale.money.put.general)

#### 28.3.4.7.3.2 Members [[locale.money.put.members]](locale.money.put.members)

#### 28.3.4.7.3.3 Virtual functions [[locale.money.put.virtuals]](locale.money.put.virtuals)

#### 28.3.4.7.4 Class template moneypunct [[locale.moneypunct]](locale.moneypunct)

#### 28.3.4.7.4.1 General [[locale.moneypunct.general]](locale.moneypunct.general)

#### 28.3.4.7.4.2 Members [[locale.moneypunct.members]](locale.moneypunct.members)

#### 28.3.4.7.4.3 Virtual functions [[locale.moneypunct.virtuals]](locale.moneypunct.virtuals)

#### 28.3.4.7.5 Class template moneypunct_byname [[locale.moneypunct.byname]](locale.moneypunct.byname)

#### 28.3.4.8 The message retrieval category [[category.messages]](category.messages)

#### 28.3.4.8.1 General [[category.messages.general]](category.messages.general)

#### 28.3.4.8.2 Class template messages [[locale.messages]](locale.messages)

#### 28.3.4.8.2.1 General [[locale.messages.general]](locale.messages.general)

#### 28.3.4.8.2.2 Members [[locale.messages.members]](locale.messages.members)

#### 28.3.4.8.2.3 Virtual functions [[locale.messages.virtuals]](locale.messages.virtuals)

#### 28.3.4.8.3 Class template messages_byname [[locale.messages.byname]](locale.messages.byname)

#### 28.3.5 C library locales [[c.locales]](c.locales)

#### 28.3.5.1 Header <clocale> synopsis [[clocale.syn]](clocale.syn)

#### 28.3.5.2 Data races [[clocale.data.races]](clocale.data.races)

### 28.4 Text encodings identification [[text.encoding]](text.encoding)

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

#### 28.4.2 Class text_encoding [[text.encoding.class]](text.encoding.class)

#### 28.4.2.1 Overview [[text.encoding.overview]](text.encoding.overview)

#### 28.4.2.2 General [[text.encoding.general]](text.encoding.general)

#### 28.4.2.3 Members [[text.encoding.members]](text.encoding.members)

#### 28.4.2.4 Comparison functions [[text.encoding.cmp]](text.encoding.cmp)

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

#### 28.4.2.6 Enumeration text_encoding​::​id [[text.encoding.id]](text.encoding.id)

#### 28.4.2.7 Hash support [[text.encoding.hash]](text.encoding.hash)

### 28.5 Formatting [[format]](format)

#### 28.5.1 Header <format> synopsis [[format.syn]](format.syn)

#### 28.5.2 Format string [[format.string]](format.string)

#### 28.5.2.1 General [[format.string.general]](format.string.general)

#### 28.5.2.2 Standard format specifiers [[format.string.std]](format.string.std)

#### 28.5.3 Error reporting [[format.err.report]](format.err.report)

#### 28.5.4 Class template basic_format_string [[format.fmt.string]](format.fmt.string)

#### 28.5.5 Formatting functions [[format.functions]](format.functions)

#### 28.5.6 Formatter [[format.formatter]](format.formatter)

#### 28.5.6.1 Formatter requirements [[formatter.requirements]](formatter.requirements)

#### 28.5.6.2 Formatter locking [[format.formatter.locking]](format.formatter.locking)

#### 28.5.6.3 Concept formattable [[format.formattable]](format.formattable)

#### 28.5.6.4 Formatter specializations [[format.formatter.spec]](format.formatter.spec)

#### 28.5.6.5 Formatting escaped characters and strings [[format.string.escaped]](format.string.escaped)

#### 28.5.6.6 Class template basic_format_parse_context [[format.parse.ctx]](format.parse.ctx)

#### 28.5.6.7 Class template basic_format_context [[format.context]](format.context)

#### 28.5.7 Formatting of ranges [[format.range]](format.range)

#### 28.5.7.1 Variable template format_kind [[format.range.fmtkind]](format.range.fmtkind)

#### 28.5.7.2 Class template range_formatter [[format.range.formatter]](format.range.formatter)

#### 28.5.7.3 Class template *range-default-formatter* [[format.range.fmtdef]](format.range.fmtdef)

#### 28.5.7.4 Specialization of *range-default-formatter* for maps [[format.range.fmtmap]](format.range.fmtmap)

#### 28.5.7.5 Specialization of *range-default-formatter* for sets [[format.range.fmtset]](format.range.fmtset)

#### 28.5.7.6 Specialization of *range-default-formatter* for strings [[format.range.fmtstr]](format.range.fmtstr)

#### 28.5.8 Arguments [[format.arguments]](format.arguments)

#### 28.5.8.1 Class template basic_format_arg [[format.arg]](format.arg)

#### 28.5.8.2 Class template *format-arg-store* [[format.arg.store]](format.arg.store)

#### 28.5.8.3 Class template basic_format_args [[format.args]](format.args)

#### 28.5.9 Tuple formatter [[format.tuple]](format.tuple)

#### 28.5.10 Class format_error [[format.error]](format.error)

### 28.6 Regular expressions library [[re]](re)

#### 28.6.1 General [[re.general]](re.general)

#### 28.6.2 Requirements [[re.req]](re.req)

#### 28.6.3 Header <regex> synopsis [[re.syn]](re.syn)

#### 28.6.4 Namespace std​::​regex_constants [[re.const]](re.const)

#### 28.6.4.1 General [[re.const.general]](re.const.general)

#### 28.6.4.2 Bitmask type syntax_option_type [[re.synopt]](re.synopt)

#### 28.6.4.3 Bitmask type match_flag_type [[re.matchflag]](re.matchflag)

#### 28.6.4.4 Implementation-defined error_type [[re.err]](re.err)

#### 28.6.5 Class regex_error [[re.badexp]](re.badexp)

#### 28.6.6 Class template regex_traits [[re.traits]](re.traits)

#### 28.6.7 Class template basic_regex [[re.regex]](re.regex)

#### 28.6.7.1 General [[re.regex.general]](re.regex.general)

#### 28.6.7.2 Constructors [[re.regex.construct]](re.regex.construct)

#### 28.6.7.3 Assignment [[re.regex.assign]](re.regex.assign)

#### 28.6.7.4 Constant operations [[re.regex.operations]](re.regex.operations)

#### 28.6.7.5 Locale [[re.regex.locale]](re.regex.locale)

#### 28.6.7.6 Swap [[re.regex.swap]](re.regex.swap)

#### 28.6.7.7 Non-member functions [[re.regex.nonmemb]](re.regex.nonmemb)

#### 28.6.8 Class template sub_match [[re.submatch]](re.submatch)

#### 28.6.8.1 General [[re.submatch.general]](re.submatch.general)

#### 28.6.8.2 Members [[re.submatch.members]](re.submatch.members)

#### 28.6.8.3 Non-member operators [[re.submatch.op]](re.submatch.op)

#### 28.6.9 Class template match_results [[re.results]](re.results)

#### 28.6.9.1 General [[re.results.general]](re.results.general)

#### 28.6.9.2 Constructors [[re.results.const]](re.results.const)

#### 28.6.9.3 State [[re.results.state]](re.results.state)

#### 28.6.9.4 Size [[re.results.size]](re.results.size)

#### 28.6.9.5 Element access [[re.results.acc]](re.results.acc)

#### 28.6.9.6 Formatting [[re.results.form]](re.results.form)

#### 28.6.9.7 Allocator [[re.results.all]](re.results.all)

#### 28.6.9.8 Swap [[re.results.swap]](re.results.swap)

#### 28.6.9.9 Non-member functions [[re.results.nonmember]](re.results.nonmember)

#### 28.6.10 Regular expression algorithms [[re.alg]](re.alg)

#### 28.6.10.1 Exceptions [[re.except]](re.except)

#### 28.6.10.2 regex_match [[re.alg.match]](re.alg.match)

#### 28.6.10.3 regex_search [[re.alg.search]](re.alg.search)

#### 28.6.10.4 regex_replace [[re.alg.replace]](re.alg.replace)

#### 28.6.11 Regular expression iterators [[re.iter]](re.iter)

#### 28.6.11.1 Class template regex_iterator [[re.regiter]](re.regiter)

#### 28.6.11.1.1 General [[re.regiter.general]](re.regiter.general)

#### 28.6.11.1.2 Constructors [[re.regiter.cnstr]](re.regiter.cnstr)

#### 28.6.11.1.3 Comparisons [[re.regiter.comp]](re.regiter.comp)

#### 28.6.11.1.4 Indirection [[re.regiter.deref]](re.regiter.deref)

#### 28.6.11.1.5 Increment [[re.regiter.incr]](re.regiter.incr)

#### 28.6.11.2 Class template regex_token_iterator [[re.tokiter]](re.tokiter)

#### 28.6.11.2.1 General [[re.tokiter.general]](re.tokiter.general)

#### 28.6.11.2.2 Constructors [[re.tokiter.cnstr]](re.tokiter.cnstr)

#### 28.6.11.2.3 Comparisons [[re.tokiter.comp]](re.tokiter.comp)

#### 28.6.11.2.4 Indirection [[re.tokiter.deref]](re.tokiter.deref)

#### 28.6.11.2.5 Increment [[re.tokiter.incr]](re.tokiter.incr)

#### 28.6.12 Modified ECMAScript regular expression grammar [[re.grammar]](re.grammar)

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

#### 28.7.1 Header <cctype> synopsis [[cctype.syn]](cctype.syn)

#### 28.7.2 Header <cwctype> synopsis [[cwctype.syn]](cwctype.syn)

#### 28.7.3 Header <cwchar> synopsis [[cwchar.syn]](cwchar.syn)

#### 28.7.4 Header <cuchar> synopsis [[cuchar.syn]](cuchar.syn)

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

## 29 Numerics library [[numerics]](#numerics)[[numerics]](numerics)

### 29.1 General [[numerics.general]](numerics.general)

### 29.2 Numeric type requirements [[numeric.requirements]](numeric.requirements)

### 29.3 The floating-point environment [[cfenv]](cfenv)

#### 29.3.1 Header <cfenv> synopsis [[cfenv.syn]](cfenv.syn)

#### 29.3.2 Threads [[cfenv.thread]](cfenv.thread)

### 29.4 Complex numbers [[complex.numbers]](complex.numbers)

#### 29.4.1 General [[complex.numbers.general]](complex.numbers.general)

#### 29.4.2 Header <complex> synopsis [[complex.syn]](complex.syn)

#### 29.4.3 Class template complex [[complex]](complex)

#### 29.4.4 Member functions [[complex.members]](complex.members)

#### 29.4.5 Member operators [[complex.member.ops]](complex.member.ops)

#### 29.4.6 Non-member operations [[complex.ops]](complex.ops)

#### 29.4.7 Value operations [[complex.value.ops]](complex.value.ops)

#### 29.4.8 Transcendentals [[complex.transcendentals]](complex.transcendentals)

#### 29.4.9 Tuple interface [[complex.tuple]](complex.tuple)

#### 29.4.10 Additional overloads [[cmplx.over]](cmplx.over)

#### 29.4.11 Suffixes for complex number literals [[complex.literals]](complex.literals)

### 29.5 Random number generation [[rand]](rand)

#### 29.5.1 General [[rand.general]](rand.general)

#### 29.5.2 Header <random> synopsis [[rand.synopsis]](rand.synopsis)

#### 29.5.3 Requirements [[rand.req]](rand.req)

#### 29.5.3.1 General requirements [[rand.req.genl]](rand.req.genl)

#### 29.5.3.2 Seed sequence requirements [[rand.req.seedseq]](rand.req.seedseq)

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

#### 29.5.3.4 Random number engine requirements [[rand.req.eng]](rand.req.eng)

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

#### 29.5.3.6 Random number distribution requirements [[rand.req.dist]](rand.req.dist)

#### 29.5.4 Random number engine class templates [[rand.eng]](rand.eng)

#### 29.5.4.1 General [[rand.eng.general]](rand.eng.general)

#### 29.5.4.2 Class template linear_congruential_engine [[rand.eng.lcong]](rand.eng.lcong)

#### 29.5.4.3 Class template mersenne_twister_engine [[rand.eng.mers]](rand.eng.mers)

#### 29.5.4.4 Class template subtract_with_carry_engine [[rand.eng.sub]](rand.eng.sub)

#### 29.5.4.5 Class template philox_engine [[rand.eng.philox]](rand.eng.philox)

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

#### 29.5.5.1 General [[rand.adapt.general]](rand.adapt.general)

#### 29.5.5.2 Class template discard_block_engine [[rand.adapt.disc]](rand.adapt.disc)

#### 29.5.5.3 Class template independent_bits_engine [[rand.adapt.ibits]](rand.adapt.ibits)

#### 29.5.5.4 Class template shuffle_order_engine [[rand.adapt.shuf]](rand.adapt.shuf)

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

#### 29.5.7 Class random_device [[rand.device]](rand.device)

#### 29.5.8 Utilities [[rand.util]](rand.util)

#### 29.5.8.1 Class seed_seq [[rand.util.seedseq]](rand.util.seedseq)

#### 29.5.8.2 Function template generate_canonical [[rand.util.canonical]](rand.util.canonical)

#### 29.5.9 Random number distribution class templates [[rand.dist]](rand.dist)

#### 29.5.9.1 General [[rand.dist.general]](rand.dist.general)

#### 29.5.9.2 Uniform distributions [[rand.dist.uni]](rand.dist.uni)

#### 29.5.9.2.1 Class template uniform_int_distribution [[rand.dist.uni.int]](rand.dist.uni.int)

#### 29.5.9.2.2 Class template uniform_real_distribution [[rand.dist.uni.real]](rand.dist.uni.real)

#### 29.5.9.3 Bernoulli distributions [[rand.dist.bern]](rand.dist.bern)

#### 29.5.9.3.1 Class bernoulli_distribution [[rand.dist.bern.bernoulli]](rand.dist.bern.bernoulli)

#### 29.5.9.3.2 Class template binomial_distribution [[rand.dist.bern.bin]](rand.dist.bern.bin)

#### 29.5.9.3.3 Class template geometric_distribution [[rand.dist.bern.geo]](rand.dist.bern.geo)

#### 29.5.9.3.4 Class template negative_binomial_distribution [[rand.dist.bern.negbin]](rand.dist.bern.negbin)

#### 29.5.9.4 Poisson distributions [[rand.dist.pois]](rand.dist.pois)

#### 29.5.9.4.1 Class template poisson_distribution [[rand.dist.pois.poisson]](rand.dist.pois.poisson)

#### 29.5.9.4.2 Class template exponential_distribution [[rand.dist.pois.exp]](rand.dist.pois.exp)

#### 29.5.9.4.3 Class template gamma_distribution [[rand.dist.pois.gamma]](rand.dist.pois.gamma)

#### 29.5.9.4.4 Class template weibull_distribution [[rand.dist.pois.weibull]](rand.dist.pois.weibull)

#### 29.5.9.4.5 Class template extreme_value_distribution [[rand.dist.pois.extreme]](rand.dist.pois.extreme)

#### 29.5.9.5 Normal distributions [[rand.dist.norm]](rand.dist.norm)

#### 29.5.9.5.1 Class template normal_distribution [[rand.dist.norm.normal]](rand.dist.norm.normal)

#### 29.5.9.5.2 Class template lognormal_distribution [[rand.dist.norm.lognormal]](rand.dist.norm.lognormal)

#### 29.5.9.5.3 Class template chi_squared_distribution [[rand.dist.norm.chisq]](rand.dist.norm.chisq)

#### 29.5.9.5.4 Class template cauchy_distribution [[rand.dist.norm.cauchy]](rand.dist.norm.cauchy)

#### 29.5.9.5.5 Class template fisher_f_distribution [[rand.dist.norm.f]](rand.dist.norm.f)

#### 29.5.9.5.6 Class template student_t_distribution [[rand.dist.norm.t]](rand.dist.norm.t)

#### 29.5.9.6 Sampling distributions [[rand.dist.samp]](rand.dist.samp)

#### 29.5.9.6.1 Class template discrete_distribution [[rand.dist.samp.discrete]](rand.dist.samp.discrete)

#### 29.5.9.6.2 Class template piecewise_constant_distribution [[rand.dist.samp.pconst]](rand.dist.samp.pconst)

#### 29.5.9.6.3 Class template piecewise_linear_distribution [[rand.dist.samp.plinear]](rand.dist.samp.plinear)

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

### 29.6 Numeric arrays [[numarray]](numarray)

#### 29.6.1 Header <valarray> synopsis [[valarray.syn]](valarray.syn)

#### 29.6.2 Class template valarray [[template.valarray]](template.valarray)

#### 29.6.2.1 Overview [[template.valarray.overview]](template.valarray.overview)

#### 29.6.2.2 Constructors [[valarray.cons]](valarray.cons)

#### 29.6.2.3 Assignment [[valarray.assign]](valarray.assign)

#### 29.6.2.4 Element access [[valarray.access]](valarray.access)

#### 29.6.2.5 Subset operations [[valarray.sub]](valarray.sub)

#### 29.6.2.6 Unary operators [[valarray.unary]](valarray.unary)

#### 29.6.2.7 Compound assignment [[valarray.cassign]](valarray.cassign)

#### 29.6.2.8 Member functions [[valarray.members]](valarray.members)

#### 29.6.3 valarray non-member operations [[valarray.nonmembers]](valarray.nonmembers)

#### 29.6.3.1 Binary operators [[valarray.binary]](valarray.binary)

#### 29.6.3.2 Logical operators [[valarray.comparison]](valarray.comparison)

#### 29.6.3.3 Transcendentals [[valarray.transcend]](valarray.transcend)

#### 29.6.3.4 Specialized algorithms [[valarray.special]](valarray.special)

#### 29.6.4 Class slice [[class.slice]](class.slice)

#### 29.6.4.1 Overview [[class.slice.overview]](class.slice.overview)

#### 29.6.4.2 Constructors [[cons.slice]](cons.slice)

#### 29.6.4.3 Access functions [[slice.access]](slice.access)

#### 29.6.4.4 Operators [[slice.ops]](slice.ops)

#### 29.6.5 Class template slice_array [[template.slice.array]](template.slice.array)

#### 29.6.5.1 Overview [[template.slice.array.overview]](template.slice.array.overview)

#### 29.6.5.2 Assignment [[slice.arr.assign]](slice.arr.assign)

#### 29.6.5.3 Compound assignment [[slice.arr.comp.assign]](slice.arr.comp.assign)

#### 29.6.5.4 Fill function [[slice.arr.fill]](slice.arr.fill)

#### 29.6.6 The gslice class [[class.gslice]](class.gslice)

#### 29.6.6.1 Overview [[class.gslice.overview]](class.gslice.overview)

#### 29.6.6.2 Constructors [[gslice.cons]](gslice.cons)

#### 29.6.6.3 Access functions [[gslice.access]](gslice.access)

#### 29.6.7 Class template gslice_array [[template.gslice.array]](template.gslice.array)

#### 29.6.7.1 Overview [[template.gslice.array.overview]](template.gslice.array.overview)

#### 29.6.7.2 Assignment [[gslice.array.assign]](gslice.array.assign)

#### 29.6.7.3 Compound assignment [[gslice.array.comp.assign]](gslice.array.comp.assign)

#### 29.6.7.4 Fill function [[gslice.array.fill]](gslice.array.fill)

#### 29.6.8 Class template mask_array [[template.mask.array]](template.mask.array)

#### 29.6.8.1 Overview [[template.mask.array.overview]](template.mask.array.overview)

#### 29.6.8.2 Assignment [[mask.array.assign]](mask.array.assign)

#### 29.6.8.3 Compound assignment [[mask.array.comp.assign]](mask.array.comp.assign)

#### 29.6.8.4 Fill function [[mask.array.fill]](mask.array.fill)

#### 29.6.9 Class template indirect_array [[template.indirect.array]](template.indirect.array)

#### 29.6.9.1 Overview [[template.indirect.array.overview]](template.indirect.array.overview)

#### 29.6.9.2 Assignment [[indirect.array.assign]](indirect.array.assign)

#### 29.6.9.3 Compound assignment [[indirect.array.comp.assign]](indirect.array.comp.assign)

#### 29.6.9.4 Fill function [[indirect.array.fill]](indirect.array.fill)

#### 29.6.10 valarray range access [[valarray.range]](valarray.range)

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

#### 29.7.1 Header <cmath> synopsis [[cmath.syn]](cmath.syn)

#### 29.7.2 Absolute values [[c.math.abs]](c.math.abs)

#### 29.7.3 Three-dimensional hypotenuse [[c.math.hypot3]](c.math.hypot3)

#### 29.7.4 Linear interpolation [[c.math.lerp]](c.math.lerp)

#### 29.7.5 Classification / comparison functions [[c.math.fpclass]](c.math.fpclass)

#### 29.7.6 Mathematical special functions [[sf.cmath]](sf.cmath)

#### 29.7.6.1 General [[sf.cmath.general]](sf.cmath.general)

#### 29.7.6.2 Associated Laguerre polynomials [[sf.cmath.assoc.laguerre]](sf.cmath.assoc.laguerre)

#### 29.7.6.3 Associated Legendre functions [[sf.cmath.assoc.legendre]](sf.cmath.assoc.legendre)

#### 29.7.6.4 Beta function [[sf.cmath.beta]](sf.cmath.beta)

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

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

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

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

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

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

#### 29.7.6.11 Cylindrical Neumann functions [[sf.cmath.cyl.neumann]](sf.cmath.cyl.neumann)

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

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

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

#### 29.7.6.15 Exponential integral [[sf.cmath.expint]](sf.cmath.expint)

#### 29.7.6.16 Hermite polynomials [[sf.cmath.hermite]](sf.cmath.hermite)

#### 29.7.6.17 Laguerre polynomials [[sf.cmath.laguerre]](sf.cmath.laguerre)

#### 29.7.6.18 Legendre polynomials [[sf.cmath.legendre]](sf.cmath.legendre)

#### 29.7.6.19 Riemann zeta function [[sf.cmath.riemann.zeta]](sf.cmath.riemann.zeta)

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

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

#### 29.7.6.22 Spherical Neumann functions [[sf.cmath.sph.neumann]](sf.cmath.sph.neumann)

### 29.8 Numbers [[numbers]](numbers)

#### 29.8.1 Header <numbers> synopsis [[numbers.syn]](numbers.syn)

#### 29.8.2 Mathematical constants [[math.constants]](math.constants)

### 29.9 Basic linear algebra algorithms [[linalg]](linalg)

#### 29.9.1 Overview [[linalg.overview]](linalg.overview)

#### 29.9.2 Header <linalg> synopsis [[linalg.syn]](linalg.syn)

#### 29.9.3 General [[linalg.general]](linalg.general)

#### 29.9.4 Requirements [[linalg.reqs]](linalg.reqs)

#### 29.9.4.1 Linear algebra value types [[linalg.reqs.val]](linalg.reqs.val)

#### 29.9.4.2 Algorithm and class requirements [[linalg.reqs.alg]](linalg.reqs.alg)

#### 29.9.5 Tag classes [[linalg.tags]](linalg.tags)

#### 29.9.5.1 Storage order tags [[linalg.tags.order]](linalg.tags.order)

#### 29.9.5.2 Triangle tags [[linalg.tags.triangle]](linalg.tags.triangle)

#### 29.9.5.3 Diagonal tags [[linalg.tags.diagonal]](linalg.tags.diagonal)

#### 29.9.6 Layouts for packed matrix types [[linalg.layout.packed]](linalg.layout.packed)

#### 29.9.6.1 Overview [[linalg.layout.packed.overview]](linalg.layout.packed.overview)

#### 29.9.6.2 Constructors [[linalg.layout.packed.cons]](linalg.layout.packed.cons)

#### 29.9.6.3 Observers [[linalg.layout.packed.obs]](linalg.layout.packed.obs)

#### 29.9.7 Exposition-only helpers [[linalg.helpers]](linalg.helpers)

#### 29.9.7.1 *abs-if-needed* [[linalg.helpers.abs]](linalg.helpers.abs)

#### 29.9.7.2 *conj-if-needed* [[linalg.helpers.conj]](linalg.helpers.conj)

#### 29.9.7.3 *real-if-needed* [[linalg.helpers.real]](linalg.helpers.real)

#### 29.9.7.4 *imag-if-needed* [[linalg.helpers.imag]](linalg.helpers.imag)

#### 29.9.7.5 Argument concepts [[linalg.helpers.concepts]](linalg.helpers.concepts)

#### 29.9.7.6 Mandates [[linalg.helpers.mandates]](linalg.helpers.mandates)

#### 29.9.7.7 Preconditions [[linalg.helpers.precond]](linalg.helpers.precond)

#### 29.9.8 Scaled in-place transformation [[linalg.scaled]](linalg.scaled)

#### 29.9.8.1 Introduction [[linalg.scaled.intro]](linalg.scaled.intro)

#### 29.9.8.2 Class template scaled_accessor [[linalg.scaled.scaledaccessor]](linalg.scaled.scaledaccessor)

#### 29.9.8.3 Function template scaled [[linalg.scaled.scaled]](linalg.scaled.scaled)

#### 29.9.9 Conjugated in-place transformation [[linalg.conj]](linalg.conj)

#### 29.9.9.1 Introduction [[linalg.conj.intro]](linalg.conj.intro)

#### 29.9.9.2 Class template conjugated_accessor [[linalg.conj.conjugatedaccessor]](linalg.conj.conjugatedaccessor)

#### 29.9.9.3 Function template conjugated [[linalg.conj.conjugated]](linalg.conj.conjugated)

#### 29.9.10 Transpose in-place transformation [[linalg.transp]](linalg.transp)

#### 29.9.10.1 Introduction [[linalg.transp.intro]](linalg.transp.intro)

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

#### 29.9.10.3 Class template layout_transpose [[linalg.transp.layout.transpose]](linalg.transp.layout.transpose)

#### 29.9.10.4 Function template transposed [[linalg.transp.transposed]](linalg.transp.transposed)

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

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

#### 29.9.13 BLAS 1 algorithms [[linalg.algs.blas1]](linalg.algs.blas1)

#### 29.9.13.1 Complexity [[linalg.algs.blas1.complexity]](linalg.algs.blas1.complexity)

#### 29.9.13.2 Givens rotations [[linalg.algs.blas1.givens]](linalg.algs.blas1.givens)

#### 29.9.13.2.1 Compute Givens rotation [[linalg.algs.blas1.givens.lartg]](linalg.algs.blas1.givens.lartg)

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

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

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

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

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

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

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

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

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

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

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

#### 29.9.13.13 One norm of a matrix [[linalg.algs.blas1.matonenorm]](linalg.algs.blas1.matonenorm)

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

#### 29.9.14 BLAS 2 algorithms [[linalg.algs.blas2]](linalg.algs.blas2)

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

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

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

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

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

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

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

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

#### 29.9.15 BLAS 3 algorithms [[linalg.algs.blas3]](linalg.algs.blas3)

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

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

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

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

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

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

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

### 29.10 Data-parallel types [[simd]](simd)

#### 29.10.1 General [[simd.general]](simd.general)

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

#### 29.10.2.1 Exposition-only helpers [[simd.expos.defn]](simd.expos.defn)

#### 29.10.2.2 simd ABI tags [[simd.expos.abi]](simd.expos.abi)

#### 29.10.3 Header <simd> synopsis [[simd.syn]](simd.syn)

#### 29.10.4 Type traits [[simd.traits]](simd.traits)

#### 29.10.5 Load and store flags [[simd.flags]](simd.flags)

#### 29.10.5.1 Class template flags overview [[simd.flags.overview]](simd.flags.overview)

#### 29.10.5.2 flags operators [[simd.flags.oper]](simd.flags.oper)

#### 29.10.6 Class template *simd-iterator* [[simd.iterator]](simd.iterator)

#### 29.10.7 Class template basic_vec [[simd.class]](simd.class)

#### 29.10.7.1 Class template basic_vec overview [[simd.overview]](simd.overview)

#### 29.10.7.2 basic_vec constructors [[simd.ctor]](simd.ctor)

#### 29.10.7.3 basic_vec subscript operator [[simd.subscr]](simd.subscr)

#### 29.10.7.4 basic_vec complex accessors [[simd.complex.access]](simd.complex.access)

#### 29.10.7.5 basic_vec unary operators [[simd.unary]](simd.unary)

#### 29.10.8 basic_vec non-member operations [[simd.nonmembers]](simd.nonmembers)

#### 29.10.8.1 basic_vec binary operators [[simd.binary]](simd.binary)

#### 29.10.8.2 basic_vec compound assignment [[simd.cassign]](simd.cassign)

#### 29.10.8.3 basic_vec compare operators [[simd.comparison]](simd.comparison)

#### 29.10.8.4 basic_vec exposition only conditional operators [[simd.cond]](simd.cond)

#### 29.10.8.5 basic_vec reductions [[simd.reductions]](simd.reductions)

#### 29.10.8.6 basic_vec load and store functions [[simd.loadstore]](simd.loadstore)

#### 29.10.8.7 vec static permute [[simd.permute.static]](simd.permute.static)

#### 29.10.8.8 vec dynamic permute [[simd.permute.dynamic]](simd.permute.dynamic)

#### 29.10.8.9 vec mask permute [[simd.permute.mask]](simd.permute.mask)

#### 29.10.8.10 simd memory permute [[simd.permute.memory]](simd.permute.memory)

#### 29.10.8.11 basic_vec and basic_mask creation [[simd.creation]](simd.creation)

#### 29.10.8.12 Algorithms [[simd.alg]](simd.alg)

#### 29.10.8.13 Mathematical functions [[simd.math]](simd.math)

#### 29.10.8.14 basic_vec bit library [[simd.bit]](simd.bit)

#### 29.10.8.15 vec complex math [[simd.complex.math]](simd.complex.math)

#### 29.10.9 Class template basic_mask [[simd.mask.class]](simd.mask.class)

#### 29.10.9.1 Class template basic_mask overview [[simd.mask.overview]](simd.mask.overview)

#### 29.10.9.2 basic_mask constructors [[simd.mask.ctor]](simd.mask.ctor)

#### 29.10.9.3 basic_mask subscript operator [[simd.mask.subscr]](simd.mask.subscr)

#### 29.10.9.4 basic_mask unary operators [[simd.mask.unary]](simd.mask.unary)

#### 29.10.9.5 basic_mask conversions [[simd.mask.conv]](simd.mask.conv)

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

#### 29.10.10.1 basic_mask binary operators [[simd.mask.binary]](simd.mask.binary)

#### 29.10.10.2 basic_mask compound assignment [[simd.mask.cassign]](simd.mask.cassign)

#### 29.10.10.3 basic_mask comparisons [[simd.mask.comparison]](simd.mask.comparison)

#### 29.10.10.4 basic_mask exposition only conditional operators [[simd.mask.cond]](simd.mask.cond)

#### 29.10.10.5 basic_mask reductions [[simd.mask.reductions]](simd.mask.reductions)

### 29.11 C compatibility [[numerics.c]](numerics.c)

#### 29.11.1 Header <stdckdint.h> synopsis [[stdckdint.h.syn]](stdckdint.h.syn)

#### 29.11.2 Checked integer operations [[numerics.c.ckdint]](numerics.c.ckdint)

## 30 Time library [[time]](#time)[[time]](time)

### 30.1 General [[time.general]](time.general)

### 30.2 Header <chrono> synopsis [[time.syn]](time.syn)

### 30.3 *Cpp17Clock* requirements [[time.clock.req]](time.clock.req)

### 30.4 Time-related traits [[time.traits]](time.traits)

#### 30.4.1 treat_as_floating_point [[time.traits.is.fp]](time.traits.is.fp)

#### 30.4.2 duration_values [[time.traits.duration.values]](time.traits.duration.values)

#### 30.4.3 Specializations of common_type [[time.traits.specializations]](time.traits.specializations)

#### 30.4.4 Class template is_clock [[time.traits.is.clock]](time.traits.is.clock)

### 30.5 Class template duration [[time.duration]](time.duration)

#### 30.5.1 General [[time.duration.general]](time.duration.general)

#### 30.5.2 Constructors [[time.duration.cons]](time.duration.cons)

#### 30.5.3 Observer [[time.duration.observer]](time.duration.observer)

#### 30.5.4 Arithmetic [[time.duration.arithmetic]](time.duration.arithmetic)

#### 30.5.5 Special values [[time.duration.special]](time.duration.special)

#### 30.5.6 Non-member arithmetic [[time.duration.nonmember]](time.duration.nonmember)

#### 30.5.7 Comparisons [[time.duration.comparisons]](time.duration.comparisons)

#### 30.5.8 Conversions [[time.duration.cast]](time.duration.cast)

#### 30.5.9 Suffixes for duration literals [[time.duration.literals]](time.duration.literals)

#### 30.5.10 Algorithms [[time.duration.alg]](time.duration.alg)

#### 30.5.11 I/O [[time.duration.io]](time.duration.io)

### 30.6 Class template time_point [[time.point]](time.point)

#### 30.6.1 General [[time.point.general]](time.point.general)

#### 30.6.2 Constructors [[time.point.cons]](time.point.cons)

#### 30.6.3 Observer [[time.point.observer]](time.point.observer)

#### 30.6.4 Arithmetic [[time.point.arithmetic]](time.point.arithmetic)

#### 30.6.5 Special values [[time.point.special]](time.point.special)

#### 30.6.6 Non-member arithmetic [[time.point.nonmember]](time.point.nonmember)

#### 30.6.7 Comparisons [[time.point.comparisons]](time.point.comparisons)

#### 30.6.8 Conversions [[time.point.cast]](time.point.cast)

### 30.7 Clocks [[time.clock]](time.clock)

#### 30.7.1 General [[time.clock.general]](time.clock.general)

#### 30.7.2 Class system_clock [[time.clock.system]](time.clock.system)

#### 30.7.2.1 Overview [[time.clock.system.overview]](time.clock.system.overview)

#### 30.7.2.2 Members [[time.clock.system.members]](time.clock.system.members)

#### 30.7.2.3 Non-member functions [[time.clock.system.nonmembers]](time.clock.system.nonmembers)

#### 30.7.3 Class utc_clock [[time.clock.utc]](time.clock.utc)

#### 30.7.3.1 Overview [[time.clock.utc.overview]](time.clock.utc.overview)

#### 30.7.3.2 Member functions [[time.clock.utc.members]](time.clock.utc.members)

#### 30.7.3.3 Non-member functions [[time.clock.utc.nonmembers]](time.clock.utc.nonmembers)

#### 30.7.4 Class tai_clock [[time.clock.tai]](time.clock.tai)

#### 30.7.4.1 Overview [[time.clock.tai.overview]](time.clock.tai.overview)

#### 30.7.4.2 Member functions [[time.clock.tai.members]](time.clock.tai.members)

#### 30.7.4.3 Non-member functions [[time.clock.tai.nonmembers]](time.clock.tai.nonmembers)

#### 30.7.5 Class gps_clock [[time.clock.gps]](time.clock.gps)

#### 30.7.5.1 Overview [[time.clock.gps.overview]](time.clock.gps.overview)

#### 30.7.5.2 Member functions [[time.clock.gps.members]](time.clock.gps.members)

#### 30.7.5.3 Non-member functions [[time.clock.gps.nonmembers]](time.clock.gps.nonmembers)

#### 30.7.6 Type file_clock [[time.clock.file]](time.clock.file)

#### 30.7.6.1 Overview [[time.clock.file.overview]](time.clock.file.overview)

#### 30.7.6.2 Member functions [[time.clock.file.members]](time.clock.file.members)

#### 30.7.6.3 Non-member functions [[time.clock.file.nonmembers]](time.clock.file.nonmembers)

#### 30.7.7 Class steady_clock [[time.clock.steady]](time.clock.steady)

#### 30.7.8 Class high_resolution_clock [[time.clock.hires]](time.clock.hires)

#### 30.7.9 Local time [[time.clock.local]](time.clock.local)

#### 30.7.10 time_point conversions [[time.clock.cast]](time.clock.cast)

#### 30.7.10.1 Class template clock_time_conversion [[time.clock.conv]](time.clock.conv)

#### 30.7.10.2 Identity conversions [[time.clock.cast.id]](time.clock.cast.id)

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

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

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

#### 30.7.10.6 Function template clock_cast [[time.clock.cast.fn]](time.clock.cast.fn)

### 30.8 The civil calendar [[time.cal]](time.cal)

#### 30.8.1 General [[time.cal.general]](time.cal.general)

#### 30.8.2 Class last_spec [[time.cal.last]](time.cal.last)

#### 30.8.3 Class day [[time.cal.day]](time.cal.day)

#### 30.8.3.1 Overview [[time.cal.day.overview]](time.cal.day.overview)

#### 30.8.3.2 Member functions [[time.cal.day.members]](time.cal.day.members)

#### 30.8.3.3 Non-member functions [[time.cal.day.nonmembers]](time.cal.day.nonmembers)

#### 30.8.4 Class month [[time.cal.month]](time.cal.month)

#### 30.8.4.1 Overview [[time.cal.month.overview]](time.cal.month.overview)

#### 30.8.4.2 Member functions [[time.cal.month.members]](time.cal.month.members)

#### 30.8.4.3 Non-member functions [[time.cal.month.nonmembers]](time.cal.month.nonmembers)

#### 30.8.5 Class year [[time.cal.year]](time.cal.year)

#### 30.8.5.1 Overview [[time.cal.year.overview]](time.cal.year.overview)

#### 30.8.5.2 Member functions [[time.cal.year.members]](time.cal.year.members)

#### 30.8.5.3 Non-member functions [[time.cal.year.nonmembers]](time.cal.year.nonmembers)

#### 30.8.6 Class weekday [[time.cal.wd]](time.cal.wd)

#### 30.8.6.1 Overview [[time.cal.wd.overview]](time.cal.wd.overview)

#### 30.8.6.2 Member functions [[time.cal.wd.members]](time.cal.wd.members)

#### 30.8.6.3 Non-member functions [[time.cal.wd.nonmembers]](time.cal.wd.nonmembers)

#### 30.8.7 Class weekday_indexed [[time.cal.wdidx]](time.cal.wdidx)

#### 30.8.7.1 Overview [[time.cal.wdidx.overview]](time.cal.wdidx.overview)

#### 30.8.7.2 Member functions [[time.cal.wdidx.members]](time.cal.wdidx.members)

#### 30.8.7.3 Non-member functions [[time.cal.wdidx.nonmembers]](time.cal.wdidx.nonmembers)

#### 30.8.8 Class weekday_last [[time.cal.wdlast]](time.cal.wdlast)

#### 30.8.8.1 Overview [[time.cal.wdlast.overview]](time.cal.wdlast.overview)

#### 30.8.8.2 Member functions [[time.cal.wdlast.members]](time.cal.wdlast.members)

#### 30.8.8.3 Non-member functions [[time.cal.wdlast.nonmembers]](time.cal.wdlast.nonmembers)

#### 30.8.9 Class month_day [[time.cal.md]](time.cal.md)

#### 30.8.9.1 Overview [[time.cal.md.overview]](time.cal.md.overview)

#### 30.8.9.2 Member functions [[time.cal.md.members]](time.cal.md.members)

#### 30.8.9.3 Non-member functions [[time.cal.md.nonmembers]](time.cal.md.nonmembers)

#### 30.8.10 Class month_day_last [[time.cal.mdlast]](time.cal.mdlast)

#### 30.8.11 Class month_weekday [[time.cal.mwd]](time.cal.mwd)

#### 30.8.11.1 Overview [[time.cal.mwd.overview]](time.cal.mwd.overview)

#### 30.8.11.2 Member functions [[time.cal.mwd.members]](time.cal.mwd.members)

#### 30.8.11.3 Non-member functions [[time.cal.mwd.nonmembers]](time.cal.mwd.nonmembers)

#### 30.8.12 Class month_weekday_last [[time.cal.mwdlast]](time.cal.mwdlast)

#### 30.8.12.1 Overview [[time.cal.mwdlast.overview]](time.cal.mwdlast.overview)

#### 30.8.12.2 Member functions [[time.cal.mwdlast.members]](time.cal.mwdlast.members)

#### 30.8.12.3 Non-member functions [[time.cal.mwdlast.nonmembers]](time.cal.mwdlast.nonmembers)

#### 30.8.13 Class year_month [[time.cal.ym]](time.cal.ym)

#### 30.8.13.1 Overview [[time.cal.ym.overview]](time.cal.ym.overview)

#### 30.8.13.2 Member functions [[time.cal.ym.members]](time.cal.ym.members)

#### 30.8.13.3 Non-member functions [[time.cal.ym.nonmembers]](time.cal.ym.nonmembers)

#### 30.8.14 Class year_month_day [[time.cal.ymd]](time.cal.ymd)

#### 30.8.14.1 Overview [[time.cal.ymd.overview]](time.cal.ymd.overview)

#### 30.8.14.2 Member functions [[time.cal.ymd.members]](time.cal.ymd.members)

#### 30.8.14.3 Non-member functions [[time.cal.ymd.nonmembers]](time.cal.ymd.nonmembers)

#### 30.8.15 Class year_month_day_last [[time.cal.ymdlast]](time.cal.ymdlast)

#### 30.8.15.1 Overview [[time.cal.ymdlast.overview]](time.cal.ymdlast.overview)

#### 30.8.15.2 Member functions [[time.cal.ymdlast.members]](time.cal.ymdlast.members)

#### 30.8.15.3 Non-member functions [[time.cal.ymdlast.nonmembers]](time.cal.ymdlast.nonmembers)

#### 30.8.16 Class year_month_weekday [[time.cal.ymwd]](time.cal.ymwd)

#### 30.8.16.1 Overview [[time.cal.ymwd.overview]](time.cal.ymwd.overview)

#### 30.8.16.2 Member functions [[time.cal.ymwd.members]](time.cal.ymwd.members)

#### 30.8.16.3 Non-member functions [[time.cal.ymwd.nonmembers]](time.cal.ymwd.nonmembers)

#### 30.8.17 Class year_month_weekday_last [[time.cal.ymwdlast]](time.cal.ymwdlast)

#### 30.8.17.1 Overview [[time.cal.ymwdlast.overview]](time.cal.ymwdlast.overview)

#### 30.8.17.2 Member functions [[time.cal.ymwdlast.members]](time.cal.ymwdlast.members)

#### 30.8.17.3 Non-member functions [[time.cal.ymwdlast.nonmembers]](time.cal.ymwdlast.nonmembers)

#### 30.8.18 Conventional syntax operators [[time.cal.operators]](time.cal.operators)

### 30.9 Class template hh_mm_ss [[time.hms]](time.hms)

#### 30.9.1 Overview [[time.hms.overview]](time.hms.overview)

#### 30.9.2 Members [[time.hms.members]](time.hms.members)

#### 30.9.3 Non-members [[time.hms.nonmembers]](time.hms.nonmembers)

### 30.10 12/24 hours functions [[time.12]](time.12)

### 30.11 Time zones [[time.zone]](time.zone)

#### 30.11.1 General [[time.zone.general]](time.zone.general)

#### 30.11.2 Time zone database [[time.zone.db]](time.zone.db)

#### 30.11.2.1 Class tzdb [[time.zone.db.tzdb]](time.zone.db.tzdb)

#### 30.11.2.2 Class tzdb_list [[time.zone.db.list]](time.zone.db.list)

#### 30.11.2.3 Time zone database access [[time.zone.db.access]](time.zone.db.access)

#### 30.11.2.4 Remote time zone database support [[time.zone.db.remote]](time.zone.db.remote)

#### 30.11.3 Exception classes [[time.zone.exception]](time.zone.exception)

#### 30.11.3.1 Class nonexistent_local_time [[time.zone.exception.nonexist]](time.zone.exception.nonexist)

#### 30.11.3.2 Class ambiguous_local_time [[time.zone.exception.ambig]](time.zone.exception.ambig)

#### 30.11.4 Information classes [[time.zone.info]](time.zone.info)

#### 30.11.4.1 Class sys_info [[time.zone.info.sys]](time.zone.info.sys)

#### 30.11.4.2 Class local_info [[time.zone.info.local]](time.zone.info.local)

#### 30.11.5 Class time_zone [[time.zone.timezone]](time.zone.timezone)

#### 30.11.5.1 Overview [[time.zone.overview]](time.zone.overview)

#### 30.11.5.2 Member functions [[time.zone.members]](time.zone.members)

#### 30.11.5.3 Non-member functions [[time.zone.nonmembers]](time.zone.nonmembers)

#### 30.11.6 Class template zoned_traits [[time.zone.zonedtraits]](time.zone.zonedtraits)

#### 30.11.7 Class template zoned_time [[time.zone.zonedtime]](time.zone.zonedtime)

#### 30.11.7.1 Overview [[time.zone.zonedtime.overview]](time.zone.zonedtime.overview)

#### 30.11.7.2 Constructors [[time.zone.zonedtime.ctor]](time.zone.zonedtime.ctor)

#### 30.11.7.3 Member functions [[time.zone.zonedtime.members]](time.zone.zonedtime.members)

#### 30.11.7.4 Non-member functions [[time.zone.zonedtime.nonmembers]](time.zone.zonedtime.nonmembers)

#### 30.11.8 Class leap_second [[time.zone.leap]](time.zone.leap)

#### 30.11.8.1 Overview [[time.zone.leap.overview]](time.zone.leap.overview)

#### 30.11.8.2 Member functions [[time.zone.leap.members]](time.zone.leap.members)

#### 30.11.8.3 Non-member functions [[time.zone.leap.nonmembers]](time.zone.leap.nonmembers)

#### 30.11.9 Class time_zone_link [[time.zone.link]](time.zone.link)

#### 30.11.9.1 Overview [[time.zone.link.overview]](time.zone.link.overview)

#### 30.11.9.2 Member functions [[time.zone.link.members]](time.zone.link.members)

#### 30.11.9.3 Non-member functions [[time.zone.link.nonmembers]](time.zone.link.nonmembers)

### 30.12 Formatting [[time.format]](time.format)

### 30.13 Parsing [[time.parse]](time.parse)

### 30.14 Hash support [[time.hash]](time.hash)

### 30.15 Header <ctime> synopsis [[ctime.syn]](ctime.syn)

## 31 Input/output library [[input.output]](#input.output)[[input.output]](input.output)

### 31.1 General [[input.output.general]](input.output.general)

### 31.2 Iostreams requirements [[iostreams.requirements]](iostreams.requirements)

#### 31.2.1 Imbue limitations [[iostream.limits.imbue]](iostream.limits.imbue)

#### 31.2.2 Types [[stream.types]](stream.types)

#### 31.2.3 Positioning type limitations [[iostreams.limits.pos]](iostreams.limits.pos)

#### 31.2.4 Thread safety [[iostreams.threadsafety]](iostreams.threadsafety)

### 31.3 Forward declarations [[iostream.forward]](iostream.forward)

#### 31.3.1 Header <iosfwd> synopsis [[iosfwd.syn]](iosfwd.syn)

#### 31.3.2 Overview [[iostream.forward.overview]](iostream.forward.overview)

### 31.4 Standard iostream objects [[iostream.objects]](iostream.objects)

#### 31.4.1 Header <iostream> synopsis [[iostream.syn]](iostream.syn)

#### 31.4.2 Overview [[iostream.objects.overview]](iostream.objects.overview)

#### 31.4.3 Narrow stream objects [[narrow.stream.objects]](narrow.stream.objects)

#### 31.4.4 Wide stream objects [[wide.stream.objects]](wide.stream.objects)

### 31.5 Iostreams base classes [[iostreams.base]](iostreams.base)

#### 31.5.1 Header <ios> synopsis [[ios.syn]](ios.syn)

#### 31.5.2 Class ios_base [[ios.base]](ios.base)

#### 31.5.2.1 General [[ios.base.general]](ios.base.general)

#### 31.5.2.2 Types [[ios.types]](ios.types)

#### 31.5.2.2.1 Class ios_base​::​failure [[ios.failure]](ios.failure)

#### 31.5.2.2.2 Type ios_base​::​fmtflags [[ios.fmtflags]](ios.fmtflags)

#### 31.5.2.2.3 Type ios_base​::​iostate [[ios.iostate]](ios.iostate)

#### 31.5.2.2.4 Type ios_base​::​openmode [[ios.openmode]](ios.openmode)

#### 31.5.2.2.5 Type ios_base​::​seekdir [[ios.seekdir]](ios.seekdir)

#### 31.5.2.2.6 Class ios_base​::​Init [[ios.init]](ios.init)

#### 31.5.2.3 State functions [[fmtflags.state]](fmtflags.state)

#### 31.5.2.4 Functions [[ios.base.locales]](ios.base.locales)

#### 31.5.2.5 Static members [[ios.members.static]](ios.members.static)

#### 31.5.2.6 Storage functions [[ios.base.storage]](ios.base.storage)

#### 31.5.2.7 Callbacks [[ios.base.callback]](ios.base.callback)

#### 31.5.2.8 Constructors and destructor [[ios.base.cons]](ios.base.cons)

#### 31.5.3 Class template fpos [[fpos]](fpos)

#### 31.5.3.1 General [[fpos.general]](fpos.general)

#### 31.5.3.2 Members [[fpos.members]](fpos.members)

#### 31.5.3.3 Requirements [[fpos.operations]](fpos.operations)

#### 31.5.4 Class template basic_ios [[ios]](ios)

#### 31.5.4.1 Overview [[ios.overview]](ios.overview)

#### 31.5.4.2 Constructors [[basic.ios.cons]](basic.ios.cons)

#### 31.5.4.3 Member functions [[basic.ios.members]](basic.ios.members)

#### 31.5.4.4 Flags functions [[iostate.flags]](iostate.flags)

#### 31.5.5 ios_base manipulators [[std.ios.manip]](std.ios.manip)

#### 31.5.5.1 fmtflags manipulators [[fmtflags.manip]](fmtflags.manip)

#### 31.5.5.2 adjustfield manipulators [[adjustfield.manip]](adjustfield.manip)

#### 31.5.5.3 basefield manipulators [[basefield.manip]](basefield.manip)

#### 31.5.5.4 floatfield manipulators [[floatfield.manip]](floatfield.manip)

#### 31.5.6 Error reporting [[error.reporting]](error.reporting)

### 31.6 Stream buffers [[stream.buffers]](stream.buffers)

#### 31.6.1 Header <streambuf> synopsis [[streambuf.syn]](streambuf.syn)

#### 31.6.2 Stream buffer requirements [[streambuf.reqts]](streambuf.reqts)

#### 31.6.3 Class template basic_streambuf [[streambuf]](streambuf)

#### 31.6.3.1 General [[streambuf.general]](streambuf.general)

#### 31.6.3.2 Constructors [[streambuf.cons]](streambuf.cons)

#### 31.6.3.3 Public member functions [[streambuf.members]](streambuf.members)

#### 31.6.3.3.1 Locales [[streambuf.locales]](streambuf.locales)

#### 31.6.3.3.2 Buffer management and positioning [[streambuf.buffer]](streambuf.buffer)

#### 31.6.3.3.3 Get area [[streambuf.pub.get]](streambuf.pub.get)

#### 31.6.3.3.4 Putback [[streambuf.pub.pback]](streambuf.pub.pback)

#### 31.6.3.3.5 Put area [[streambuf.pub.put]](streambuf.pub.put)

#### 31.6.3.4 Protected member functions [[streambuf.protected]](streambuf.protected)

#### 31.6.3.4.1 Assignment [[streambuf.assign]](streambuf.assign)

#### 31.6.3.4.2 Get area access [[streambuf.get.area]](streambuf.get.area)

#### 31.6.3.4.3 Put area access [[streambuf.put.area]](streambuf.put.area)

#### 31.6.3.5 Virtual functions [[streambuf.virtuals]](streambuf.virtuals)

#### 31.6.3.5.1 Locales [[streambuf.virt.locales]](streambuf.virt.locales)

#### 31.6.3.5.2 Buffer management and positioning [[streambuf.virt.buffer]](streambuf.virt.buffer)

#### 31.6.3.5.3 Get area [[streambuf.virt.get]](streambuf.virt.get)

#### 31.6.3.5.4 Putback [[streambuf.virt.pback]](streambuf.virt.pback)

#### 31.6.3.5.5 Put area [[streambuf.virt.put]](streambuf.virt.put)

### 31.7 Formatting and manipulators [[iostream.format]](iostream.format)

#### 31.7.1 Header <istream> synopsis [[istream.syn]](istream.syn)

#### 31.7.2 Header <ostream> synopsis [[ostream.syn]](ostream.syn)

#### 31.7.3 Header <iomanip> synopsis [[iomanip.syn]](iomanip.syn)

#### 31.7.4 Header <print> synopsis [[print.syn]](print.syn)

#### 31.7.5 Input streams [[input.streams]](input.streams)

#### 31.7.5.1 General [[input.streams.general]](input.streams.general)

#### 31.7.5.2 Class template basic_istream [[istream]](istream)

#### 31.7.5.2.1 General [[istream.general]](istream.general)

#### 31.7.5.2.2 Constructors [[istream.cons]](istream.cons)

#### 31.7.5.2.3 Assignment and swap [[istream.assign]](istream.assign)

#### 31.7.5.2.4 Class basic_istream​::​sentry [[istream.sentry]](istream.sentry)

#### 31.7.5.3 Formatted input functions [[istream.formatted]](istream.formatted)

#### 31.7.5.3.1 Common requirements [[istream.formatted.reqmts]](istream.formatted.reqmts)

#### 31.7.5.3.2 Arithmetic extractors [[istream.formatted.arithmetic]](istream.formatted.arithmetic)

#### 31.7.5.3.3 basic_istream​::​operator>> [[istream.extractors]](istream.extractors)

#### 31.7.5.4 Unformatted input functions [[istream.unformatted]](istream.unformatted)

#### 31.7.5.5 Standard basic_istream manipulators [[istream.manip]](istream.manip)

#### 31.7.5.6 Rvalue stream extraction [[istream.rvalue]](istream.rvalue)

#### 31.7.5.7 Class template basic_iostream [[iostreamclass]](iostreamclass)

#### 31.7.5.7.1 General [[iostreamclass.general]](iostreamclass.general)

#### 31.7.5.7.2 Constructors [[iostream.cons]](iostream.cons)

#### 31.7.5.7.3 Destructor [[iostream.dest]](iostream.dest)

#### 31.7.5.7.4 Assignment and swap [[iostream.assign]](iostream.assign)

#### 31.7.6 Output streams [[output.streams]](output.streams)

#### 31.7.6.1 General [[output.streams.general]](output.streams.general)

#### 31.7.6.2 Class template basic_ostream [[ostream]](ostream)

#### 31.7.6.2.1 General [[ostream.general]](ostream.general)

#### 31.7.6.2.2 Constructors [[ostream.cons]](ostream.cons)

#### 31.7.6.2.3 Assignment and swap [[ostream.assign]](ostream.assign)

#### 31.7.6.2.4 Class basic_ostream​::​sentry [[ostream.sentry]](ostream.sentry)

#### 31.7.6.2.5 Seek members [[ostream.seeks]](ostream.seeks)

#### 31.7.6.3 Formatted output functions [[ostream.formatted]](ostream.formatted)

#### 31.7.6.3.1 Common requirements [[ostream.formatted.reqmts]](ostream.formatted.reqmts)

#### 31.7.6.3.2 Arithmetic inserters [[ostream.inserters.arithmetic]](ostream.inserters.arithmetic)

#### 31.7.6.3.3 basic_ostream​::​operator<< [[ostream.inserters]](ostream.inserters)

#### 31.7.6.3.4 Character inserter function templates [[ostream.inserters.character]](ostream.inserters.character)

#### 31.7.6.3.5 Print [[ostream.formatted.print]](ostream.formatted.print)

#### 31.7.6.4 Unformatted output functions [[ostream.unformatted]](ostream.unformatted)

#### 31.7.6.5 Standard basic_ostream manipulators [[ostream.manip]](ostream.manip)

#### 31.7.6.6 Rvalue stream insertion [[ostream.rvalue]](ostream.rvalue)

#### 31.7.7 Standard manipulators [[std.manip]](std.manip)

#### 31.7.8 Extended manipulators [[ext.manip]](ext.manip)

#### 31.7.9 Quoted manipulators [[quoted.manip]](quoted.manip)

#### 31.7.10 Print functions [[print.fun]](print.fun)

### 31.8 String-based streams [[string.streams]](string.streams)

#### 31.8.1 Header <sstream> synopsis [[sstream.syn]](sstream.syn)

#### 31.8.2 Class template basic_stringbuf [[stringbuf]](stringbuf)

#### 31.8.2.1 General [[stringbuf.general]](stringbuf.general)

#### 31.8.2.2 Constructors [[stringbuf.cons]](stringbuf.cons)

#### 31.8.2.3 Assignment and swap [[stringbuf.assign]](stringbuf.assign)

#### 31.8.2.4 Member functions [[stringbuf.members]](stringbuf.members)

#### 31.8.2.5 Overridden virtual functions [[stringbuf.virtuals]](stringbuf.virtuals)

#### 31.8.3 Class template basic_istringstream [[istringstream]](istringstream)

#### 31.8.3.1 General [[istringstream.general]](istringstream.general)

#### 31.8.3.2 Constructors [[istringstream.cons]](istringstream.cons)

#### 31.8.3.3 Swap [[istringstream.swap]](istringstream.swap)

#### 31.8.3.4 Member functions [[istringstream.members]](istringstream.members)

#### 31.8.4 Class template basic_ostringstream [[ostringstream]](ostringstream)

#### 31.8.4.1 General [[ostringstream.general]](ostringstream.general)

#### 31.8.4.2 Constructors [[ostringstream.cons]](ostringstream.cons)

#### 31.8.4.3 Swap [[ostringstream.swap]](ostringstream.swap)

#### 31.8.4.4 Member functions [[ostringstream.members]](ostringstream.members)

#### 31.8.5 Class template basic_stringstream [[stringstream]](stringstream)

#### 31.8.5.1 General [[stringstream.general]](stringstream.general)

#### 31.8.5.2 Constructors [[stringstream.cons]](stringstream.cons)

#### 31.8.5.3 Swap [[stringstream.swap]](stringstream.swap)

#### 31.8.5.4 Member functions [[stringstream.members]](stringstream.members)

### 31.9 Span-based streams [[span.streams]](span.streams)

#### 31.9.1 Overview [[span.streams.overview]](span.streams.overview)

#### 31.9.2 Header <spanstream> synopsis [[spanstream.syn]](spanstream.syn)

#### 31.9.3 Class template basic_spanbuf [[spanbuf]](spanbuf)

#### 31.9.3.1 General [[spanbuf.general]](spanbuf.general)

#### 31.9.3.2 Constructors [[spanbuf.cons]](spanbuf.cons)

#### 31.9.3.3 Assignment and swap [[spanbuf.assign]](spanbuf.assign)

#### 31.9.3.4 Member functions [[spanbuf.members]](spanbuf.members)

#### 31.9.3.5 Overridden virtual functions [[spanbuf.virtuals]](spanbuf.virtuals)

#### 31.9.4 Class template basic_ispanstream [[ispanstream]](ispanstream)

#### 31.9.4.1 General [[ispanstream.general]](ispanstream.general)

#### 31.9.4.2 Constructors [[ispanstream.cons]](ispanstream.cons)

#### 31.9.4.3 Swap [[ispanstream.swap]](ispanstream.swap)

#### 31.9.4.4 Member functions [[ispanstream.members]](ispanstream.members)

#### 31.9.5 Class template basic_ospanstream [[ospanstream]](ospanstream)

#### 31.9.5.1 General [[ospanstream.general]](ospanstream.general)

#### 31.9.5.2 Constructors [[ospanstream.cons]](ospanstream.cons)

#### 31.9.5.3 Swap [[ospanstream.swap]](ospanstream.swap)

#### 31.9.5.4 Member functions [[ospanstream.members]](ospanstream.members)

#### 31.9.6 Class template basic_spanstream [[spanstream]](spanstream)

#### 31.9.6.1 General [[spanstream.general]](spanstream.general)

#### 31.9.6.2 Constructors [[spanstream.cons]](spanstream.cons)

#### 31.9.6.3 Swap [[spanstream.swap]](spanstream.swap)

#### 31.9.6.4 Member functions [[spanstream.members]](spanstream.members)

### 31.10 File-based streams [[file.streams]](file.streams)

#### 31.10.1 Header <fstream> synopsis [[fstream.syn]](fstream.syn)

#### 31.10.2 Native handles [[file.native]](file.native)

#### 31.10.3 Class template basic_filebuf [[filebuf]](filebuf)

#### 31.10.3.1 General [[filebuf.general]](filebuf.general)

#### 31.10.3.2 Constructors [[filebuf.cons]](filebuf.cons)

#### 31.10.3.3 Assignment and swap [[filebuf.assign]](filebuf.assign)

#### 31.10.3.4 Member functions [[filebuf.members]](filebuf.members)

#### 31.10.3.5 Overridden virtual functions [[filebuf.virtuals]](filebuf.virtuals)

#### 31.10.4 Class template basic_ifstream [[ifstream]](ifstream)

#### 31.10.4.1 General [[ifstream.general]](ifstream.general)

#### 31.10.4.2 Constructors [[ifstream.cons]](ifstream.cons)

#### 31.10.4.3 Swap [[ifstream.swap]](ifstream.swap)

#### 31.10.4.4 Member functions [[ifstream.members]](ifstream.members)

#### 31.10.5 Class template basic_ofstream [[ofstream]](ofstream)

#### 31.10.5.1 General [[ofstream.general]](ofstream.general)

#### 31.10.5.2 Constructors [[ofstream.cons]](ofstream.cons)

#### 31.10.5.3 Swap [[ofstream.swap]](ofstream.swap)

#### 31.10.5.4 Member functions [[ofstream.members]](ofstream.members)

#### 31.10.6 Class template basic_fstream [[fstream]](fstream)

#### 31.10.6.1 General [[fstream.general]](fstream.general)

#### 31.10.6.2 Constructors [[fstream.cons]](fstream.cons)

#### 31.10.6.3 Swap [[fstream.swap]](fstream.swap)

#### 31.10.6.4 Member functions [[fstream.members]](fstream.members)

### 31.11 Synchronized output streams [[syncstream]](syncstream)

#### 31.11.1 Header <syncstream> synopsis [[syncstream.syn]](syncstream.syn)

#### 31.11.2 Class template basic_syncbuf [[syncstream.syncbuf]](syncstream.syncbuf)

#### 31.11.2.1 Overview [[syncstream.syncbuf.overview]](syncstream.syncbuf.overview)

#### 31.11.2.2 Construction and destruction [[syncstream.syncbuf.cons]](syncstream.syncbuf.cons)

#### 31.11.2.3 Assignment and swap [[syncstream.syncbuf.assign]](syncstream.syncbuf.assign)

#### 31.11.2.4 Member functions [[syncstream.syncbuf.members]](syncstream.syncbuf.members)

#### 31.11.2.5 Overridden virtual functions [[syncstream.syncbuf.virtuals]](syncstream.syncbuf.virtuals)

#### 31.11.2.6 Specialized algorithms [[syncstream.syncbuf.special]](syncstream.syncbuf.special)

#### 31.11.3 Class template basic_osyncstream [[syncstream.osyncstream]](syncstream.osyncstream)

#### 31.11.3.1 Overview [[syncstream.osyncstream.overview]](syncstream.osyncstream.overview)

#### 31.11.3.2 Construction and destruction [[syncstream.osyncstream.cons]](syncstream.osyncstream.cons)

#### 31.11.3.3 Member functions [[syncstream.osyncstream.members]](syncstream.osyncstream.members)

### 31.12 File systems [[filesystems]](filesystems)

#### 31.12.1 General [[fs.general]](fs.general)

#### 31.12.2 Conformance [[fs.conformance]](fs.conformance)

#### 31.12.2.1 General [[fs.conformance.general]](fs.conformance.general)

#### 31.12.2.2 POSIX conformance [[fs.conform.9945]](fs.conform.9945)

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

#### 31.12.2.4 File system race behavior [[fs.race.behavior]](fs.race.behavior)

#### 31.12.3 Requirements [[fs.req]](fs.req)

#### 31.12.4 Header <filesystem> synopsis [[fs.filesystem.syn]](fs.filesystem.syn)

#### 31.12.5 Error reporting [[fs.err.report]](fs.err.report)

#### 31.12.6 Class path [[fs.class.path]](fs.class.path)

#### 31.12.6.1 General [[fs.class.path.general]](fs.class.path.general)

#### 31.12.6.2 Generic pathname format [[fs.path.generic]](fs.path.generic)

#### 31.12.6.3 Conversions [[fs.path.cvt]](fs.path.cvt)

#### 31.12.6.3.1 Argument format conversions [[fs.path.fmt.cvt]](fs.path.fmt.cvt)

#### 31.12.6.3.2 Type and encoding conversions [[fs.path.type.cvt]](fs.path.type.cvt)

#### 31.12.6.4 Requirements [[fs.path.req]](fs.path.req)

#### 31.12.6.5 Members [[fs.path.member]](fs.path.member)

#### 31.12.6.5.1 Constructors [[fs.path.construct]](fs.path.construct)

#### 31.12.6.5.2 Assignments [[fs.path.assign]](fs.path.assign)

#### 31.12.6.5.3 Appends [[fs.path.append]](fs.path.append)

#### 31.12.6.5.4 Concatenation [[fs.path.concat]](fs.path.concat)

#### 31.12.6.5.5 Modifiers [[fs.path.modifiers]](fs.path.modifiers)

#### 31.12.6.5.6 Native format observers [[fs.path.native.obs]](fs.path.native.obs)

#### 31.12.6.5.7 Generic format observers [[fs.path.generic.obs]](fs.path.generic.obs)

#### 31.12.6.5.8 Compare [[fs.path.compare]](fs.path.compare)

#### 31.12.6.5.9 Decomposition [[fs.path.decompose]](fs.path.decompose)

#### 31.12.6.5.10 Query [[fs.path.query]](fs.path.query)

#### 31.12.6.5.11 Generation [[fs.path.gen]](fs.path.gen)

#### 31.12.6.6 Iterators [[fs.path.itr]](fs.path.itr)

#### 31.12.6.7 Inserter and extractor [[fs.path.io]](fs.path.io)

#### 31.12.6.8 Non-member functions [[fs.path.nonmember]](fs.path.nonmember)

#### 31.12.6.9 Formatting support [[fs.path.fmtr]](fs.path.fmtr)

#### 31.12.6.9.1 Formatting support overview [[fs.path.fmtr.general]](fs.path.fmtr.general)

#### 31.12.6.9.2 Formatting support functions [[fs.path.fmtr.funcs]](fs.path.fmtr.funcs)

#### 31.12.6.10 Hash support [[fs.path.hash]](fs.path.hash)

#### 31.12.7 Class filesystem_error [[fs.class.filesystem.error]](fs.class.filesystem.error)

#### 31.12.7.1 General [[fs.class.filesystem.error.general]](fs.class.filesystem.error.general)

#### 31.12.7.2 Members [[fs.filesystem.error.members]](fs.filesystem.error.members)

#### 31.12.8 Enumerations [[fs.enum]](fs.enum)

#### 31.12.8.1 Enum path​::​format [[fs.enum.path.format]](fs.enum.path.format)

#### 31.12.8.2 Enum class file_type [[fs.enum.file.type]](fs.enum.file.type)

#### 31.12.8.3 Enum class copy_options [[fs.enum.copy.opts]](fs.enum.copy.opts)

#### 31.12.8.4 Enum class perms [[fs.enum.perms]](fs.enum.perms)

#### 31.12.8.5 Enum class perm_options [[fs.enum.perm.opts]](fs.enum.perm.opts)

#### 31.12.8.6 Enum class directory_options [[fs.enum.dir.opts]](fs.enum.dir.opts)

#### 31.12.9 Class file_status [[fs.class.file.status]](fs.class.file.status)

#### 31.12.9.1 General [[fs.class.file.status.general]](fs.class.file.status.general)

#### 31.12.9.2 Constructors [[fs.file.status.cons]](fs.file.status.cons)

#### 31.12.9.3 Observers [[fs.file.status.obs]](fs.file.status.obs)

#### 31.12.9.4 Modifiers [[fs.file.status.mods]](fs.file.status.mods)

#### 31.12.10 Class directory_entry [[fs.class.directory.entry]](fs.class.directory.entry)

#### 31.12.10.1 General [[fs.class.directory.entry.general]](fs.class.directory.entry.general)

#### 31.12.10.2 Constructors [[fs.dir.entry.cons]](fs.dir.entry.cons)

#### 31.12.10.3 Modifiers [[fs.dir.entry.mods]](fs.dir.entry.mods)

#### 31.12.10.4 Observers [[fs.dir.entry.obs]](fs.dir.entry.obs)

#### 31.12.10.5 Inserter [[fs.dir.entry.io]](fs.dir.entry.io)

#### 31.12.11 Class directory_iterator [[fs.class.directory.iterator]](fs.class.directory.iterator)

#### 31.12.11.1 General [[fs.class.directory.iterator.general]](fs.class.directory.iterator.general)

#### 31.12.11.2 Members [[fs.dir.itr.members]](fs.dir.itr.members)

#### 31.12.11.3 Non-member functions [[fs.dir.itr.nonmembers]](fs.dir.itr.nonmembers)

#### 31.12.12 Class recursive_directory_iterator [[fs.class.rec.dir.itr]](fs.class.rec.dir.itr)

#### 31.12.12.1 General [[fs.class.rec.dir.itr.general]](fs.class.rec.dir.itr.general)

#### 31.12.12.2 Members [[fs.rec.dir.itr.members]](fs.rec.dir.itr.members)

#### 31.12.12.3 Non-member functions [[fs.rec.dir.itr.nonmembers]](fs.rec.dir.itr.nonmembers)

#### 31.12.13 Filesystem operation functions [[fs.op.funcs]](fs.op.funcs)

#### 31.12.13.1 General [[fs.op.funcs.general]](fs.op.funcs.general)

#### 31.12.13.2 Absolute [[fs.op.absolute]](fs.op.absolute)

#### 31.12.13.3 Canonical [[fs.op.canonical]](fs.op.canonical)

#### 31.12.13.4 Copy [[fs.op.copy]](fs.op.copy)

#### 31.12.13.5 Copy file [[fs.op.copy.file]](fs.op.copy.file)

#### 31.12.13.6 Copy symlink [[fs.op.copy.symlink]](fs.op.copy.symlink)

#### 31.12.13.7 Create directories [[fs.op.create.directories]](fs.op.create.directories)

#### 31.12.13.8 Create directory [[fs.op.create.directory]](fs.op.create.directory)

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

#### 31.12.13.10 Create hard link [[fs.op.create.hard.lk]](fs.op.create.hard.lk)

#### 31.12.13.11 Create symlink [[fs.op.create.symlink]](fs.op.create.symlink)

#### 31.12.13.12 Current path [[fs.op.current.path]](fs.op.current.path)

#### 31.12.13.13 Equivalent [[fs.op.equivalent]](fs.op.equivalent)

#### 31.12.13.14 Exists [[fs.op.exists]](fs.op.exists)

#### 31.12.13.15 File size [[fs.op.file.size]](fs.op.file.size)

#### 31.12.13.16 Hard link count [[fs.op.hard.lk.ct]](fs.op.hard.lk.ct)

#### 31.12.13.17 Is block file [[fs.op.is.block.file]](fs.op.is.block.file)

#### 31.12.13.18 Is character file [[fs.op.is.char.file]](fs.op.is.char.file)

#### 31.12.13.19 Is directory [[fs.op.is.directory]](fs.op.is.directory)

#### 31.12.13.20 Is empty [[fs.op.is.empty]](fs.op.is.empty)

#### 31.12.13.21 Is fifo [[fs.op.is.fifo]](fs.op.is.fifo)

#### 31.12.13.22 Is other [[fs.op.is.other]](fs.op.is.other)

#### 31.12.13.23 Is regular file [[fs.op.is.regular.file]](fs.op.is.regular.file)

#### 31.12.13.24 Is socket [[fs.op.is.socket]](fs.op.is.socket)

#### 31.12.13.25 Is symlink [[fs.op.is.symlink]](fs.op.is.symlink)

#### 31.12.13.26 Last write time [[fs.op.last.write.time]](fs.op.last.write.time)

#### 31.12.13.27 Permissions [[fs.op.permissions]](fs.op.permissions)

#### 31.12.13.28 Proximate [[fs.op.proximate]](fs.op.proximate)

#### 31.12.13.29 Read symlink [[fs.op.read.symlink]](fs.op.read.symlink)

#### 31.12.13.30 Relative [[fs.op.relative]](fs.op.relative)

#### 31.12.13.31 Remove [[fs.op.remove]](fs.op.remove)

#### 31.12.13.32 Remove all [[fs.op.remove.all]](fs.op.remove.all)

#### 31.12.13.33 Rename [[fs.op.rename]](fs.op.rename)

#### 31.12.13.34 Resize file [[fs.op.resize.file]](fs.op.resize.file)

#### 31.12.13.35 Space [[fs.op.space]](fs.op.space)

#### 31.12.13.36 Status [[fs.op.status]](fs.op.status)

#### 31.12.13.37 Status known [[fs.op.status.known]](fs.op.status.known)

#### 31.12.13.38 Symlink status [[fs.op.symlink.status]](fs.op.symlink.status)

#### 31.12.13.39 Temporary directory path [[fs.op.temp.dir.path]](fs.op.temp.dir.path)

#### 31.12.13.40 Weakly canonical [[fs.op.weakly.canonical]](fs.op.weakly.canonical)

### 31.13 C library files [[c.files]](c.files)

#### 31.13.1 Header <cstdio> synopsis [[cstdio.syn]](cstdio.syn)

#### 31.13.2 Header <cinttypes> synopsis [[cinttypes.syn]](cinttypes.syn)

## 32 Concurrency support library [[thread]](#thread)[[thread]](thread)

### 32.1 General [[thread.general]](thread.general)

### 32.2 Requirements [[thread.req]](thread.req)

#### 32.2.1 Template parameter names [[thread.req.paramname]](thread.req.paramname)

#### 32.2.2 Exceptions [[thread.req.exception]](thread.req.exception)

#### 32.2.3 Native handles [[thread.req.native]](thread.req.native)

#### 32.2.4 Timing specifications [[thread.req.timing]](thread.req.timing)

#### 32.2.5 Requirements for *Cpp17Lockable* types [[thread.req.lockable]](thread.req.lockable)

#### 32.2.5.1 General [[thread.req.lockable.general]](thread.req.lockable.general)

#### 32.2.5.2 *Cpp17BasicLockable* requirements [[thread.req.lockable.basic]](thread.req.lockable.basic)

#### 32.2.5.3 *Cpp17Lockable* requirements [[thread.req.lockable.req]](thread.req.lockable.req)

#### 32.2.5.4 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]](thread.req.lockable.timed)

#### 32.2.5.5 *Cpp17SharedLockable* requirements [[thread.req.lockable.shared]](thread.req.lockable.shared)

#### 32.2.5.6 *Cpp17SharedTimedLockable* requirements [[thread.req.lockable.shared.timed]](thread.req.lockable.shared.timed)

### 32.3 Stop tokens [[thread.stoptoken]](thread.stoptoken)

#### 32.3.1 Introduction [[thread.stoptoken.intro]](thread.stoptoken.intro)

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

#### 32.3.3 Stop token concepts [[stoptoken.concepts]](stoptoken.concepts)

#### 32.3.4 Class stop_token [[stoptoken]](stoptoken)

#### 32.3.4.1 General [[stoptoken.general]](stoptoken.general)

#### 32.3.4.2 Member functions [[stoptoken.mem]](stoptoken.mem)

#### 32.3.5 Class stop_source [[stopsource]](stopsource)

#### 32.3.5.1 General [[stopsource.general]](stopsource.general)

#### 32.3.5.2 Constructors, copy, and assignment [[stopsource.cons]](stopsource.cons)

#### 32.3.5.3 Member functions [[stopsource.mem]](stopsource.mem)

#### 32.3.6 Class template stop_callback [[stopcallback]](stopcallback)

#### 32.3.6.1 General [[stopcallback.general]](stopcallback.general)

#### 32.3.6.2 Constructors and destructor [[stopcallback.cons]](stopcallback.cons)

#### 32.3.7 Class never_stop_token [[stoptoken.never]](stoptoken.never)

#### 32.3.8 Class inplace_stop_token [[stoptoken.inplace]](stoptoken.inplace)

#### 32.3.8.1 General [[stoptoken.inplace.general]](stoptoken.inplace.general)

#### 32.3.8.2 Member functions [[stoptoken.inplace.mem]](stoptoken.inplace.mem)

#### 32.3.9 Class inplace_stop_source [[stopsource.inplace]](stopsource.inplace)

#### 32.3.9.1 General [[stopsource.inplace.general]](stopsource.inplace.general)

#### 32.3.9.2 Constructors [[stopsource.inplace.cons]](stopsource.inplace.cons)

#### 32.3.9.3 Member functions [[stopsource.inplace.mem]](stopsource.inplace.mem)

#### 32.3.10 Class template inplace_stop_callback [[stopcallback.inplace]](stopcallback.inplace)

#### 32.3.10.1 General [[stopcallback.inplace.general]](stopcallback.inplace.general)

#### 32.3.10.2 Constructors and destructor [[stopcallback.inplace.cons]](stopcallback.inplace.cons)

### 32.4 Threads [[thread.threads]](thread.threads)

#### 32.4.1 General [[thread.threads.general]](thread.threads.general)

#### 32.4.2 Header <thread> synopsis [[thread.syn]](thread.syn)

#### 32.4.3 Class thread [[thread.thread.class]](thread.thread.class)

#### 32.4.3.1 General [[thread.thread.class.general]](thread.thread.class.general)

#### 32.4.3.2 Class thread​::​id [[thread.thread.id]](thread.thread.id)

#### 32.4.3.3 Constructors [[thread.thread.constr]](thread.thread.constr)

#### 32.4.3.4 Destructor [[thread.thread.destr]](thread.thread.destr)

#### 32.4.3.5 Assignment [[thread.thread.assign]](thread.thread.assign)

#### 32.4.3.6 Members [[thread.thread.member]](thread.thread.member)

#### 32.4.3.7 Static members [[thread.thread.static]](thread.thread.static)

#### 32.4.3.8 Specialized algorithms [[thread.thread.algorithm]](thread.thread.algorithm)

#### 32.4.4 Class jthread [[thread.jthread.class]](thread.jthread.class)

#### 32.4.4.1 General [[thread.jthread.class.general]](thread.jthread.class.general)

#### 32.4.4.2 Constructors, move, and assignment [[thread.jthread.cons]](thread.jthread.cons)

#### 32.4.4.3 Members [[thread.jthread.mem]](thread.jthread.mem)

#### 32.4.4.4 Stop token handling [[thread.jthread.stop]](thread.jthread.stop)

#### 32.4.4.5 Specialized algorithms [[thread.jthread.special]](thread.jthread.special)

#### 32.4.4.6 Static members [[thread.jthread.static]](thread.jthread.static)

#### 32.4.5 Namespace this_thread [[thread.thread.this]](thread.thread.this)

### 32.5 Atomic operations [[atomics]](atomics)

#### 32.5.1 General [[atomics.general]](atomics.general)

#### 32.5.2 Header <atomic> synopsis [[atomics.syn]](atomics.syn)

#### 32.5.3 Type aliases [[atomics.alias]](atomics.alias)

#### 32.5.4 Order and consistency [[atomics.order]](atomics.order)

#### 32.5.5 Lock-free property [[atomics.lockfree]](atomics.lockfree)

#### 32.5.6 Waiting and notifying [[atomics.wait]](atomics.wait)

#### 32.5.7 Class template atomic_ref [[atomics.ref.generic]](atomics.ref.generic)

#### 32.5.7.1 General [[atomics.ref.generic.general]](atomics.ref.generic.general)

#### 32.5.7.2 Operations [[atomics.ref.ops]](atomics.ref.ops)

#### 32.5.7.3 Specializations for integral types [[atomics.ref.int]](atomics.ref.int)

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

#### 32.5.7.5 Specialization for pointers [[atomics.ref.pointer]](atomics.ref.pointer)

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

#### 32.5.8 Class template atomic [[atomics.types.generic]](atomics.types.generic)

#### 32.5.8.1 General [[atomics.types.generic.general]](atomics.types.generic.general)

#### 32.5.8.2 Operations on atomic types [[atomics.types.operations]](atomics.types.operations)

#### 32.5.8.3 Specializations for integers [[atomics.types.int]](atomics.types.int)

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

#### 32.5.8.5 Partial specialization for pointers [[atomics.types.pointer]](atomics.types.pointer)

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

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

#### 32.5.8.7.1 General [[util.smartptr.atomic.general]](util.smartptr.atomic.general)

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

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

#### 32.5.9 Non-member functions [[atomics.nonmembers]](atomics.nonmembers)

#### 32.5.10 Flag type and operations [[atomics.flag]](atomics.flag)

#### 32.5.11 Fences [[atomics.fences]](atomics.fences)

#### 32.5.12 C compatibility [[stdatomic.h.syn]](stdatomic.h.syn)

### 32.6 Mutual exclusion [[thread.mutex]](thread.mutex)

#### 32.6.1 General [[thread.mutex.general]](thread.mutex.general)

#### 32.6.2 Header <mutex> synopsis [[mutex.syn]](mutex.syn)

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

#### 32.6.4 Mutex requirements [[thread.mutex.requirements]](thread.mutex.requirements)

#### 32.6.4.1 General [[thread.mutex.requirements.general]](thread.mutex.requirements.general)

#### 32.6.4.2 Mutex types [[thread.mutex.requirements.mutex]](thread.mutex.requirements.mutex)

#### 32.6.4.2.1 General [[thread.mutex.requirements.mutex.general]](thread.mutex.requirements.mutex.general)

#### 32.6.4.2.2 Class mutex [[thread.mutex.class]](thread.mutex.class)

#### 32.6.4.2.3 Class recursive_mutex [[thread.mutex.recursive]](thread.mutex.recursive)

#### 32.6.4.3 Timed mutex types [[thread.timedmutex.requirements]](thread.timedmutex.requirements)

#### 32.6.4.3.1 General [[thread.timedmutex.requirements.general]](thread.timedmutex.requirements.general)

#### 32.6.4.3.2 Class timed_mutex [[thread.timedmutex.class]](thread.timedmutex.class)

#### 32.6.4.3.3 Class recursive_timed_mutex [[thread.timedmutex.recursive]](thread.timedmutex.recursive)

#### 32.6.4.4 Shared mutex types [[thread.sharedmutex.requirements]](thread.sharedmutex.requirements)

#### 32.6.4.4.1 General [[thread.sharedmutex.requirements.general]](thread.sharedmutex.requirements.general)

#### 32.6.4.4.2 Class shared_mutex [[thread.sharedmutex.class]](thread.sharedmutex.class)

#### 32.6.4.5 Shared timed mutex types [[thread.sharedtimedmutex.requirements]](thread.sharedtimedmutex.requirements)

#### 32.6.4.5.1 General [[thread.sharedtimedmutex.requirements.general]](thread.sharedtimedmutex.requirements.general)

#### 32.6.4.5.2 Class shared_timed_mutex [[thread.sharedtimedmutex.class]](thread.sharedtimedmutex.class)

#### 32.6.5 Locks [[thread.lock]](thread.lock)

#### 32.6.5.1 General [[thread.lock.general]](thread.lock.general)

#### 32.6.5.2 Class template lock_guard [[thread.lock.guard]](thread.lock.guard)

#### 32.6.5.3 Class template scoped_lock [[thread.lock.scoped]](thread.lock.scoped)

#### 32.6.5.4 Class template unique_lock [[thread.lock.unique]](thread.lock.unique)

#### 32.6.5.4.1 General [[thread.lock.unique.general]](thread.lock.unique.general)

#### 32.6.5.4.2 Constructors, destructor, and assignment [[thread.lock.unique.cons]](thread.lock.unique.cons)

#### 32.6.5.4.3 Locking [[thread.lock.unique.locking]](thread.lock.unique.locking)

#### 32.6.5.4.4 Modifiers [[thread.lock.unique.mod]](thread.lock.unique.mod)

#### 32.6.5.4.5 Observers [[thread.lock.unique.obs]](thread.lock.unique.obs)

#### 32.6.5.5 Class template shared_lock [[thread.lock.shared]](thread.lock.shared)

#### 32.6.5.5.1 General [[thread.lock.shared.general]](thread.lock.shared.general)

#### 32.6.5.5.2 Constructors, destructor, and assignment [[thread.lock.shared.cons]](thread.lock.shared.cons)

#### 32.6.5.5.3 Locking [[thread.lock.shared.locking]](thread.lock.shared.locking)

#### 32.6.5.5.4 Modifiers [[thread.lock.shared.mod]](thread.lock.shared.mod)

#### 32.6.5.5.5 Observers [[thread.lock.shared.obs]](thread.lock.shared.obs)

#### 32.6.6 Generic locking algorithms [[thread.lock.algorithm]](thread.lock.algorithm)

#### 32.6.7 Call once [[thread.once]](thread.once)

#### 32.6.7.1 Struct once_flag [[thread.once.onceflag]](thread.once.onceflag)

#### 32.6.7.2 Function call_once [[thread.once.callonce]](thread.once.callonce)

### 32.7 Condition variables [[thread.condition]](thread.condition)

#### 32.7.1 General [[thread.condition.general]](thread.condition.general)

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

#### 32.7.3 Non-member functions [[thread.condition.nonmember]](thread.condition.nonmember)

#### 32.7.4 Class condition_variable [[thread.condition.condvar]](thread.condition.condvar)

#### 32.7.5 Class condition_variable_any [[thread.condition.condvarany]](thread.condition.condvarany)

#### 32.7.5.1 General [[thread.condition.condvarany.general]](thread.condition.condvarany.general)

#### 32.7.5.2 Noninterruptible waits [[thread.condvarany.wait]](thread.condvarany.wait)

#### 32.7.5.3 Interruptible waits [[thread.condvarany.intwait]](thread.condvarany.intwait)

### 32.8 Semaphore [[thread.sema]](thread.sema)

#### 32.8.1 General [[thread.sema.general]](thread.sema.general)

#### 32.8.2 Header <semaphore> synopsis [[semaphore.syn]](semaphore.syn)

#### 32.8.3 Class template counting_semaphore [[thread.sema.cnt]](thread.sema.cnt)

### 32.9 Coordination types [[thread.coord]](thread.coord)

#### 32.9.1 General [[thread.coord.general]](thread.coord.general)

#### 32.9.2 Latches [[thread.latch]](thread.latch)

#### 32.9.2.1 General [[thread.latch.general]](thread.latch.general)

#### 32.9.2.2 Header <latch> synopsis [[latch.syn]](latch.syn)

#### 32.9.2.3 Class latch [[thread.latch.class]](thread.latch.class)

#### 32.9.3 Barriers [[thread.barrier]](thread.barrier)

#### 32.9.3.1 General [[thread.barrier.general]](thread.barrier.general)

#### 32.9.3.2 Header <barrier> synopsis [[barrier.syn]](barrier.syn)

#### 32.9.3.3 Class template barrier [[thread.barrier.class]](thread.barrier.class)

### 32.10 Futures [[futures]](futures)

#### 32.10.1 Overview [[futures.overview]](futures.overview)

#### 32.10.2 Header <future> synopsis [[future.syn]](future.syn)

#### 32.10.3 Error handling [[futures.errors]](futures.errors)

#### 32.10.4 Class future_error [[futures.future.error]](futures.future.error)

#### 32.10.5 Shared state [[futures.state]](futures.state)

#### 32.10.6 Class template promise [[futures.promise]](futures.promise)

#### 32.10.7 Class template future [[futures.unique.future]](futures.unique.future)

#### 32.10.8 Class template shared_future [[futures.shared.future]](futures.shared.future)

#### 32.10.9 Function template async [[futures.async]](futures.async)

#### 32.10.10 Class template packaged_task [[futures.task]](futures.task)

#### 32.10.10.1 General [[futures.task.general]](futures.task.general)

#### 32.10.10.2 Member functions [[futures.task.members]](futures.task.members)

#### 32.10.10.3 Globals [[futures.task.nonmembers]](futures.task.nonmembers)

### 32.11 Safe reclamation [[saferecl]](saferecl)

#### 32.11.1 General [[saferecl.general]](saferecl.general)

#### 32.11.2 Read-copy update (RCU) [[saferecl.rcu]](saferecl.rcu)

#### 32.11.2.1 General [[saferecl.rcu.general]](saferecl.rcu.general)

#### 32.11.2.2 Header <rcu> synopsis [[rcu.syn]](rcu.syn)

#### 32.11.2.3 Class template rcu_obj_base [[saferecl.rcu.base]](saferecl.rcu.base)

#### 32.11.2.4 Class rcu_domain [[saferecl.rcu.domain]](saferecl.rcu.domain)

#### 32.11.2.4.1 General [[saferecl.rcu.domain.general]](saferecl.rcu.domain.general)

#### 32.11.2.4.2 Member functions [[saferecl.rcu.domain.members]](saferecl.rcu.domain.members)

#### 32.11.2.4.3 Non-member functions [[saferecl.rcu.domain.func]](saferecl.rcu.domain.func)

#### 32.11.3 Hazard pointers [[saferecl.hp]](saferecl.hp)

#### 32.11.3.1 General [[saferecl.hp.general]](saferecl.hp.general)

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

#### 32.11.3.3 Class template hazard_pointer_obj_base [[saferecl.hp.base]](saferecl.hp.base)

#### 32.11.3.4 Class hazard_pointer [[saferecl.hp.holder]](saferecl.hp.holder)

#### 32.11.3.4.1 General [[saferecl.hp.holder.general]](saferecl.hp.holder.general)

#### 32.11.3.4.2 Constructors, destructor, and assignment [[saferecl.hp.holder.ctor]](saferecl.hp.holder.ctor)

#### 32.11.3.4.3 Member functions [[saferecl.hp.holder.mem]](saferecl.hp.holder.mem)

#### 32.11.3.4.4 Non-member functions [[saferecl.hp.holder.nonmem]](saferecl.hp.holder.nonmem)

## 33 Execution control library [[exec]](#exec)[[exec]](exec)

### 33.1 General [[exec.general]](exec.general)

### 33.2 Queries and queryables [[exec.queryable]](exec.queryable)

#### 33.2.1 General [[exec.queryable.general]](exec.queryable.general)

#### 33.2.2 queryable concept [[exec.queryable.concept]](exec.queryable.concept)

### 33.3 Asynchronous operations [[exec.async.ops]](exec.async.ops)

### 33.4 Header <execution> synopsis [[execution.syn]](execution.syn)

### 33.5 Queries [[exec.queries]](exec.queries)

#### 33.5.1 forwarding_query [[exec.fwd.env]](exec.fwd.env)

#### 33.5.2 get_allocator [[exec.get.allocator]](exec.get.allocator)

#### 33.5.3 get_stop_token [[exec.get.stop.token]](exec.get.stop.token)

#### 33.5.4 execution​::​get_env [[exec.get.env]](exec.get.env)

#### 33.5.5 execution​::​get_domain [[exec.get.domain]](exec.get.domain)

#### 33.5.6 execution​::​get_scheduler [[exec.get.scheduler]](exec.get.scheduler)

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

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

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

#### 33.5.10 execution​::​get_await_completion_adaptor [[exec.get.await.adapt]](exec.get.await.adapt)

### 33.6 Schedulers [[exec.sched]](exec.sched)

### 33.7 Receivers [[exec.recv]](exec.recv)

#### 33.7.1 Receiver concepts [[exec.recv.concepts]](exec.recv.concepts)

#### 33.7.2 execution​::​set_value [[exec.set.value]](exec.set.value)

#### 33.7.3 execution​::​set_error [[exec.set.error]](exec.set.error)

#### 33.7.4 execution​::​set_stopped [[exec.set.stopped]](exec.set.stopped)

### 33.8 Operation states [[exec.opstate]](exec.opstate)

#### 33.8.1 General [[exec.opstate.general]](exec.opstate.general)

#### 33.8.2 execution​::​start [[exec.opstate.start]](exec.opstate.start)

### 33.9 Senders [[exec.snd]](exec.snd)

#### 33.9.1 General [[exec.snd.general]](exec.snd.general)

#### 33.9.2 Exposition-only entities [[exec.snd.expos]](exec.snd.expos)

#### 33.9.3 Sender concepts [[exec.snd.concepts]](exec.snd.concepts)

#### 33.9.4 Awaitable helpers [[exec.awaitable]](exec.awaitable)

#### 33.9.5 execution​::​default_domain [[exec.domain.default]](exec.domain.default)

#### 33.9.6 execution​::​transform_sender [[exec.snd.transform]](exec.snd.transform)

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

#### 33.9.8 execution​::​apply_sender [[exec.snd.apply]](exec.snd.apply)

#### 33.9.9 execution​::​get_completion_signatures [[exec.getcomplsigs]](exec.getcomplsigs)

#### 33.9.10 execution​::​connect [[exec.connect]](exec.connect)

#### 33.9.11 Sender factories [[exec.factories]](exec.factories)

#### 33.9.11.1 execution​::​schedule [[exec.schedule]](exec.schedule)

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

#### 33.9.11.3 execution​::​read_env [[exec.read.env]](exec.read.env)

#### 33.9.12 Sender adaptors [[exec.adapt]](exec.adapt)

#### 33.9.12.1 General [[exec.adapt.general]](exec.adapt.general)

#### 33.9.12.2 Closure objects [[exec.adapt.obj]](exec.adapt.obj)

#### 33.9.12.3 execution​::​write_env [[exec.write.env]](exec.write.env)

#### 33.9.12.4 execution​::​unstoppable [[exec.unstoppable]](exec.unstoppable)

#### 33.9.12.5 execution​::​starts_on [[exec.starts.on]](exec.starts.on)

#### 33.9.12.6 execution​::​continues_on [[exec.continues.on]](exec.continues.on)

#### 33.9.12.7 execution​::​schedule_from [[exec.schedule.from]](exec.schedule.from)

#### 33.9.12.8 execution​::​on [[exec.on]](exec.on)

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

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

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

#### 33.9.12.12 execution​::​when_all [[exec.when.all]](exec.when.all)

#### 33.9.12.13 execution​::​into_variant [[exec.into.variant]](exec.into.variant)

#### 33.9.12.14 execution​::​stopped_as_optional [[exec.stopped.opt]](exec.stopped.opt)

#### 33.9.12.15 execution​::​stopped_as_error [[exec.stopped.err]](exec.stopped.err)

#### 33.9.12.16 execution​::​associate [[exec.associate]](exec.associate)

#### 33.9.12.17 Exposition-only execution​::​*stop-when* [[exec.stop.when]](exec.stop.when)

#### 33.9.12.18 execution​::​spawn_future [[exec.spawn.future]](exec.spawn.future)

#### 33.9.13 Sender consumers [[exec.consumers]](exec.consumers)

#### 33.9.13.1 this_thread​::​sync_wait [[exec.sync.wait]](exec.sync.wait)

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

#### 33.9.13.3 execution​::​spawn [[exec.spawn]](exec.spawn)

### 33.10 Completion signatures [[exec.cmplsig]](exec.cmplsig)

### 33.11 Queryable utilities [[exec.envs]](exec.envs)

#### 33.11.1 Class template prop [[exec.prop]](exec.prop)

#### 33.11.2 Class template env [[exec.env]](exec.env)

### 33.12 Execution contexts [[exec.ctx]](exec.ctx)

#### 33.12.1 execution​::​run_loop [[exec.run.loop]](exec.run.loop)

#### 33.12.1.1 General [[exec.run.loop.general]](exec.run.loop.general)

#### 33.12.1.2 Associated types [[exec.run.loop.types]](exec.run.loop.types)

#### 33.12.1.3 Constructor and destructor [[exec.run.loop.ctor]](exec.run.loop.ctor)

#### 33.12.1.4 Member functions [[exec.run.loop.members]](exec.run.loop.members)

### 33.13 Coroutine utilities [[exec.coro.util]](exec.coro.util)

#### 33.13.1 execution​::​as_awaitable [[exec.as.awaitable]](exec.as.awaitable)

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

#### 33.13.3 execution​::​affine_on [[exec.affine.on]](exec.affine.on)

#### 33.13.4 execution​::​inline_scheduler [[exec.inline.scheduler]](exec.inline.scheduler)

#### 33.13.5 execution​::​task_scheduler [[exec.task.scheduler]](exec.task.scheduler)

#### 33.13.6 execution​::​task [[exec.task]](exec.task)

#### 33.13.6.1 task overview [[task.overview]](task.overview)

#### 33.13.6.2 Class template task [[task.class]](task.class)

#### 33.13.6.3 task members [[task.members]](task.members)

#### 33.13.6.4 Class template task​::​*state* [[task.state]](task.state)

#### 33.13.6.5 Class task​::​promise_type [[task.promise]](task.promise)

### 33.14 Execution scope utilities [[exec.scope]](exec.scope)

#### 33.14.1 Execution scope concepts [[exec.scope.concepts]](exec.scope.concepts)

#### 33.14.2 Counting Scopes [[exec.counting.scopes]](exec.counting.scopes)

#### 33.14.2.1 General [[exec.counting.scopes.general]](exec.counting.scopes.general)

#### 33.14.2.2 Simple Counting Scope [[exec.scope.simple.counting]](exec.scope.simple.counting)

#### 33.14.2.2.1 General [[exec.scope.simple.counting.general]](exec.scope.simple.counting.general)

#### 33.14.2.2.2 Constructor and Destructor [[exec.simple.counting.ctor]](exec.simple.counting.ctor)

#### 33.14.2.2.3 Members [[exec.simple.counting.mem]](exec.simple.counting.mem)

#### 33.14.2.2.4 Token [[exec.simple.counting.token]](exec.simple.counting.token)

#### 33.14.2.3 Counting Scope [[exec.scope.counting]](exec.scope.counting)

### 33.15 Parallel scheduler [[exec.par.scheduler]](exec.par.scheduler)

### 33.16 Namespace system_context_replaceability [[exec.sysctxrepl]](exec.sysctxrepl)

#### 33.16.1 General [[exec.sysctxrepl.general]](exec.sysctxrepl.general)

#### 33.16.2 query_parallel_scheduler_backend [[exec.sysctxrepl.query]](exec.sysctxrepl.query)

#### 33.16.3 Class parallel_scheduler_backend [[exec.sysctxrepl.psb]](exec.sysctxrepl.psb)

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

### A.1 General [[gram.general]](gram.general)

### A.2 Keywords [[gram.key]](gram.key)

### A.3 Lexical conventions [[gram.lex]](gram.lex)

### A.4 Basics [[gram.basic]](gram.basic)

### A.5 Expressions [[gram.expr]](gram.expr)

### A.6 Statements [[gram.stmt]](gram.stmt)

### A.7 Declarations [[gram.dcl]](gram.dcl)

### A.8 Modules [[gram.module]](gram.module)

### A.9 Classes [[gram.class]](gram.class)

### A.10 Overloading [[gram.over]](gram.over)

### A.11 Templates [[gram.temp]](gram.temp)

### A.12 Exception handling [[gram.except]](gram.except)

### A.13 Preprocessing directives [[gram.cpp]](gram.cpp)

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

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

### C.1 C++ and ISO C++ 2023 [[diff.cpp23]](diff.cpp23)

#### C.1.1 General [[diff.cpp23.general]](diff.cpp23.general)

#### C.1.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp23.lex]](diff.cpp23.lex)

#### C.1.3 [[expr]](expr "7 Expressions"): expressions [[diff.cpp23.expr]](diff.cpp23.expr)

#### C.1.4 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp23.dcl.dcl]](diff.cpp23.dcl.dcl)

#### C.1.5 [[temp]](temp "13 Templates"): templates [[diff.cpp23.temp]](diff.cpp23.temp)

#### C.1.6 [[library]](library "16 Library introduction"): library introduction [[diff.cpp23.library]](diff.cpp23.library)

#### C.1.7 [[mem]](mem "20 Memory management library"): memory management library [[diff.cpp23.mem]](diff.cpp23.mem)

#### C.1.8 [[containers]](containers "23 Containers library"): containers library [[diff.cpp23.containers]](diff.cpp23.containers)

#### C.1.9 [[strings]](strings "27 Strings library"): strings library [[diff.cpp23.strings]](diff.cpp23.strings)

#### C.1.10 [[input.output]](input.output "31 Input/output library"): input/output library [[diff.cpp23.io]](diff.cpp23.io)

#### C.1.11 [[depr]](depr "Annex D (normative) Compatibility features"): compatibility features [[diff.cpp23.depr]](diff.cpp23.depr)

### C.2 C++ and ISO C++ 2020 [[diff.cpp20]](diff.cpp20)

#### C.2.1 General [[diff.cpp20.general]](diff.cpp20.general)

#### C.2.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp20.lex]](diff.cpp20.lex)

#### C.2.3 [[expr]](expr "7 Expressions"): expressions [[diff.cpp20.expr]](diff.cpp20.expr)

#### C.2.4 [[stmt]](stmt "8 Statements"): statements [[diff.cpp20.stmt]](diff.cpp20.stmt)

#### C.2.5 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp20.dcl]](diff.cpp20.dcl)

#### C.2.6 [[temp]](temp "13 Templates"): templates [[diff.cpp20.temp]](diff.cpp20.temp)

#### C.2.7 [[library]](library "16 Library introduction"): library introduction [[diff.cpp20.library]](diff.cpp20.library)

#### C.2.8 [[concepts]](concepts "18 Concepts library"): concepts library [[diff.cpp20.concepts]](diff.cpp20.concepts)

#### C.2.9 [[mem]](mem "20 Memory management library"): memory management library [[diff.cpp20.memory]](diff.cpp20.memory)

#### C.2.10 [[utilities]](utilities "22 General utilities library"): general utilities library [[diff.cpp20.utilities]](diff.cpp20.utilities)

#### C.2.11 [[strings]](strings "27 Strings library"): strings library [[diff.cpp20.strings]](diff.cpp20.strings)

#### C.2.12 [[containers]](containers "23 Containers library"): containers library [[diff.cpp20.containers]](diff.cpp20.containers)

#### C.2.13 [[thread]](thread "32 Concurrency support library"): concurrency support library [[diff.cpp20.thread]](diff.cpp20.thread)

### C.3 C++ and ISO C++ 2017 [[diff.cpp17]](diff.cpp17)

#### C.3.1 General [[diff.cpp17.general]](diff.cpp17.general)

#### C.3.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp17.lex]](diff.cpp17.lex)

#### C.3.3 [[basic]](basic "6 Basics"): basics [[diff.cpp17.basic]](diff.cpp17.basic)

#### C.3.4 [[expr]](expr "7 Expressions"): expressions [[diff.cpp17.expr]](diff.cpp17.expr)

#### C.3.5 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp17.dcl.dcl]](diff.cpp17.dcl.dcl)

#### C.3.6 [[class]](class "11 Classes"): classes [[diff.cpp17.class]](diff.cpp17.class)

#### C.3.7 [[over]](over "12 Overloading"): overloading [[diff.cpp17.over]](diff.cpp17.over)

#### C.3.8 [[temp]](temp "13 Templates"): templates [[diff.cpp17.temp]](diff.cpp17.temp)

#### C.3.9 [[except]](except "14 Exception handling"): exception handling [[diff.cpp17.except]](diff.cpp17.except)

#### C.3.10 [[library]](library "16 Library introduction"): library introduction [[diff.cpp17.library]](diff.cpp17.library)

#### C.3.11 [[containers]](containers "23 Containers library"): containers library [[diff.cpp17.containers]](diff.cpp17.containers)

#### C.3.12 [[iterators]](iterators "24 Iterators library"): iterators library [[diff.cpp17.iterators]](diff.cpp17.iterators)

#### C.3.13 [[algorithms]](algorithms "26 Algorithms library"): algorithms library [[diff.cpp17.alg.reqs]](diff.cpp17.alg.reqs)

#### C.3.14 [[input.output]](input.output "31 Input/output library"): input/output library [[diff.cpp17.input.output]](diff.cpp17.input.output)

#### C.3.15 [[depr]](depr "Annex D (normative) Compatibility features"): compatibility features [[diff.cpp17.depr]](diff.cpp17.depr)

### C.4 C++ and ISO C++ 2014 [[diff.cpp14]](diff.cpp14)

#### C.4.1 General [[diff.cpp14.general]](diff.cpp14.general)

#### C.4.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp14.lex]](diff.cpp14.lex)

#### C.4.3 [[expr]](expr "7 Expressions"): expressions [[diff.cpp14.expr]](diff.cpp14.expr)

#### C.4.4 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp14.dcl.dcl]](diff.cpp14.dcl.dcl)

#### C.4.5 [[class]](class "11 Classes"): classes [[diff.cpp14.class]](diff.cpp14.class)

#### C.4.6 [[temp]](temp "13 Templates"): templates [[diff.cpp14.temp]](diff.cpp14.temp)

#### C.4.7 [[except]](except "14 Exception handling"): exception handling [[diff.cpp14.except]](diff.cpp14.except)

#### C.4.8 [[library]](library "16 Library introduction"): library introduction [[diff.cpp14.library]](diff.cpp14.library)

#### C.4.9 [[utilities]](utilities "22 General utilities library"): general utilities library [[diff.cpp14.utilities]](diff.cpp14.utilities)

#### C.4.10 [[strings]](strings "27 Strings library"): strings library [[diff.cpp14.string]](diff.cpp14.string)

#### C.4.11 [[containers]](containers "23 Containers library"): containers library [[diff.cpp14.containers]](diff.cpp14.containers)

#### C.4.12 [[depr]](depr "Annex D (normative) Compatibility features"): compatibility features [[diff.cpp14.depr]](diff.cpp14.depr)

### C.5 C++ and ISO C++ 2011 [[diff.cpp11]](diff.cpp11)

#### C.5.1 General [[diff.cpp11.general]](diff.cpp11.general)

#### C.5.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp11.lex]](diff.cpp11.lex)

#### C.5.3 [[basic]](basic "6 Basics"): basics [[diff.cpp11.basic]](diff.cpp11.basic)

#### C.5.4 [[expr]](expr "7 Expressions"): expressions [[diff.cpp11.expr]](diff.cpp11.expr)

#### C.5.5 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp11.dcl.dcl]](diff.cpp11.dcl.dcl)

#### C.5.6 [[library]](library "16 Library introduction"): library introduction [[diff.cpp11.library]](diff.cpp11.library)

#### C.5.7 [[input.output]](input.output "31 Input/output library"): input/output library [[diff.cpp11.input.output]](diff.cpp11.input.output)

### C.6 C++ and ISO C++ 2003 [[diff.cpp03]](diff.cpp03)

#### C.6.1 General [[diff.cpp03.general]](diff.cpp03.general)

#### C.6.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.cpp03.lex]](diff.cpp03.lex)

#### C.6.3 [[expr]](expr "7 Expressions"): expressions [[diff.cpp03.expr]](diff.cpp03.expr)

#### C.6.4 [[dcl]](dcl "9 Declarations"): declarations [[diff.cpp03.dcl.dcl]](diff.cpp03.dcl.dcl)

#### C.6.5 [[class]](class "11 Classes"): classes [[diff.cpp03.class]](diff.cpp03.class)

#### C.6.6 [[temp]](temp "13 Templates"): templates [[diff.cpp03.temp]](diff.cpp03.temp)

#### C.6.7 [[library]](library "16 Library introduction"): library introduction [[diff.cpp03.library]](diff.cpp03.library)

#### C.6.8 [[support]](support "17 Language support library"):
language support library [[diff.cpp03.language.support]](diff.cpp03.language.support)

#### C.6.9 [[diagnostics]](diagnostics "19 Diagnostics library"): diagnostics library [[diff.cpp03.diagnostics]](diff.cpp03.diagnostics)

#### C.6.10 [[utilities]](utilities "22 General utilities library"): general utilities library [[diff.cpp03.utilities]](diff.cpp03.utilities)

#### C.6.11 [[strings]](strings "27 Strings library"): strings library [[diff.cpp03.strings]](diff.cpp03.strings)

#### C.6.12 [[containers]](containers "23 Containers library"): containers library [[diff.cpp03.containers]](diff.cpp03.containers)

#### C.6.13 [[algorithms]](algorithms "26 Algorithms library"): algorithms library [[diff.cpp03.algorithms]](diff.cpp03.algorithms)

#### C.6.14 [[numerics]](numerics "29 Numerics library"): numerics library [[diff.cpp03.numerics]](diff.cpp03.numerics)

#### C.6.15 [[localization]](localization "28.3 Localization library"): localization library [[diff.cpp03.locale]](diff.cpp03.locale)

#### C.6.16 [[input.output]](input.output "31 Input/output library"): input/output library [[diff.cpp03.input.output]](diff.cpp03.input.output)

### C.7 C++ and C [[diff.iso]](diff.iso)

#### C.7.1 General [[diff.iso.general]](diff.iso.general)

#### C.7.2 [[lex]](lex "5 Lexical conventions"): lexical conventions [[diff.lex]](diff.lex)

#### C.7.3 [[basic]](basic "6 Basics"): basics [[diff.basic]](diff.basic)

#### C.7.4 [[expr]](expr "7 Expressions"): expressions [[diff.expr]](diff.expr)

#### C.7.5 [[stmt]](stmt "8 Statements"): statements [[diff.stat]](diff.stat)

#### C.7.6 [[dcl]](dcl "9 Declarations"): declarations [[diff.dcl]](diff.dcl)

#### C.7.7 [[class]](class "11 Classes"): classes [[diff.class]](diff.class)

#### C.7.8 [[cpp]](cpp "15 Preprocessing directives"): preprocessing directives [[diff.cpp]](diff.cpp)

### C.8 C standard library [[diff.library]](diff.library)

#### C.8.1 General [[diff.library.general]](diff.library.general)

#### C.8.2 Modifications to headers [[diff.mods.to.headers]](diff.mods.to.headers)

#### C.8.3 Modifications to definitions [[diff.mods.to.definitions]](diff.mods.to.definitions)

#### C.8.3.1 Types char8_t, char16_t, and char32_t [[diff.char16]](diff.char16)

#### C.8.3.2 Type wchar_t [[diff.wchar.t]](diff.wchar.t)

#### C.8.3.3 Header <iso646.h> [[diff.header.iso646.h]](diff.header.iso646.h)

#### C.8.3.4 Macro NULL [[diff.null]](diff.null)

#### C.8.4 Modifications to declarations [[diff.mods.to.declarations]](diff.mods.to.declarations)

#### C.8.5 Modifications to behavior [[diff.mods.to.behavior]](diff.mods.to.behavior)

#### C.8.5.1 General [[diff.mods.to.behavior.general]](diff.mods.to.behavior.general)

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

#### C.8.5.3 Memory allocation functions [[diff.malloc]](diff.malloc)

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

### D.1 General [[depr.general]](depr.general)

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

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

### D.4 Deprecated volatile types [[depr.volatile.type]](depr.volatile.type)

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

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

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

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

### D.9 template keyword before qualified names [[depr.template.template]](depr.template.template)

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

### D.11 Deprecated C macros [[depr.c.macros]](depr.c.macros)

### D.12 Deprecated error numbers [[depr.cerrno]](depr.cerrno)

### D.13 Deprecated type traits [[depr.meta.types]](depr.meta.types)

### D.14 Relational operators [[depr.relops]](depr.relops)

### D.15 Tuple [[depr.tuple]](depr.tuple)

### D.16 Variant [[depr.variant]](depr.variant)

### D.17 Deprecated iterator class template [[depr.iterator]](depr.iterator)

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

### D.19 Deprecated locale category facets [[depr.locale.category]](depr.locale.category)

### D.20 Deprecated formatting [[depr.format]](depr.format)

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

#### D.20.2 Formatting arguments [[depr.format.arg]](depr.format.arg)

### D.21 Deprecated time formatting [[depr.ctime]](depr.ctime)

### D.22 Deprecated file systems [[depr.filesystems]](depr.filesystems)

#### D.22.1 Deprecated filesystem path factory functions [[depr.fs.path.factory]](depr.fs.path.factory)

#### D.22.2 Deprecated filesystem path format observers [[depr.fs.path.obs]](depr.fs.path.obs)

### D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics)

#### D.23.1 General [[depr.atomics.general]](depr.atomics.general)

#### D.23.2 Volatile access [[depr.atomics.volatile]](depr.atomics.volatile)

#### D.23.3 Non-member functions [[depr.atomics.nonmembers]](depr.atomics.nonmembers)

#### D.23.4 Operations on atomic types [[depr.atomics.types.operations]](depr.atomics.types.operations)

#### D.23.5 memory_order​::​consume [[depr.atomics.order]](depr.atomics.order)

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

### E.1 General [[uaxid.general]](uaxid.general)

### E.2 R1 Default identifiers [[uaxid.def]](uaxid.def)

#### E.2.1 General [[uaxid.def.general]](uaxid.def.general)

#### E.2.2 R1b Stable identifiers [[uaxid.def.stable]](uaxid.def.stable)

### E.3 R2 Immutable identifiers [[uaxid.immutable]](uaxid.immutable)

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

### E.5 R4 Equivalent normalized identifiers [[uaxid.eqn]](uaxid.eqn)

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

### E.7 R6 Filtered normalized identifiers [[uaxid.filter]](uaxid.filter)

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

### E.9 R8 Hashtag identifiers [[uaxid.hashtag]](uaxid.hashtag)

## [Bibliography](bibliography)

## [Index](generalindex)

## [Index of grammar productions](grammarindex)

## [Index of library headers](headerindex)

## [Index of library names](libraryindex)

## [Index of library concepts](conceptindex)

## [Index of implementation-defined behavior](impldefindex)