diff --git a/README.md b/README.md index b7aeb51..4df29d7 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,52 @@ - is the repository for -the C++ Technical Specification "Concurrency TS 2". +This came from which was the repository for +the C++ Technical Specification "Trannsactional Memory TS 2021" for N4906, the TM-TS2 from 2022-02-14: +https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4906.pdf +It was moved here on Oct 10, 2022 where it will be edited for the DTS ballot comments from P2617 +https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2617r0.html The draft Technical Specification is found in the `src` directory and is written in LaTeX. There is a Makefile that can be used to compile the sources, or you can use the `latexmk` program e.g. `latexmk -pdf ts` will generate a PDF. -\textbf{Concurrency TS2 Editor's Report} -\textbf{pre-Oct 2021 virtual Plenary meeting} +# TM TS2021 Editor's Report -N4895 is the proposed working draft of Concurrency TS Version 2. It contains changes to the Concurrency TS as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. +## pre-Kona Nov 2022 Plenary meeting N4923 -N4895 contains P1121R3 and P1122R4 from the June 2021 virtual plenary. +1. N4923 revises N4906 and is the DTS of Transactional Memory TS Version 2. It contains changes to the N4906 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. +2. N4923 revises N4906 with P2617R0 Responses to NB comments on TM-TS2 DTS 12907. It omits the symbolic references in P2517R0 in cross-references as is conventional in these documents and just use the numeric references. + +3. Other than the front matter changes, it also contains the following editorial changes: + + in Sec. 4.2: Michael Scott->Michael L. Scotts + + In 6.9.1 (Line 5.3), “start and the end of an atomic block” -> “start or the end of an atomic block” + + In 6.9.2.2 (Line 21), “An atomic block” -> “The execution of an atomic block” + + +## pre-Feb 2022 virtual Plenary meeting N4906 + +N4906 is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. + +N4895 contains P2066R10 from Oct 2021 virtual plenary. + +## Technical Changes -\textbf{Technical Changes} None -\textbf{Notes} +## Notes + None -\textbf{Acknowledgement} +## Acknowledgements + -Thank you to the Editing team of Michael Wong, Paul McKenney, Maged Michael, and Jens Maurer. +Hans Boehm +Victor Luchangco +Paul McKenney +Maged Michael +Jens Maurer +Michael L. Scott +Michael Spear +Michael Wong diff --git a/src/config.tex b/src/config.tex index 8a41179..87d2460 100644 --- a/src/config.tex +++ b/src/config.tex @@ -1,14 +1,14 @@ %!TEX root = ts.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{N4895} -\newcommand{\isodocno}{ISO/IEC ?????:2021(E)} -\newcommand{\prevdocno}{None} +\newcommand{\docno}{N4923} +\newcommand{\isodocno}{ISO/IEC 12907:2021(E)} +\newcommand{\prevdocno}{N4906} \newcommand{\cppver}{201703L @@@} %% MW: need update -\newcommand{\tsver}{202108} +\newcommand{\tsver}{202110} %% Title -\newcommand{\doctitle}{Extensions to \Cpp for Concurrency Version 2 @@@} +\newcommand{\doctitle}{Extensions to \Cpp for Transactional Memory Version 2 @@@} % \newcommand{\frtitle}{\Cpp Extensions for Concurrency} %% Release date diff --git a/src/cover-wd.tex b/src/cover-wd.tex index d5294c4..f2d5c7b 100644 --- a/src/cover-wd.tex +++ b/src/cover-wd.tex @@ -10,7 +10,7 @@ \textbf{Date:} & \reldate \\ \textbf{Revises:} & \prevdocno \\ \textbf{Reply to:} & Michael Wong \\ - & Codeplay \\ +%% & Codeplay %% \\ & fraggamuffin@gmail.com \end{tabular} } @@ -22,7 +22,7 @@ \vspace{2.5cm} \begin{center} \textbf{\Huge -Working Draft, Extensions to \Cpp for Concurrency Version 2} +White Paper, Extensions to {\Cpp} for Transactional Memory Version 2} \end{center} \vfill \textbf{Note: this is an early draft. It's known to be incomplet and diff --git a/src/cxx-sections.tex b/src/cxx-sections.tex new file mode 100644 index 0000000..79f1a9a --- /dev/null +++ b/src/cxx-sections.tex @@ -0,0 +1,2980 @@ +\cxxsec{algorithms}{Clause 25} +\cxxsec{algorithms.general}{25.1} +\cxxsec{tab:algorithms.summary}{91} +\cxxsec{algorithms.requirements}{25.2} +\cxxsec{algorithms.parallel}{25.3} +\cxxsec{algorithms.parallel.defns}{25.3.1} +\cxxsec{algorithms.parallel.user}{25.3.2} +\cxxsec{algorithms.parallel.exec}{25.3.3} +\cxxsec{algorithms.parallel.exceptions}{25.3.4} +\cxxsec{algorithms.parallel.overloads}{25.3.5} +\cxxsec{algorithm.syn}{25.4} +\cxxsec{algorithms.results}{25.5} +\cxxsec{alg.nonmodifying}{25.6} +\cxxsec{alg.all.of}{25.6.1} +\cxxsec{alg.any.of}{25.6.2} +\cxxsec{alg.none.of}{25.6.3} +\cxxsec{alg.foreach}{25.6.4} +\cxxsec{alg.find}{25.6.5} +\cxxsec{alg.find.end}{25.6.6} +\cxxsec{alg.find.first.of}{25.6.7} +\cxxsec{alg.adjacent.find}{25.6.8} +\cxxsec{alg.count}{25.6.9} +\cxxsec{mismatch}{25.6.10} +\cxxsec{alg.equal}{25.6.11} +\cxxsec{alg.is.permutation}{25.6.12} +\cxxsec{alg.search}{25.6.13} +\cxxsec{alg.modifying.operations}{25.7} +\cxxsec{alg.copy}{25.7.1} +\cxxsec{alg.move}{25.7.2} +\cxxsec{alg.swap}{25.7.3} +\cxxsec{alg.transform}{25.7.4} +\cxxsec{alg.replace}{25.7.5} +\cxxsec{alg.fill}{25.7.6} +\cxxsec{alg.generate}{25.7.7} +\cxxsec{alg.remove}{25.7.8} +\cxxsec{alg.unique}{25.7.9} +\cxxsec{alg.reverse}{25.7.10} +\cxxsec{alg.rotate}{25.7.11} +\cxxsec{alg.random.sample}{25.7.12} +\cxxsec{alg.random.shuffle}{25.7.13} +\cxxsec{alg.shift}{25.7.14} +\cxxsec{alg.sorting}{25.8} +\cxxsec{alg.sorting.general}{25.8.1} +\cxxsec{alg.sort}{25.8.2} +\cxxsec{sort}{25.8.2.1} +\cxxsec{stable.sort}{25.8.2.2} +\cxxsec{partial.sort}{25.8.2.3} +\cxxsec{partial.sort.copy}{25.8.2.4} +\cxxsec{is.sorted}{25.8.2.5} +\cxxsec{alg.nth.element}{25.8.3} +\cxxsec{alg.binary.search}{25.8.4} +\cxxsec{alg.binary.search.general}{25.8.4.1} +\cxxsec{lower.bound}{25.8.4.2} +\cxxsec{upper.bound}{25.8.4.3} +\cxxsec{equal.range}{25.8.4.4} +\cxxsec{binary.search}{25.8.4.5} +\cxxsec{alg.partitions}{25.8.5} +\cxxsec{alg.merge}{25.8.6} +\cxxsec{alg.set.operations}{25.8.7} +\cxxsec{alg.set.operations.general}{25.8.7.1} +\cxxsec{includes}{25.8.7.2} +\cxxsec{set.union}{25.8.7.3} +\cxxsec{set.intersection}{25.8.7.4} +\cxxsec{set.difference}{25.8.7.5} +\cxxsec{set.symmetric.difference}{25.8.7.6} +\cxxsec{alg.heap.operations}{25.8.8} +\cxxsec{alg.heap.operations.general}{25.8.8.1} +\cxxsec{push.heap}{25.8.8.2} +\cxxsec{pop.heap}{25.8.8.3} +\cxxsec{make.heap}{25.8.8.4} +\cxxsec{sort.heap}{25.8.8.5} +\cxxsec{is.heap}{25.8.8.6} +\cxxsec{alg.min.max}{25.8.9} +\cxxsec{alg.clamp}{25.8.10} +\cxxsec{alg.lex.comparison}{25.8.11} +\cxxsec{alg.three.way}{25.8.12} +\cxxsec{alg.permutation.generators}{25.8.13} +\cxxsec{numeric.ops.overview}{25.9} +\cxxsec{numeric.ops}{25.10} +\cxxsec{numeric.ops.general}{25.10.1} +\cxxsec{numerics.defns}{25.10.2} +\cxxsec{accumulate}{25.10.3} +\cxxsec{reduce}{25.10.4} +\cxxsec{inner.product}{25.10.5} +\cxxsec{transform.reduce}{25.10.6} +\cxxsec{partial.sum}{25.10.7} +\cxxsec{exclusive.scan}{25.10.8} +\cxxsec{inclusive.scan}{25.10.9} +\cxxsec{transform.exclusive.scan}{25.10.10} +\cxxsec{transform.inclusive.scan}{25.10.11} +\cxxsec{adjacent.difference}{25.10.12} +\cxxsec{numeric.iota}{25.10.13} +\cxxsec{numeric.ops.gcd}{25.10.14} +\cxxsec{numeric.ops.lcm}{25.10.15} +\cxxsec{numeric.ops.midpoint}{25.10.16} +\cxxsec{specialized.algorithms}{25.11} +\cxxsec{specialized.algorithms.general}{25.11.1} +\cxxsec{special.mem.concepts}{25.11.2} +\cxxsec{uninitialized.construct.default}{25.11.3} +\cxxsec{uninitialized.construct.value}{25.11.4} +\cxxsec{uninitialized.copy}{25.11.5} +\cxxsec{uninitialized.move}{25.11.6} +\cxxsec{uninitialized.fill}{25.11.7} +\cxxsec{specialized.construct}{25.11.8} +\cxxsec{specialized.destroy}{25.11.9} +\cxxsec{alg.c.library}{25.12} +\cxxsec{atomics}{Clause 31} +\cxxsec{atomics.general}{31.1} +\cxxsec{tab:atomics.summary}{143} +\cxxsec{atomics.syn}{31.2} +\cxxsec{atomics.alias}{31.3} +\cxxsec{atomics.order}{31.4} +\cxxsec{atomics.lockfree}{31.5} +\cxxsec{atomics.wait}{31.6} +\cxxsec{atomics.ref.generic}{31.7} +\cxxsec{atomics.ref.generic.general}{31.7.1} +\cxxsec{atomics.ref.ops}{31.7.2} +\cxxsec{atomics.ref.int}{31.7.3} +\cxxsec{atomics.ref.float}{31.7.4} +\cxxsec{atomics.ref.pointer}{31.7.5} +\cxxsec{atomics.ref.memop}{31.7.6} +\cxxsec{atomics.types.generic}{31.8} +\cxxsec{atomics.types.generic.general}{31.8.1} +\cxxsec{atomics.types.operations}{31.8.2} +\cxxsec{atomics.types.int}{31.8.3} +\cxxsec{tab:atomic.types.int.comp}{144} +\cxxsec{atomics.types.float}{31.8.4} +\cxxsec{atomics.types.pointer}{31.8.5} +\cxxsec{tab:atomic.types.pointer.comp}{145} +\cxxsec{atomics.types.memop}{31.8.6} +\cxxsec{util.smartptr.atomic}{31.8.7} +\cxxsec{util.smartptr.atomic.general}{31.8.7.1} +\cxxsec{util.smartptr.atomic.shared}{31.8.7.2} +\cxxsec{util.smartptr.atomic.weak}{31.8.7.3} +\cxxsec{atomics.nonmembers}{31.9} +\cxxsec{atomics.flag}{31.10} +\cxxsec{atomics.fences}{31.11} +\cxxsec{idx.general.Symbols}{D.25.5} +\cxxsec{idx.general.Numbers}{D.25.5} +\cxxsec{idx.general.A}{D.25.5} +\cxxsec{idx.general.B}{D.25.5} +\cxxsec{idx.general.C}{D.25.5} +\cxxsec{idx.general.D}{D.25.5} +\cxxsec{idx.general.E}{D.25.5} +\cxxsec{idx.general.F}{D.25.5} +\cxxsec{idx.general.G}{D.25.5} +\cxxsec{idx.general.H}{D.25.5} +\cxxsec{idx.general.I}{D.25.5} +\cxxsec{idx.general.J}{D.25.5} +\cxxsec{idx.general.K}{D.25.5} +\cxxsec{idx.general.L}{D.25.5} +\cxxsec{idx.general.M}{D.25.5} +\cxxsec{idx.general.N}{D.25.5} +\cxxsec{idx.general.O}{D.25.5} +\cxxsec{idx.general.P}{D.25.5} +\cxxsec{idx.general.Q}{D.25.5} +\cxxsec{idx.general.R}{D.25.5} +\cxxsec{idx.general.S}{D.25.5} +\cxxsec{idx.general.T}{D.25.5} +\cxxsec{idx.general.U}{D.25.5} +\cxxsec{idx.general.V}{D.25.5} +\cxxsec{idx.general.W}{D.25.5} +\cxxsec{idx.general.X}{D.25.5} +\cxxsec{idx.general.Y}{D.25.5} +\cxxsec{idx.general.Z}{D.25.5} +\cxxsec{idx.library.Symbols}{D.25.5} +\cxxsec{idx.library.Numbers}{D.25.5} +\cxxsec{idx.library.A}{D.25.5} +\cxxsec{idx.library.B}{D.25.5} +\cxxsec{idx.library.C}{D.25.5} +\cxxsec{idx.library.D}{D.25.5} +\cxxsec{idx.library.E}{D.25.5} +\cxxsec{idx.library.F}{D.25.5} +\cxxsec{idx.library.G}{D.25.5} +\cxxsec{idx.library.H}{D.25.5} +\cxxsec{idx.library.I}{D.25.5} +\cxxsec{idx.library.J}{D.25.5} +\cxxsec{idx.library.K}{D.25.5} +\cxxsec{idx.library.L}{D.25.5} +\cxxsec{idx.library.M}{D.25.5} +\cxxsec{idx.library.N}{D.25.5} +\cxxsec{idx.library.O}{D.25.5} +\cxxsec{idx.library.P}{D.25.5} +\cxxsec{idx.library.Q}{D.25.5} +\cxxsec{idx.library.R}{D.25.5} +\cxxsec{idx.library.S}{D.25.5} +\cxxsec{idx.library.T}{D.25.5} +\cxxsec{idx.library.U}{D.25.5} +\cxxsec{idx.library.V}{D.25.5} +\cxxsec{idx.library.W}{D.25.5} +\cxxsec{idx.library.X}{D.25.5} +\cxxsec{idx.library.Y}{D.25.5} +\cxxsec{idx.library.Z}{D.25.5} +\cxxsec{basic}{Clause 6} +\cxxsec{basic.pre}{6.1} +\cxxsec{basic.def}{6.2} +\cxxsec{basic.def.odr}{6.3} +\cxxsec{basic.scope}{6.4} +\cxxsec{basic.scope.declarative}{6.4.1} +\cxxsec{basic.scope.pdecl}{6.4.2} +\cxxsec{basic.scope.block}{6.4.3} +\cxxsec{basic.scope.param}{6.4.4} +\cxxsec{basic.funscope}{6.4.5} +\cxxsec{basic.scope.namespace}{6.4.6} +\cxxsec{basic.scope.class}{6.4.7} +\cxxsec{basic.scope.enum}{6.4.8} +\cxxsec{basic.scope.temp}{6.4.9} +\cxxsec{basic.scope.hiding}{6.4.10} +\cxxsec{basic.lookup}{6.5} +\cxxsec{basic.lookup.general}{6.5.1} +\cxxsec{basic.lookup.unqual}{6.5.2} +\cxxsec{basic.lookup.argdep}{6.5.3} +\cxxsec{basic.lookup.qual}{6.5.4} +\cxxsec{basic.lookup.qual.general}{6.5.4.1} +\cxxsec{class.qual}{6.5.4.2} +\cxxsec{namespace.qual}{6.5.4.3} +\cxxsec{basic.lookup.elab}{6.5.5} +\cxxsec{basic.lookup.classref}{6.5.6} +\cxxsec{basic.lookup.udir}{6.5.7} +\cxxsec{basic.link}{6.6} +\cxxsec{basic.memobj}{6.7} +\cxxsec{intro.memory}{6.7.1} +\cxxsec{intro.object}{6.7.2} +\cxxsec{basic.life}{6.7.3} +\cxxsec{basic.indet}{6.7.4} +\cxxsec{basic.stc}{6.7.5} +\cxxsec{basic.stc.general}{6.7.5.1} +\cxxsec{basic.stc.static}{6.7.5.2} +\cxxsec{basic.stc.thread}{6.7.5.3} +\cxxsec{basic.stc.auto}{6.7.5.4} +\cxxsec{basic.stc.dynamic}{6.7.5.5} +\cxxsec{basic.stc.dynamic.general}{6.7.5.5.1} +\cxxsec{basic.stc.dynamic.allocation}{6.7.5.5.2} +\cxxsec{basic.stc.dynamic.deallocation}{6.7.5.5.3} +\cxxsec{basic.stc.dynamic.safety}{6.7.5.5.4} +\cxxsec{basic.stc.inherit}{6.7.5.6} +\cxxsec{basic.align}{6.7.6} +\cxxsec{class.temporary}{6.7.7} +\cxxsec{basic.types}{6.8} +\cxxsec{basic.types.general}{6.8.1} +\cxxsec{basic.fundamental}{6.8.2} +\cxxsec{tab:basic.fundamental.width}{12} +\cxxsec{basic.compound}{6.8.3} +\cxxsec{basic.type.qualifier}{6.8.4} +\cxxsec{tab:basic.type.qualifier.rel}{13} +\cxxsec{conv.rank}{6.8.5} +\cxxsec{basic.exec}{6.9} +\cxxsec{intro.execution}{6.9.1} +\cxxsec{intro.multithread}{6.9.2} +\cxxsec{intro.multithread.general}{6.9.2.1} +\cxxsec{intro.races}{6.9.2.2} +\cxxsec{intro.progress}{6.9.2.3} +\cxxsec{basic.start}{6.9.3} +\cxxsec{basic.start.main}{6.9.3.1} +\cxxsec{basic.start.static}{6.9.3.2} +\cxxsec{basic.start.dynamic}{6.9.3.3} +\cxxsec{basic.start.term}{6.9.3.4} +\cxxsec{class}{Clause 11} +\cxxsec{class.pre}{11.1} +\cxxsec{class.prop}{11.2} +\cxxsec{class.name}{11.3} +\cxxsec{class.mem}{11.4} +\cxxsec{class.mem.general}{11.4.1} +\cxxsec{class.mfct}{11.4.2} +\cxxsec{class.mfct.non-static}{11.4.3} +\cxxsec{class.mfct.non-static.general}{11.4.3.1} +\cxxsec{class.this}{11.4.3.2} +\cxxsec{special}{11.4.4} +\cxxsec{class.ctor}{11.4.5} +\cxxsec{class.ctor.general}{11.4.5.1} +\cxxsec{class.default.ctor}{11.4.5.2} +\cxxsec{class.copy.ctor}{11.4.5.3} +\cxxsec{class.copy.assign}{11.4.6} +\cxxsec{class.dtor}{11.4.7} +\cxxsec{class.conv}{11.4.8} +\cxxsec{class.conv.general}{11.4.8.1} +\cxxsec{class.conv.ctor}{11.4.8.2} +\cxxsec{class.conv.fct}{11.4.8.3} +\cxxsec{class.static}{11.4.9} +\cxxsec{class.static.general}{11.4.9.1} +\cxxsec{class.static.mfct}{11.4.9.2} +\cxxsec{class.static.data}{11.4.9.3} +\cxxsec{class.bit}{11.4.10} +\cxxsec{class.nest}{11.4.11} +\cxxsec{class.nested.type}{11.4.12} +\cxxsec{class.union}{11.5} +\cxxsec{class.union.general}{11.5.1} +\cxxsec{class.union.anon}{11.5.2} +\cxxsec{class.local}{11.6} +\cxxsec{class.derived}{11.7} +\cxxsec{class.derived.general}{11.7.1} +\cxxsec{fig:class.dag}{2} +\cxxsec{class.mi}{11.7.2} +\cxxsec{fig:class.nonvirt}{3} +\cxxsec{fig:class.virt}{4} +\cxxsec{fig:class.virtnonvirt}{5} +\cxxsec{class.virtual}{11.7.3} +\cxxsec{class.abstract}{11.7.4} +\cxxsec{class.member.lookup}{11.8} +\cxxsec{fig:class.lookup}{6} +\cxxsec{class.access}{11.9} +\cxxsec{class.access.general}{11.9.1} +\cxxsec{class.access.spec}{11.9.2} +\cxxsec{class.access.base}{11.9.3} +\cxxsec{class.friend}{11.9.4} +\cxxsec{class.protected}{11.9.5} +\cxxsec{class.access.virt}{11.9.6} +\cxxsec{class.paths}{11.9.7} +\cxxsec{class.access.nest}{11.9.8} +\cxxsec{class.init}{11.10} +\cxxsec{class.init.general}{11.10.1} +\cxxsec{class.expl.init}{11.10.2} +\cxxsec{class.base.init}{11.10.3} +\cxxsec{class.inhctor.init}{11.10.4} +\cxxsec{class.cdtor}{11.10.5} +\cxxsec{class.copy.elision}{11.10.6} +\cxxsec{class.compare}{11.11} +\cxxsec{class.compare.default}{11.11.1} +\cxxsec{class.eq}{11.11.2} +\cxxsec{class.spaceship}{11.11.3} +\cxxsec{class.compare.secondary}{11.11.4} +\cxxsec{class.free}{11.12} +\cxxsec{diff}{Annex C} +\cxxsec{diff.cpp17}{C.1} +\cxxsec{diff.cpp17.general}{C.1.1} +\cxxsec{diff.cpp17.lex}{C.1.2} +\cxxsec{diff.cpp17.basic}{C.1.3} +\cxxsec{diff.cpp17.expr}{C.1.4} +\cxxsec{diff.cpp17.dcl.dcl}{C.1.5} +\cxxsec{diff.cpp17.class}{C.1.6} +\cxxsec{diff.cpp17.over}{C.1.7} +\cxxsec{diff.cpp17.temp}{C.1.8} +\cxxsec{diff.cpp17.except}{C.1.9} +\cxxsec{diff.cpp17.library}{C.1.10} +\cxxsec{diff.cpp17.containers}{C.1.11} +\cxxsec{diff.cpp17.iterators}{C.1.12} +\cxxsec{diff.cpp17.alg.reqs}{C.1.13} +\cxxsec{diff.cpp17.input.output}{C.1.14} +\cxxsec{diff.cpp17.depr}{C.1.15} +\cxxsec{diff.cpp14}{C.2} +\cxxsec{diff.cpp14.general}{C.2.1} +\cxxsec{diff.cpp14.lex}{C.2.2} +\cxxsec{diff.cpp14.expr}{C.2.3} +\cxxsec{diff.cpp14.dcl.dcl}{C.2.4} +\cxxsec{diff.cpp14.class}{C.2.5} +\cxxsec{diff.cpp14.temp}{C.2.6} +\cxxsec{diff.cpp14.except}{C.2.7} +\cxxsec{diff.cpp14.library}{C.2.8} +\cxxsec{diff.cpp14.utilities}{C.2.9} +\cxxsec{diff.cpp14.string}{C.2.10} +\cxxsec{diff.cpp14.containers}{C.2.11} +\cxxsec{diff.cpp14.depr}{C.2.12} +\cxxsec{diff.cpp11}{C.3} +\cxxsec{diff.cpp11.general}{C.3.1} +\cxxsec{diff.cpp11.lex}{C.3.2} +\cxxsec{diff.cpp11.basic}{C.3.3} +\cxxsec{diff.cpp11.expr}{C.3.4} +\cxxsec{diff.cpp11.dcl.dcl}{C.3.5} +\cxxsec{diff.cpp11.library}{C.3.6} +\cxxsec{diff.cpp11.input.output}{C.3.7} +\cxxsec{diff.cpp03}{C.4} +\cxxsec{diff.cpp03.general}{C.4.1} +\cxxsec{diff.cpp03.lex}{C.4.2} +\cxxsec{diff.cpp03.expr}{C.4.3} +\cxxsec{diff.cpp03.dcl.dcl}{C.4.4} +\cxxsec{diff.cpp03.class}{C.4.5} +\cxxsec{diff.cpp03.temp}{C.4.6} +\cxxsec{diff.cpp03.library}{C.4.7} +\cxxsec{diff.cpp03.language.support}{C.4.8} +\cxxsec{diff.cpp03.diagnostics}{C.4.9} +\cxxsec{diff.cpp03.utilities}{C.4.10} +\cxxsec{diff.cpp03.strings}{C.4.11} +\cxxsec{diff.cpp03.containers}{C.4.12} +\cxxsec{diff.cpp03.algorithms}{C.4.13} +\cxxsec{diff.cpp03.numerics}{C.4.14} +\cxxsec{diff.cpp03.input.output}{C.4.15} +\cxxsec{diff.iso}{C.5} +\cxxsec{diff.iso.general}{C.5.1} +\cxxsec{diff.lex}{C.5.2} +\cxxsec{diff.basic}{C.5.3} +\cxxsec{diff.expr}{C.5.4} +\cxxsec{diff.stat}{C.5.5} +\cxxsec{diff.dcl}{C.5.6} +\cxxsec{diff.class}{C.5.7} +\cxxsec{diff.cpp}{C.5.8} +\cxxsec{diff.library}{C.6} +\cxxsec{diff.library.general}{C.6.1} +\cxxsec{diff.mods.to.headers}{C.6.2} +\cxxsec{diff.mods.to.definitions}{C.6.3} +\cxxsec{diff.char16}{C.6.3.1} +\cxxsec{diff.wchar.t}{C.6.3.2} +\cxxsec{diff.header.assert.h}{C.6.3.3} +\cxxsec{diff.header.iso646.h}{C.6.3.4} +\cxxsec{diff.header.stdalign.h}{C.6.3.5} +\cxxsec{diff.header.stdbool.h}{C.6.3.6} +\cxxsec{diff.null}{C.6.3.7} +\cxxsec{diff.mods.to.declarations}{C.6.4} +\cxxsec{diff.mods.to.behavior}{C.6.5} +\cxxsec{diff.mods.to.behavior.general}{C.6.5.1} +\cxxsec{diff.offsetof}{C.6.5.2} +\cxxsec{diff.malloc}{C.6.5.3} +\cxxsec{concepts}{Clause 18} +\cxxsec{concepts.general}{18.1} +\cxxsec{tab:concepts.summary}{39} +\cxxsec{concepts.equality}{18.2} +\cxxsec{concepts.syn}{18.3} +\cxxsec{concepts.lang}{18.4} +\cxxsec{concepts.lang.general}{18.4.1} +\cxxsec{concept.same}{18.4.2} +\cxxsec{concept.derived}{18.4.3} +\cxxsec{concept.convertible}{18.4.4} +\cxxsec{concept.commonref}{18.4.5} +\cxxsec{concept.common}{18.4.6} +\cxxsec{concepts.arithmetic}{18.4.7} +\cxxsec{concept.assignable}{18.4.8} +\cxxsec{concept.swappable}{18.4.9} +\cxxsec{concept.destructible}{18.4.10} +\cxxsec{concept.constructible}{18.4.11} +\cxxsec{concept.default.init}{18.4.12} +\cxxsec{concept.moveconstructible}{18.4.13} +\cxxsec{concept.copyconstructible}{18.4.14} +\cxxsec{concepts.compare}{18.5} +\cxxsec{concepts.compare.general}{18.5.1} +\cxxsec{concept.booleantestable}{18.5.2} +\cxxsec{concept.equalitycomparable}{18.5.3} +\cxxsec{concept.totallyordered}{18.5.4} +\cxxsec{concepts.object}{18.6} +\cxxsec{concepts.callable}{18.7} +\cxxsec{concepts.callable.general}{18.7.1} +\cxxsec{concept.invocable}{18.7.2} +\cxxsec{concept.regularinvocable}{18.7.3} +\cxxsec{concept.predicate}{18.7.4} +\cxxsec{concept.relation}{18.7.5} +\cxxsec{concept.equiv}{18.7.6} +\cxxsec{concept.strictweakorder}{18.7.7} +\cxxsec{containers}{Clause 22} +\cxxsec{containers.general}{22.1} +\cxxsec{tab:containers.summary}{72} +\cxxsec{container.requirements}{22.2} +\cxxsec{container.requirements.general}{22.2.1} +\cxxsec{tab:container.req}{73} +\cxxsec{tab:container.rev.req}{74} +\cxxsec{tab:container.opt}{75} +\cxxsec{tab:container.alloc.req}{76} +\cxxsec{container.requirements.dataraces}{22.2.2} +\cxxsec{sequence.reqmts}{22.2.3} +\cxxsec{tab:container.seq.req}{77} +\cxxsec{tab:container.seq.opt}{78} +\cxxsec{container.node}{22.2.4} +\cxxsec{container.node.overview}{22.2.4.1} +\cxxsec{tab:container.node.compat}{79} +\cxxsec{container.node.cons}{22.2.4.2} +\cxxsec{container.node.dtor}{22.2.4.3} +\cxxsec{container.node.observers}{22.2.4.4} +\cxxsec{container.node.modifiers}{22.2.4.5} +\cxxsec{container.insert.return}{22.2.5} +\cxxsec{associative.reqmts}{22.2.6} +\cxxsec{associative.reqmts.general}{22.2.6.1} +\cxxsec{tab:container.assoc.req}{80} +\cxxsec{associative.reqmts.except}{22.2.6.2} +\cxxsec{unord.req}{22.2.7} +\cxxsec{unord.req.general}{22.2.7.1} +\cxxsec{tab:container.hash.req}{81} +\cxxsec{unord.req.except}{22.2.7.2} +\cxxsec{sequences}{22.3} +\cxxsec{sequences.general}{22.3.1} +\cxxsec{array.syn}{22.3.2} +\cxxsec{deque.syn}{22.3.3} +\cxxsec{forward.list.syn}{22.3.4} +\cxxsec{list.syn}{22.3.5} +\cxxsec{vector.syn}{22.3.6} +\cxxsec{array}{22.3.7} +\cxxsec{array.overview}{22.3.7.1} +\cxxsec{array.cons}{22.3.7.2} +\cxxsec{array.members}{22.3.7.3} +\cxxsec{array.special}{22.3.7.4} +\cxxsec{array.zero}{22.3.7.5} +\cxxsec{array.creation}{22.3.7.6} +\cxxsec{array.tuple}{22.3.7.7} +\cxxsec{deque}{22.3.8} +\cxxsec{deque.overview}{22.3.8.1} +\cxxsec{deque.cons}{22.3.8.2} +\cxxsec{deque.capacity}{22.3.8.3} +\cxxsec{deque.modifiers}{22.3.8.4} +\cxxsec{deque.erasure}{22.3.8.5} +\cxxsec{forwardlist}{22.3.9} +\cxxsec{forwardlist.overview}{22.3.9.1} +\cxxsec{forwardlist.cons}{22.3.9.2} +\cxxsec{forwardlist.iter}{22.3.9.3} +\cxxsec{forwardlist.access}{22.3.9.4} +\cxxsec{forwardlist.modifiers}{22.3.9.5} +\cxxsec{forwardlist.ops}{22.3.9.6} +\cxxsec{forward.list.erasure}{22.3.9.7} +\cxxsec{list}{22.3.10} +\cxxsec{list.overview}{22.3.10.1} +\cxxsec{list.cons}{22.3.10.2} +\cxxsec{list.capacity}{22.3.10.3} +\cxxsec{list.modifiers}{22.3.10.4} +\cxxsec{list.ops}{22.3.10.5} +\cxxsec{list.erasure}{22.3.10.6} +\cxxsec{vector}{22.3.11} +\cxxsec{vector.overview}{22.3.11.1} +\cxxsec{vector.cons}{22.3.11.2} +\cxxsec{vector.capacity}{22.3.11.3} +\cxxsec{vector.data}{22.3.11.4} +\cxxsec{vector.modifiers}{22.3.11.5} +\cxxsec{vector.erasure}{22.3.11.6} +\cxxsec{vector.bool}{22.3.12} +\cxxsec{associative}{22.4} +\cxxsec{associative.general}{22.4.1} +\cxxsec{associative.map.syn}{22.4.2} +\cxxsec{associative.set.syn}{22.4.3} +\cxxsec{map}{22.4.4} +\cxxsec{map.overview}{22.4.4.1} +\cxxsec{map.cons}{22.4.4.2} +\cxxsec{map.access}{22.4.4.3} +\cxxsec{map.modifiers}{22.4.4.4} +\cxxsec{map.erasure}{22.4.4.5} +\cxxsec{multimap}{22.4.5} +\cxxsec{multimap.overview}{22.4.5.1} +\cxxsec{multimap.cons}{22.4.5.2} +\cxxsec{multimap.modifiers}{22.4.5.3} +\cxxsec{multimap.erasure}{22.4.5.4} +\cxxsec{set}{22.4.6} +\cxxsec{set.overview}{22.4.6.1} +\cxxsec{set.cons}{22.4.6.2} +\cxxsec{set.erasure}{22.4.6.3} +\cxxsec{multiset}{22.4.7} +\cxxsec{multiset.overview}{22.4.7.1} +\cxxsec{multiset.cons}{22.4.7.2} +\cxxsec{multiset.erasure}{22.4.7.3} +\cxxsec{unord}{22.5} +\cxxsec{unord.general}{22.5.1} +\cxxsec{unord.map.syn}{22.5.2} +\cxxsec{unord.set.syn}{22.5.3} +\cxxsec{unord.map}{22.5.4} +\cxxsec{unord.map.overview}{22.5.4.1} +\cxxsec{unord.map.cnstr}{22.5.4.2} +\cxxsec{unord.map.elem}{22.5.4.3} +\cxxsec{unord.map.modifiers}{22.5.4.4} +\cxxsec{unord.map.erasure}{22.5.4.5} +\cxxsec{unord.multimap}{22.5.5} +\cxxsec{unord.multimap.overview}{22.5.5.1} +\cxxsec{unord.multimap.cnstr}{22.5.5.2} +\cxxsec{unord.multimap.modifiers}{22.5.5.3} +\cxxsec{unord.multimap.erasure}{22.5.5.4} +\cxxsec{unord.set}{22.5.6} +\cxxsec{unord.set.overview}{22.5.6.1} +\cxxsec{unord.set.cnstr}{22.5.6.2} +\cxxsec{unord.set.erasure}{22.5.6.3} +\cxxsec{unord.multiset}{22.5.7} +\cxxsec{unord.multiset.overview}{22.5.7.1} +\cxxsec{unord.multiset.cnstr}{22.5.7.2} +\cxxsec{unord.multiset.erasure}{22.5.7.3} +\cxxsec{container.adaptors}{22.6} +\cxxsec{container.adaptors.general}{22.6.1} +\cxxsec{queue.syn}{22.6.2} +\cxxsec{stack.syn}{22.6.3} +\cxxsec{queue}{22.6.4} +\cxxsec{queue.defn}{22.6.4.1} +\cxxsec{queue.cons}{22.6.4.2} +\cxxsec{queue.cons.alloc}{22.6.4.3} +\cxxsec{queue.ops}{22.6.4.4} +\cxxsec{queue.special}{22.6.4.5} +\cxxsec{priority.queue}{22.6.5} +\cxxsec{priqueue.overview}{22.6.5.1} +\cxxsec{priqueue.cons}{22.6.5.2} +\cxxsec{priqueue.cons.alloc}{22.6.5.3} +\cxxsec{priqueue.members}{22.6.5.4} +\cxxsec{priqueue.special}{22.6.5.5} +\cxxsec{stack}{22.6.6} +\cxxsec{stack.general}{22.6.6.1} +\cxxsec{stack.defn}{22.6.6.2} +\cxxsec{stack.cons}{22.6.6.3} +\cxxsec{stack.cons.alloc}{22.6.6.4} +\cxxsec{stack.ops}{22.6.6.5} +\cxxsec{stack.special}{22.6.6.6} +\cxxsec{views}{22.7} +\cxxsec{views.general}{22.7.1} +\cxxsec{span.syn}{22.7.2} +\cxxsec{views.span}{22.7.3} +\cxxsec{span.overview}{22.7.3.1} +\cxxsec{span.cons}{22.7.3.2} +\cxxsec{span.deduct}{22.7.3.3} +\cxxsec{span.sub}{22.7.3.4} +\cxxsec{span.obs}{22.7.3.5} +\cxxsec{span.elem}{22.7.3.6} +\cxxsec{span.iterators}{22.7.3.7} +\cxxsec{span.objectrep}{22.7.3.8} +\cxxsec{dcl.dcl}{Clause 9} +\cxxsec{dcl.pre}{9.1} +\cxxsec{dcl.spec}{9.2} +\cxxsec{dcl.spec.general}{9.2.1} +\cxxsec{dcl.stc}{9.2.2} +\cxxsec{dcl.fct.spec}{9.2.3} +\cxxsec{dcl.typedef}{9.2.4} +\cxxsec{dcl.friend}{9.2.5} +\cxxsec{dcl.constexpr}{9.2.6} +\cxxsec{dcl.constinit}{9.2.7} +\cxxsec{dcl.inline}{9.2.8} +\cxxsec{dcl.type}{9.2.9} +\cxxsec{dcl.type.general}{9.2.9.1} +\cxxsec{dcl.type.cv}{9.2.9.2} +\cxxsec{dcl.type.simple}{9.2.9.3} +\cxxsec{dcl.type.elab}{9.2.9.4} +\cxxsec{tab:dcl.type.simple}{14} +\cxxsec{dcl.type.decltype}{9.2.9.5} +\cxxsec{dcl.spec.auto}{9.2.9.6} +\cxxsec{dcl.spec.auto.general}{9.2.9.6.1} +\cxxsec{dcl.type.auto.deduct}{9.2.9.6.2} +\cxxsec{dcl.type.class.deduct}{9.2.9.7} +\cxxsec{dcl.decl}{9.3} +\cxxsec{dcl.decl.general}{9.3.1} +\cxxsec{dcl.name}{9.3.2} +\cxxsec{dcl.ambig.res}{9.3.3} +\cxxsec{dcl.meaning}{9.3.4} +\cxxsec{dcl.meaning.general}{9.3.4.1} +\cxxsec{dcl.ptr}{9.3.4.2} +\cxxsec{dcl.ref}{9.3.4.3} +\cxxsec{dcl.mptr}{9.3.4.4} +\cxxsec{dcl.array}{9.3.4.5} +\cxxsec{dcl.fct}{9.3.4.6} +\cxxsec{dcl.fct.default}{9.3.4.7} +\cxxsec{dcl.init}{9.4} +\cxxsec{dcl.init.general}{9.4.1} +\cxxsec{dcl.init.aggr}{9.4.2} +\cxxsec{dcl.init.string}{9.4.3} +\cxxsec{dcl.init.ref}{9.4.4} +\cxxsec{dcl.init.list}{9.4.5} +\cxxsec{dcl.fct.def}{9.5} +\cxxsec{dcl.fct.def.general}{9.5.1} +\cxxsec{dcl.fct.def.default}{9.5.2} +\cxxsec{dcl.fct.def.delete}{9.5.3} +\cxxsec{dcl.fct.def.coroutine}{9.5.4} +\cxxsec{dcl.struct.bind}{9.6} +\cxxsec{enum}{9.7} +\cxxsec{dcl.enum}{9.7.1} +\cxxsec{enum.udecl}{9.7.2} +\cxxsec{basic.namespace}{9.8} +\cxxsec{basic.namespace.general}{9.8.1} +\cxxsec{namespace.def}{9.8.2} +\cxxsec{namespace.def.general}{9.8.2.1} +\cxxsec{namespace.unnamed}{9.8.2.2} +\cxxsec{namespace.memdef}{9.8.2.3} +\cxxsec{namespace.alias}{9.8.3} +\cxxsec{namespace.udir}{9.8.4} +\cxxsec{namespace.udecl}{9.9} +\cxxsec{dcl.asm}{9.10} +\cxxsec{dcl.link}{9.11} +\cxxsec{dcl.attr}{9.12} +\cxxsec{dcl.attr.grammar}{9.12.1} +\cxxsec{dcl.align}{9.12.2} +\cxxsec{dcl.attr.depend}{9.12.3} +\cxxsec{dcl.attr.deprecated}{9.12.4} +\cxxsec{dcl.attr.fallthrough}{9.12.5} +\cxxsec{dcl.attr.likelihood}{9.12.6} +\cxxsec{dcl.attr.unused}{9.12.7} +\cxxsec{dcl.attr.nodiscard}{9.12.8} +\cxxsec{dcl.attr.noreturn}{9.12.9} +\cxxsec{dcl.attr.nouniqueaddr}{9.12.10} +\cxxsec{diagnostics}{Clause 19} +\cxxsec{diagnostics.general}{19.1} +\cxxsec{tab:diagnostics.summary}{40} +\cxxsec{std.exceptions}{19.2} +\cxxsec{std.exceptions.general}{19.2.1} +\cxxsec{stdexcept.syn}{19.2.2} +\cxxsec{logic.error}{19.2.3} +\cxxsec{domain.error}{19.2.4} +\cxxsec{invalid.argument}{19.2.5} +\cxxsec{length.error}{19.2.6} +\cxxsec{out.of.range}{19.2.7} +\cxxsec{runtime.error}{19.2.8} +\cxxsec{range.error}{19.2.9} +\cxxsec{overflow.error}{19.2.10} +\cxxsec{underflow.error}{19.2.11} +\cxxsec{assertions}{19.3} +\cxxsec{assertions.general}{19.3.1} +\cxxsec{cassert.syn}{19.3.2} +\cxxsec{assertions.assert}{19.3.3} +\cxxsec{errno}{19.4} +\cxxsec{errno.general}{19.4.1} +\cxxsec{cerrno.syn}{19.4.2} +\cxxsec{syserr}{19.5} +\cxxsec{syserr.general}{19.5.1} +\cxxsec{system.error.syn}{19.5.2} +\cxxsec{syserr.errcat}{19.5.3} +\cxxsec{syserr.errcat.overview}{19.5.3.1} +\cxxsec{syserr.errcat.virtuals}{19.5.3.2} +\cxxsec{syserr.errcat.nonvirtuals}{19.5.3.3} +\cxxsec{syserr.errcat.derived}{19.5.3.4} +\cxxsec{syserr.errcat.objects}{19.5.3.5} +\cxxsec{syserr.errcode}{19.5.4} +\cxxsec{syserr.errcode.overview}{19.5.4.1} +\cxxsec{syserr.errcode.constructors}{19.5.4.2} +\cxxsec{syserr.errcode.modifiers}{19.5.4.3} +\cxxsec{syserr.errcode.observers}{19.5.4.4} +\cxxsec{syserr.errcode.nonmembers}{19.5.4.5} +\cxxsec{syserr.errcondition}{19.5.5} +\cxxsec{syserr.errcondition.overview}{19.5.5.1} +\cxxsec{syserr.errcondition.constructors}{19.5.5.2} +\cxxsec{syserr.errcondition.modifiers}{19.5.5.3} +\cxxsec{syserr.errcondition.observers}{19.5.5.4} +\cxxsec{syserr.errcondition.nonmembers}{19.5.5.5} +\cxxsec{syserr.compare}{19.5.6} +\cxxsec{syserr.hash}{19.5.7} +\cxxsec{syserr.syserr}{19.5.8} +\cxxsec{syserr.syserr.overview}{19.5.8.1} +\cxxsec{syserr.syserr.members}{19.5.8.2} +\cxxsec{except}{Clause 14} +\cxxsec{except.pre}{14.1} +\cxxsec{except.throw}{14.2} +\cxxsec{except.ctor}{14.3} +\cxxsec{except.handle}{14.4} +\cxxsec{except.spec}{14.5} +\cxxsec{except.special}{14.6} +\cxxsec{except.special.general}{14.6.1} +\cxxsec{except.terminate}{14.6.2} +\cxxsec{except.uncaught}{14.6.3} +\cxxsec{expr}{Clause 7} +\cxxsec{expr.pre}{7.1} +\cxxsec{expr.prop}{7.2} +\cxxsec{basic.lval}{7.2.1} +\cxxsec{fig:basic.lval}{1} +\cxxsec{expr.type}{7.2.2} +\cxxsec{expr.context}{7.2.3} +\cxxsec{conv}{7.3} +\cxxsec{conv.general}{7.3.1} +\cxxsec{conv.lval}{7.3.2} +\cxxsec{conv.array}{7.3.3} +\cxxsec{conv.func}{7.3.4} +\cxxsec{conv.rval}{7.3.5} +\cxxsec{conv.qual}{7.3.6} +\cxxsec{conv.prom}{7.3.7} +\cxxsec{conv.fpprom}{7.3.8} +\cxxsec{conv.integral}{7.3.9} +\cxxsec{conv.double}{7.3.10} +\cxxsec{conv.fpint}{7.3.11} +\cxxsec{conv.ptr}{7.3.12} +\cxxsec{conv.mem}{7.3.13} +\cxxsec{conv.fctptr}{7.3.14} +\cxxsec{conv.bool}{7.3.15} +\cxxsec{expr.arith.conv}{7.4} +\cxxsec{expr.prim}{7.5} +\cxxsec{expr.prim.literal}{7.5.1} +\cxxsec{expr.prim.this}{7.5.2} +\cxxsec{expr.prim.paren}{7.5.3} +\cxxsec{expr.prim.id}{7.5.4} +\cxxsec{expr.prim.id.general}{7.5.4.1} +\cxxsec{expr.prim.id.unqual}{7.5.4.2} +\cxxsec{expr.prim.id.qual}{7.5.4.3} +\cxxsec{expr.prim.id.dtor}{7.5.4.4} +\cxxsec{expr.prim.lambda}{7.5.5} +\cxxsec{expr.prim.lambda.general}{7.5.5.1} +\cxxsec{expr.prim.lambda.closure}{7.5.5.2} +\cxxsec{expr.prim.lambda.capture}{7.5.5.3} +\cxxsec{expr.prim.fold}{7.5.6} +\cxxsec{expr.prim.req}{7.5.7} +\cxxsec{expr.prim.req.general}{7.5.7.1} +\cxxsec{expr.prim.req.simple}{7.5.7.2} +\cxxsec{expr.prim.req.type}{7.5.7.3} +\cxxsec{expr.prim.req.compound}{7.5.7.4} +\cxxsec{expr.prim.req.nested}{7.5.7.5} +\cxxsec{expr.compound}{7.6} +\cxxsec{expr.post}{7.6.1} +\cxxsec{expr.post.general}{7.6.1.1} +\cxxsec{expr.sub}{7.6.1.2} +\cxxsec{expr.call}{7.6.1.3} +\cxxsec{expr.type.conv}{7.6.1.4} +\cxxsec{expr.ref}{7.6.1.5} +\cxxsec{expr.post.incr}{7.6.1.6} +\cxxsec{expr.dynamic.cast}{7.6.1.7} +\cxxsec{expr.typeid}{7.6.1.8} +\cxxsec{expr.static.cast}{7.6.1.9} +\cxxsec{expr.reinterpret.cast}{7.6.1.10} +\cxxsec{expr.const.cast}{7.6.1.11} +\cxxsec{expr.unary}{7.6.2} +\cxxsec{expr.unary.general}{7.6.2.1} +\cxxsec{expr.unary.op}{7.6.2.2} +\cxxsec{expr.pre.incr}{7.6.2.3} +\cxxsec{expr.await}{7.6.2.4} +\cxxsec{expr.sizeof}{7.6.2.5} +\cxxsec{expr.alignof}{7.6.2.6} +\cxxsec{expr.unary.noexcept}{7.6.2.7} +\cxxsec{expr.new}{7.6.2.8} +\cxxsec{expr.delete}{7.6.2.9} +\cxxsec{expr.cast}{7.6.3} +\cxxsec{expr.mptr.oper}{7.6.4} +\cxxsec{expr.mul}{7.6.5} +\cxxsec{expr.add}{7.6.6} +\cxxsec{expr.shift}{7.6.7} +\cxxsec{expr.spaceship}{7.6.8} +\cxxsec{expr.rel}{7.6.9} +\cxxsec{expr.eq}{7.6.10} +\cxxsec{expr.bit.and}{7.6.11} +\cxxsec{expr.xor}{7.6.12} +\cxxsec{expr.or}{7.6.13} +\cxxsec{expr.log.and}{7.6.14} +\cxxsec{expr.log.or}{7.6.15} +\cxxsec{expr.cond}{7.6.16} +\cxxsec{expr.yield}{7.6.17} +\cxxsec{expr.throw}{7.6.18} +\cxxsec{expr.ass}{7.6.19} +\cxxsec{expr.comma}{7.6.20} +\cxxsec{expr.const}{7.7} +\cxxsec{depr}{Annex D} +\cxxsec{depr.general}{D.1} +\cxxsec{depr.arith.conv.enum}{D.2} +\cxxsec{depr.capture.this}{D.3} +\cxxsec{depr.comma.subscript}{D.4} +\cxxsec{depr.array.comp}{D.5} +\cxxsec{depr.volatile.type}{D.6} +\cxxsec{depr.static.constexpr}{D.7} +\cxxsec{depr.local}{D.8} +\cxxsec{depr.impldec}{D.9} +\cxxsec{depr.c.headers}{D.10} +\cxxsec{depr.c.headers.general}{D.10.1} +\cxxsec{tab:depr.c.headers}{147} +\cxxsec{depr.complex.h.syn}{D.10.2} +\cxxsec{depr.iso646.h.syn}{D.10.3} +\cxxsec{depr.stdalign.h.syn}{D.10.4} +\cxxsec{depr.stdbool.h.syn}{D.10.5} +\cxxsec{depr.tgmath.h.syn}{D.10.6} +\cxxsec{depr.c.headers.other}{D.10.7} +\cxxsec{depr.res.on.required}{D.11} +\cxxsec{depr.relops}{D.12} +\cxxsec{depr.str.strstreams}{D.13} +\cxxsec{depr.strstream.syn}{D.13.1} +\cxxsec{depr.strstreambuf}{D.13.2} +\cxxsec{depr.strstreambuf.general}{D.13.2.1} +\cxxsec{depr.strstreambuf.cons}{D.13.2.2} +\cxxsec{tab:depr.strstreambuf.cons.sz}{148} +\cxxsec{tab:depr.strstreambuf.cons.alloc}{149} +\cxxsec{tab:depr.strstreambuf.cons.ptr}{150} +\cxxsec{depr.strstreambuf.members}{D.13.2.3} +\cxxsec{depr.strstreambuf.virtuals}{D.13.2.4} +\cxxsec{tab:depr.strstreambuf.seekoff.pos}{151} +\cxxsec{tab:depr.strstreambuf.seekoff.newoff}{152} +\cxxsec{depr.istrstream}{D.13.3} +\cxxsec{depr.istrstream.general}{D.13.3.1} +\cxxsec{depr.istrstream.cons}{D.13.3.2} +\cxxsec{depr.istrstream.members}{D.13.3.3} +\cxxsec{depr.ostrstream}{D.13.4} +\cxxsec{depr.ostrstream.general}{D.13.4.1} +\cxxsec{depr.ostrstream.cons}{D.13.4.2} +\cxxsec{depr.ostrstream.members}{D.13.4.3} +\cxxsec{depr.strstream}{D.13.5} +\cxxsec{depr.strstream.general}{D.13.5.1} +\cxxsec{depr.strstream.cons}{D.13.5.2} +\cxxsec{depr.strstream.dest}{D.13.5.3} +\cxxsec{depr.strstream.oper}{D.13.5.4} +\cxxsec{depr.meta.types}{D.14} +\cxxsec{depr.tuple}{D.15} +\cxxsec{depr.variant}{D.16} +\cxxsec{depr.iterator}{D.17} +\cxxsec{depr.move.iter.elem}{D.18} +\cxxsec{depr.util.smartptr.shared.atomic}{D.19} +\cxxsec{depr.string.capacity}{D.20} +\cxxsec{depr.locale.stdcvt}{D.21} +\cxxsec{depr.locale.stdcvt.general}{D.21.1} +\cxxsec{depr.codecvt.syn}{D.21.2} +\cxxsec{depr.locale.stdcvt.req}{D.21.3} +\cxxsec{depr.conversions}{D.22} +\cxxsec{depr.conversions.general}{D.22.1} +\cxxsec{depr.conversions.string}{D.22.2} +\cxxsec{depr.conversions.buffer}{D.22.3} +\cxxsec{depr.locale.category}{D.23} +\cxxsec{depr.fs.path.factory}{D.24} +\cxxsec{depr.atomics}{D.25} +\cxxsec{depr.atomics.general}{D.25.1} +\cxxsec{depr.atomics.volatile}{D.25.2} +\cxxsec{depr.atomics.nonmembers}{D.25.3} +\cxxsec{depr.atomics.types.operations}{D.25.4} +\cxxsec{depr.atomics.flag}{D.25.5} +\cxxsec{gram}{Annex A} +\cxxsec{gram.general}{A.1} +\cxxsec{gram.key}{A.2} +\cxxsec{gram.lex}{A.3} +\cxxsec{gram.basic}{A.4} +\cxxsec{gram.expr}{A.5} +\cxxsec{gram.stmt}{A.6} +\cxxsec{gram.dcl}{A.7} +\cxxsec{gram.module}{A.8} +\cxxsec{gram.class}{A.9} +\cxxsec{gram.over}{A.10} +\cxxsec{gram.temp}{A.11} +\cxxsec{gram.except}{A.12} +\cxxsec{gram.cpp}{A.13} +\cxxsec{intro.scope}{Clause 1} +\cxxsec{intro.refs}{Clause 2} +\cxxsec{intro.defs}{Clause 3} +\cxxsec{defns.access}{3.1} +\cxxsec{defns.arbitrary.stream}{3.2} +\cxxsec{defns.argument}{3.3} +\cxxsec{defns.argument.macro}{3.4} +\cxxsec{defns.argument.throw}{3.5} +\cxxsec{defns.argument.templ}{3.6} +\cxxsec{defns.block}{3.7} +\cxxsec{defns.block.stmt}{3.8} +\cxxsec{defns.character}{3.9} +\cxxsec{defns.character.container}{3.10} +\cxxsec{defns.component}{3.11} +\cxxsec{defns.cond.supp}{3.12} +\cxxsec{defns.const.subexpr}{3.13} +\cxxsec{defns.deadlock}{3.14} +\cxxsec{defns.default.behavior.impl}{3.15} +\cxxsec{defns.diagnostic}{3.16} +\cxxsec{defns.direct-non-list-init}{3.17} +\cxxsec{defns.dynamic.type}{3.18} +\cxxsec{defns.dynamic.type.prvalue}{3.19} +\cxxsec{defns.expression-equivalent}{3.20} +\cxxsec{defns.handler}{3.21} +\cxxsec{defns.ill.formed}{3.22} +\cxxsec{defns.impl.defined}{3.23} +\cxxsec{defns.order.ptr}{3.24} +\cxxsec{defns.impl.limits}{3.25} +\cxxsec{defns.iostream.templates}{3.26} +\cxxsec{defns.locale.specific}{3.27} +\cxxsec{defns.modifier}{3.28} +\cxxsec{defns.move.assign}{3.29} +\cxxsec{defns.move.constr}{3.30} +\cxxsec{defns.multibyte}{3.31} +\cxxsec{defns.ntcts}{3.32} +\cxxsec{defns.observer}{3.33} +\cxxsec{defns.parameter}{3.34} +\cxxsec{defns.parameter.macro}{3.35} +\cxxsec{defns.parameter.templ}{3.36} +\cxxsec{defns.prog.def.spec}{3.37} +\cxxsec{defns.prog.def.type}{3.38} +\cxxsec{defns.projection}{3.39} +\cxxsec{defns.referenceable}{3.40} +\cxxsec{defns.replacement}{3.41} +\cxxsec{defns.repositional.stream}{3.42} +\cxxsec{defns.required.behavior}{3.43} +\cxxsec{defns.reserved.function}{3.44} +\cxxsec{defns.signature}{3.45} +\cxxsec{defns.signature.friend}{3.46} +\cxxsec{defns.signature.templ}{3.47} +\cxxsec{defns.signature.templ.friend}{3.48} +\cxxsec{defns.signature.spec}{3.49} +\cxxsec{defns.signature.member}{3.50} +\cxxsec{defns.signature.member.templ}{3.51} +\cxxsec{defns.signature.member.spec}{3.52} +\cxxsec{defns.stable}{3.53} +\cxxsec{defns.static.type}{3.54} +\cxxsec{defns.traits}{3.55} +\cxxsec{defns.unblock}{3.56} +\cxxsec{defns.undefined}{3.57} +\cxxsec{defns.unspecified}{3.58} +\cxxsec{defns.valid}{3.59} +\cxxsec{defns.well.formed}{3.60} +\cxxsec{intro}{Clause 4} +\cxxsec{intro.compliance}{4.1} +\cxxsec{intro.compliance.general}{4.1.1} +\cxxsec{intro.abstract}{4.1.2} +\cxxsec{intro.structure}{4.2} +\cxxsec{syntax}{4.3} +\cxxsec{input.output}{Clause 29} +\cxxsec{input.output.general}{29.1} +\cxxsec{tab:iostreams.summary}{115} +\cxxsec{fig:iostreams.streampos}{7} +\cxxsec{iostreams.requirements}{29.2} +\cxxsec{iostream.limits.imbue}{29.2.1} +\cxxsec{iostreams.limits.pos}{29.2.2} +\cxxsec{iostreams.threadsafety}{29.2.3} +\cxxsec{iostream.forward}{29.3} +\cxxsec{iosfwd.syn}{29.3.1} +\cxxsec{iostream.forward.overview}{29.3.2} +\cxxsec{iostream.objects}{29.4} +\cxxsec{iostream.syn}{29.4.1} +\cxxsec{iostream.objects.overview}{29.4.2} +\cxxsec{narrow.stream.objects}{29.4.3} +\cxxsec{wide.stream.objects}{29.4.4} +\cxxsec{iostreams.base}{29.5} +\cxxsec{ios.syn}{29.5.1} +\cxxsec{stream.types}{29.5.2} +\cxxsec{ios.base}{29.5.3} +\cxxsec{ios.base.general}{29.5.3.1} +\cxxsec{ios.types}{29.5.3.2} +\cxxsec{ios.failure}{29.5.3.2.1} +\cxxsec{ios.fmtflags}{29.5.3.2.2} +\cxxsec{ios.iostate}{29.5.3.2.3} +\cxxsec{ios.openmode}{29.5.3.2.4} +\cxxsec{ios.seekdir}{29.5.3.2.5} +\cxxsec{tab:ios.fmtflags}{116} +\cxxsec{tab:ios.fmtflags.const}{117} +\cxxsec{tab:ios.iostate}{118} +\cxxsec{tab:ios.openmode}{119} +\cxxsec{tab:ios.seekdir}{120} +\cxxsec{ios.init}{29.5.3.2.6} +\cxxsec{fmtflags.state}{29.5.3.3} +\cxxsec{ios.base.locales}{29.5.3.4} +\cxxsec{ios.members.static}{29.5.3.5} +\cxxsec{ios.base.storage}{29.5.3.6} +\cxxsec{ios.base.callback}{29.5.3.7} +\cxxsec{ios.base.cons}{29.5.3.8} +\cxxsec{fpos}{29.5.4} +\cxxsec{fpos.members}{29.5.4.1} +\cxxsec{fpos.operations}{29.5.4.2} +\cxxsec{tab:fpos.operations}{121} +\cxxsec{ios}{29.5.5} +\cxxsec{ios.overview}{29.5.5.1} +\cxxsec{basic.ios.cons}{29.5.5.2} +\cxxsec{tab:basic.ios.cons}{122} +\cxxsec{basic.ios.members}{29.5.5.3} +\cxxsec{tab:basic.ios.copyfmt}{123} +\cxxsec{iostate.flags}{29.5.5.4} +\cxxsec{std.ios.manip}{29.5.6} +\cxxsec{fmtflags.manip}{29.5.6.1} +\cxxsec{adjustfield.manip}{29.5.6.2} +\cxxsec{basefield.manip}{29.5.6.3} +\cxxsec{floatfield.manip}{29.5.6.4} +\cxxsec{error.reporting}{29.5.7} +\cxxsec{stream.buffers}{29.6} +\cxxsec{streambuf.syn}{29.6.1} +\cxxsec{streambuf.reqts}{29.6.2} +\cxxsec{streambuf}{29.6.3} +\cxxsec{streambuf.general}{29.6.3.1} +\cxxsec{streambuf.cons}{29.6.3.2} +\cxxsec{streambuf.members}{29.6.3.3} +\cxxsec{streambuf.locales}{29.6.3.3.1} +\cxxsec{streambuf.buffer}{29.6.3.3.2} +\cxxsec{streambuf.pub.get}{29.6.3.3.3} +\cxxsec{streambuf.pub.pback}{29.6.3.3.4} +\cxxsec{streambuf.pub.put}{29.6.3.3.5} +\cxxsec{streambuf.protected}{29.6.3.4} +\cxxsec{streambuf.assign}{29.6.3.4.1} +\cxxsec{streambuf.get.area}{29.6.3.4.2} +\cxxsec{streambuf.put.area}{29.6.3.4.3} +\cxxsec{streambuf.virtuals}{29.6.3.5} +\cxxsec{streambuf.virt.locales}{29.6.3.5.1} +\cxxsec{streambuf.virt.buffer}{29.6.3.5.2} +\cxxsec{streambuf.virt.get}{29.6.3.5.3} +\cxxsec{streambuf.virt.pback}{29.6.3.5.4} +\cxxsec{streambuf.virt.put}{29.6.3.5.5} +\cxxsec{iostream.format}{29.7} +\cxxsec{istream.syn}{29.7.1} +\cxxsec{ostream.syn}{29.7.2} +\cxxsec{iomanip.syn}{29.7.3} +\cxxsec{input.streams}{29.7.4} +\cxxsec{input.streams.general}{29.7.4.1} +\cxxsec{istream}{29.7.4.2} +\cxxsec{istream.general}{29.7.4.2.1} +\cxxsec{istream.cons}{29.7.4.2.2} +\cxxsec{istream.assign}{29.7.4.2.3} +\cxxsec{istream.sentry}{29.7.4.2.4} +\cxxsec{istream.formatted}{29.7.4.3} +\cxxsec{istream.formatted.reqmts}{29.7.4.3.1} +\cxxsec{istream.formatted.arithmetic}{29.7.4.3.2} +\cxxsec{istream.extractors}{29.7.4.3.3} +\cxxsec{istream.unformatted}{29.7.4.4} +\cxxsec{istream.manip}{29.7.4.5} +\cxxsec{istream.rvalue}{29.7.4.6} +\cxxsec{iostreamclass}{29.7.4.7} +\cxxsec{iostreamclass.general}{29.7.4.7.1} +\cxxsec{iostream.cons}{29.7.4.7.2} +\cxxsec{iostream.dest}{29.7.4.7.3} +\cxxsec{iostream.assign}{29.7.4.7.4} +\cxxsec{output.streams}{29.7.5} +\cxxsec{output.streams.general}{29.7.5.1} +\cxxsec{ostream}{29.7.5.2} +\cxxsec{ostream.general}{29.7.5.2.1} +\cxxsec{ostream.cons}{29.7.5.2.2} +\cxxsec{ostream.assign}{29.7.5.2.3} +\cxxsec{ostream.sentry}{29.7.5.2.4} +\cxxsec{ostream.seeks}{29.7.5.2.5} +\cxxsec{ostream.formatted}{29.7.5.3} +\cxxsec{ostream.formatted.reqmts}{29.7.5.3.1} +\cxxsec{ostream.inserters.arithmetic}{29.7.5.3.2} +\cxxsec{ostream.inserters}{29.7.5.3.3} +\cxxsec{ostream.inserters.character}{29.7.5.3.4} +\cxxsec{ostream.unformatted}{29.7.5.4} +\cxxsec{ostream.manip}{29.7.5.5} +\cxxsec{ostream.rvalue}{29.7.5.6} +\cxxsec{std.manip}{29.7.6} +\cxxsec{ext.manip}{29.7.7} +\cxxsec{quoted.manip}{29.7.8} +\cxxsec{string.streams}{29.8} +\cxxsec{sstream.syn}{29.8.1} +\cxxsec{stringbuf}{29.8.2} +\cxxsec{stringbuf.general}{29.8.2.1} +\cxxsec{stringbuf.cons}{29.8.2.2} +\cxxsec{stringbuf.assign}{29.8.2.3} +\cxxsec{stringbuf.members}{29.8.2.4} +\cxxsec{stringbuf.virtuals}{29.8.2.5} +\cxxsec{tab:stringbuf.seekoff.pos}{124} +\cxxsec{tab:stringbuf.seekoff.newoff}{125} +\cxxsec{istringstream}{29.8.3} +\cxxsec{istringstream.general}{29.8.3.1} +\cxxsec{istringstream.cons}{29.8.3.2} +\cxxsec{istringstream.assign}{29.8.3.3} +\cxxsec{istringstream.members}{29.8.3.4} +\cxxsec{ostringstream}{29.8.4} +\cxxsec{ostringstream.general}{29.8.4.1} +\cxxsec{ostringstream.cons}{29.8.4.2} +\cxxsec{ostringstream.assign}{29.8.4.3} +\cxxsec{ostringstream.members}{29.8.4.4} +\cxxsec{stringstream}{29.8.5} +\cxxsec{stringstream.general}{29.8.5.1} +\cxxsec{stringstream.cons}{29.8.5.2} +\cxxsec{stringstream.assign}{29.8.5.3} +\cxxsec{stringstream.members}{29.8.5.4} +\cxxsec{file.streams}{29.9} +\cxxsec{fstream.syn}{29.9.1} +\cxxsec{filebuf}{29.9.2} +\cxxsec{filebuf.general}{29.9.2.1} +\cxxsec{filebuf.cons}{29.9.2.2} +\cxxsec{filebuf.assign}{29.9.2.3} +\cxxsec{filebuf.members}{29.9.2.4} +\cxxsec{tab:filebuf.open.modes}{126} +\cxxsec{filebuf.virtuals}{29.9.2.5} +\cxxsec{tab:filebuf.seekoff}{127} +\cxxsec{ifstream}{29.9.3} +\cxxsec{ifstream.general}{29.9.3.1} +\cxxsec{ifstream.cons}{29.9.3.2} +\cxxsec{ifstream.assign}{29.9.3.3} +\cxxsec{ifstream.members}{29.9.3.4} +\cxxsec{ofstream}{29.9.4} +\cxxsec{ofstream.general}{29.9.4.1} +\cxxsec{ofstream.cons}{29.9.4.2} +\cxxsec{ofstream.assign}{29.9.4.3} +\cxxsec{ofstream.members}{29.9.4.4} +\cxxsec{fstream}{29.9.5} +\cxxsec{fstream.general}{29.9.5.1} +\cxxsec{fstream.cons}{29.9.5.2} +\cxxsec{fstream.assign}{29.9.5.3} +\cxxsec{fstream.members}{29.9.5.4} +\cxxsec{syncstream}{29.10} +\cxxsec{syncstream.syn}{29.10.1} +\cxxsec{syncstream.syncbuf}{29.10.2} +\cxxsec{syncstream.syncbuf.overview}{29.10.2.1} +\cxxsec{syncstream.syncbuf.cons}{29.10.2.2} +\cxxsec{syncstream.syncbuf.assign}{29.10.2.3} +\cxxsec{syncstream.syncbuf.members}{29.10.2.4} +\cxxsec{syncstream.syncbuf.virtuals}{29.10.2.5} +\cxxsec{syncstream.syncbuf.special}{29.10.2.6} +\cxxsec{syncstream.osyncstream}{29.10.3} +\cxxsec{syncstream.osyncstream.overview}{29.10.3.1} +\cxxsec{syncstream.osyncstream.cons}{29.10.3.2} +\cxxsec{syncstream.osyncstream.members}{29.10.3.3} +\cxxsec{filesystems}{29.11} +\cxxsec{fs.general}{29.11.1} +\cxxsec{fs.conformance}{29.11.2} +\cxxsec{fs.conformance.general}{29.11.2.1} +\cxxsec{fs.conform.9945}{29.11.2.2} +\cxxsec{fs.conform.os}{29.11.2.3} +\cxxsec{fs.race.behavior}{29.11.2.4} +\cxxsec{fs.req}{29.11.3} +\cxxsec{fs.req.general}{29.11.3.1} +\cxxsec{fs.req.namespace}{29.11.3.2} +\cxxsec{fs.filesystem.syn}{29.11.4} +\cxxsec{fs.err.report}{29.11.5} +\cxxsec{fs.class.path}{29.11.6} +\cxxsec{fs.class.path.general}{29.11.6.1} +\cxxsec{fs.path.generic}{29.11.6.2} +\cxxsec{fs.path.cvt}{29.11.6.3} +\cxxsec{fs.path.fmt.cvt}{29.11.6.3.1} +\cxxsec{fs.path.type.cvt}{29.11.6.3.2} +\cxxsec{fs.path.req}{29.11.6.4} +\cxxsec{fs.path.member}{29.11.6.5} +\cxxsec{fs.path.construct}{29.11.6.5.1} +\cxxsec{fs.path.assign}{29.11.6.5.2} +\cxxsec{fs.path.append}{29.11.6.5.3} +\cxxsec{fs.path.concat}{29.11.6.5.4} +\cxxsec{fs.path.modifiers}{29.11.6.5.5} +\cxxsec{fs.path.native.obs}{29.11.6.5.6} +\cxxsec{fs.path.generic.obs}{29.11.6.5.7} +\cxxsec{fs.path.compare}{29.11.6.5.8} +\cxxsec{fs.path.decompose}{29.11.6.5.9} +\cxxsec{fs.path.query}{29.11.6.5.10} +\cxxsec{fs.path.gen}{29.11.6.5.11} +\cxxsec{fs.path.itr}{29.11.6.6} +\cxxsec{fs.path.io}{29.11.6.7} +\cxxsec{fs.path.nonmember}{29.11.6.8} +\cxxsec{fs.class.filesystem.error}{29.11.7} +\cxxsec{fs.class.filesystem.error.general}{29.11.7.1} +\cxxsec{fs.filesystem.error.members}{29.11.7.2} +\cxxsec{fs.enum}{29.11.8} +\cxxsec{fs.enum.path.format}{29.11.8.1} +\cxxsec{tab:fs.enum.path.format}{128} +\cxxsec{fs.enum.file.type}{29.11.8.2} +\cxxsec{tab:fs.enum.file.type}{129} +\cxxsec{fs.enum.copy.opts}{29.11.8.3} +\cxxsec{tab:fs.enum.copy.opts}{130} +\cxxsec{tab:fs.enum.perms}{131} +\cxxsec{fs.enum.perms}{29.11.8.4} +\cxxsec{fs.enum.perm.opts}{29.11.8.5} +\cxxsec{tab:fs.enum.perm.opts}{132} +\cxxsec{fs.enum.dir.opts}{29.11.8.6} +\cxxsec{tab:fs.enum.dir.opts}{133} +\cxxsec{fs.class.file.status}{29.11.9} +\cxxsec{fs.class.file.status.general}{29.11.9.1} +\cxxsec{fs.file.status.cons}{29.11.9.2} +\cxxsec{fs.file.status.obs}{29.11.9.3} +\cxxsec{fs.file.status.mods}{29.11.9.4} +\cxxsec{fs.class.directory.entry}{29.11.10} +\cxxsec{fs.class.directory.entry.general}{29.11.10.1} +\cxxsec{fs.dir.entry.cons}{29.11.10.2} +\cxxsec{fs.dir.entry.mods}{29.11.10.3} +\cxxsec{fs.dir.entry.obs}{29.11.10.4} +\cxxsec{fs.class.directory.iterator}{29.11.11} +\cxxsec{fs.class.directory.iterator.general}{29.11.11.1} +\cxxsec{fs.dir.itr.members}{29.11.11.2} +\cxxsec{fs.dir.itr.nonmembers}{29.11.11.3} +\cxxsec{fs.class.rec.dir.itr}{29.11.12} +\cxxsec{fs.class.rec.dir.itr.general}{29.11.12.1} +\cxxsec{fs.rec.dir.itr.members}{29.11.12.2} +\cxxsec{fs.rec.dir.itr.nonmembers}{29.11.12.3} +\cxxsec{fs.op.funcs}{29.11.13} +\cxxsec{fs.op.funcs.general}{29.11.13.1} +\cxxsec{fs.op.absolute}{29.11.13.2} +\cxxsec{fs.op.canonical}{29.11.13.3} +\cxxsec{fs.op.copy}{29.11.13.4} +\cxxsec{fs.op.copy.file}{29.11.13.5} +\cxxsec{fs.op.copy.symlink}{29.11.13.6} +\cxxsec{fs.op.create.directories}{29.11.13.7} +\cxxsec{fs.op.create.directory}{29.11.13.8} +\cxxsec{fs.op.create.dir.symlk}{29.11.13.9} +\cxxsec{fs.op.create.hard.lk}{29.11.13.10} +\cxxsec{fs.op.create.symlink}{29.11.13.11} +\cxxsec{fs.op.current.path}{29.11.13.12} +\cxxsec{fs.op.equivalent}{29.11.13.13} +\cxxsec{fs.op.exists}{29.11.13.14} +\cxxsec{fs.op.file.size}{29.11.13.15} +\cxxsec{fs.op.hard.lk.ct}{29.11.13.16} +\cxxsec{fs.op.is.block.file}{29.11.13.17} +\cxxsec{fs.op.is.char.file}{29.11.13.18} +\cxxsec{fs.op.is.directory}{29.11.13.19} +\cxxsec{fs.op.is.empty}{29.11.13.20} +\cxxsec{fs.op.is.fifo}{29.11.13.21} +\cxxsec{fs.op.is.other}{29.11.13.22} +\cxxsec{fs.op.is.regular.file}{29.11.13.23} +\cxxsec{fs.op.is.socket}{29.11.13.24} +\cxxsec{fs.op.is.symlink}{29.11.13.25} +\cxxsec{fs.op.last.write.time}{29.11.13.26} +\cxxsec{fs.op.permissions}{29.11.13.27} +\cxxsec{fs.op.proximate}{29.11.13.28} +\cxxsec{fs.op.read.symlink}{29.11.13.29} +\cxxsec{fs.op.relative}{29.11.13.30} +\cxxsec{fs.op.remove}{29.11.13.31} +\cxxsec{fs.op.remove.all}{29.11.13.32} +\cxxsec{fs.op.rename}{29.11.13.33} +\cxxsec{fs.op.resize.file}{29.11.13.34} +\cxxsec{fs.op.space}{29.11.13.35} +\cxxsec{fs.op.status}{29.11.13.36} +\cxxsec{fs.op.status.known}{29.11.13.37} +\cxxsec{fs.op.symlink.status}{29.11.13.38} +\cxxsec{fs.op.temp.dir.path}{29.11.13.39} +\cxxsec{fs.op.weakly.canonical}{29.11.13.40} +\cxxsec{c.files}{29.12} +\cxxsec{cstdio.syn}{29.12.1} +\cxxsec{cinttypes.syn}{29.12.2} +\cxxsec{iterators}{Clause 23} +\cxxsec{iterators.general}{23.1} +\cxxsec{tab:iterators.summary}{82} +\cxxsec{iterator.synopsis}{23.2} +\cxxsec{iterator.requirements}{23.3} +\cxxsec{iterator.requirements.general}{23.3.1} +\cxxsec{tab:iterators.relations}{83} +\cxxsec{iterator.assoc.types}{23.3.2} +\cxxsec{incrementable.traits}{23.3.2.1} +\cxxsec{readable.traits}{23.3.2.2} +\cxxsec{iterator.traits}{23.3.2.3} +\cxxsec{iterator.cust}{23.3.3} +\cxxsec{iterator.cust.move}{23.3.3.1} +\cxxsec{iterator.cust.swap}{23.3.3.2} +\cxxsec{iterator.concepts}{23.3.4} +\cxxsec{iterator.concepts.general}{23.3.4.1} +\cxxsec{iterator.concept.readable}{23.3.4.2} +\cxxsec{iterator.concept.writable}{23.3.4.3} +\cxxsec{iterator.concept.winc}{23.3.4.4} +\cxxsec{iterator.concept.inc}{23.3.4.5} +\cxxsec{iterator.concept.iterator}{23.3.4.6} +\cxxsec{iterator.concept.sentinel}{23.3.4.7} +\cxxsec{iterator.concept.sizedsentinel}{23.3.4.8} +\cxxsec{iterator.concept.input}{23.3.4.9} +\cxxsec{iterator.concept.output}{23.3.4.10} +\cxxsec{iterator.concept.forward}{23.3.4.11} +\cxxsec{iterator.concept.bidir}{23.3.4.12} +\cxxsec{iterator.concept.random.access}{23.3.4.13} +\cxxsec{iterator.concept.contiguous}{23.3.4.14} +\cxxsec{iterator.cpp17}{23.3.5} +\cxxsec{iterator.cpp17.general}{23.3.5.1} +\cxxsec{iterator.iterators}{23.3.5.2} +\cxxsec{tab:iterator}{84} +\cxxsec{input.iterators}{23.3.5.3} +\cxxsec{tab:inputiterator}{85} +\cxxsec{output.iterators}{23.3.5.4} +\cxxsec{tab:outputiterator}{86} +\cxxsec{forward.iterators}{23.3.5.5} +\cxxsec{tab:forwarditerator}{87} +\cxxsec{bidirectional.iterators}{23.3.5.6} +\cxxsec{random.access.iterators}{23.3.5.7} +\cxxsec{tab:bidirectionaliterator}{88} +\cxxsec{tab:randomaccessiterator}{89} +\cxxsec{indirectcallable}{23.3.6} +\cxxsec{indirectcallable.general}{23.3.6.1} +\cxxsec{indirectcallable.indirectinvocable}{23.3.6.2} +\cxxsec{projected}{23.3.6.3} +\cxxsec{alg.req}{23.3.7} +\cxxsec{alg.req.general}{23.3.7.1} +\cxxsec{alg.req.ind.move}{23.3.7.2} +\cxxsec{alg.req.ind.copy}{23.3.7.3} +\cxxsec{alg.req.ind.swap}{23.3.7.4} +\cxxsec{alg.req.ind.cmp}{23.3.7.5} +\cxxsec{alg.req.permutable}{23.3.7.6} +\cxxsec{alg.req.mergeable}{23.3.7.7} +\cxxsec{alg.req.sortable}{23.3.7.8} +\cxxsec{iterator.primitives}{23.4} +\cxxsec{iterator.primitives.general}{23.4.1} +\cxxsec{std.iterator.tags}{23.4.2} +\cxxsec{iterator.operations}{23.4.3} +\cxxsec{range.iter.ops}{23.4.4} +\cxxsec{range.iter.ops.general}{23.4.4.1} +\cxxsec{range.iter.op.advance}{23.4.4.2} +\cxxsec{range.iter.op.distance}{23.4.4.3} +\cxxsec{range.iter.op.next}{23.4.4.4} +\cxxsec{range.iter.op.prev}{23.4.4.5} +\cxxsec{predef.iterators}{23.5} +\cxxsec{reverse.iterators}{23.5.1} +\cxxsec{reverse.iterators.general}{23.5.1.1} +\cxxsec{reverse.iterator}{23.5.1.2} +\cxxsec{reverse.iter.requirements}{23.5.1.3} +\cxxsec{reverse.iter.cons}{23.5.1.4} +\cxxsec{reverse.iter.conv}{23.5.1.5} +\cxxsec{reverse.iter.elem}{23.5.1.6} +\cxxsec{reverse.iter.nav}{23.5.1.7} +\cxxsec{reverse.iter.cmp}{23.5.1.8} +\cxxsec{reverse.iter.nonmember}{23.5.1.9} +\cxxsec{insert.iterators}{23.5.2} +\cxxsec{insert.iterators.general}{23.5.2.1} +\cxxsec{back.insert.iterator}{23.5.2.2} +\cxxsec{back.insert.iter.ops}{23.5.2.2.1} +\cxxsec{back.inserter}{23.5.2.2.2} +\cxxsec{front.insert.iterator}{23.5.2.3} +\cxxsec{front.insert.iter.ops}{23.5.2.3.1} +\cxxsec{front.inserter}{23.5.2.3.2} +\cxxsec{insert.iterator}{23.5.2.4} +\cxxsec{insert.iter.ops}{23.5.2.4.1} +\cxxsec{inserter}{23.5.2.4.2} +\cxxsec{move.iterators}{23.5.3} +\cxxsec{move.iterators.general}{23.5.3.1} +\cxxsec{move.iterator}{23.5.3.2} +\cxxsec{move.iter.requirements}{23.5.3.3} +\cxxsec{move.iter.cons}{23.5.3.4} +\cxxsec{move.iter.op.conv}{23.5.3.5} +\cxxsec{move.iter.elem}{23.5.3.6} +\cxxsec{move.iter.nav}{23.5.3.7} +\cxxsec{move.iter.op.comp}{23.5.3.8} +\cxxsec{move.iter.nonmember}{23.5.3.9} +\cxxsec{move.sentinel}{23.5.3.10} +\cxxsec{move.sent.ops}{23.5.3.11} +\cxxsec{iterators.common}{23.5.4} +\cxxsec{common.iterator}{23.5.4.1} +\cxxsec{common.iter.types}{23.5.4.2} +\cxxsec{common.iter.const}{23.5.4.3} +\cxxsec{common.iter.access}{23.5.4.4} +\cxxsec{common.iter.nav}{23.5.4.5} +\cxxsec{common.iter.cmp}{23.5.4.6} +\cxxsec{common.iter.cust}{23.5.4.7} +\cxxsec{default.sentinel}{23.5.5} +\cxxsec{iterators.counted}{23.5.6} +\cxxsec{counted.iterator}{23.5.6.1} +\cxxsec{counted.iter.const}{23.5.6.2} +\cxxsec{counted.iter.access}{23.5.6.3} +\cxxsec{counted.iter.elem}{23.5.6.4} +\cxxsec{counted.iter.nav}{23.5.6.5} +\cxxsec{counted.iter.cmp}{23.5.6.6} +\cxxsec{counted.iter.cust}{23.5.6.7} +\cxxsec{unreachable.sentinel}{23.5.7} +\cxxsec{stream.iterators}{23.6} +\cxxsec{stream.iterators.general}{23.6.1} +\cxxsec{istream.iterator}{23.6.2} +\cxxsec{istream.iterator.general}{23.6.2.1} +\cxxsec{istream.iterator.cons}{23.6.2.2} +\cxxsec{istream.iterator.ops}{23.6.2.3} +\cxxsec{ostream.iterator}{23.6.3} +\cxxsec{ostream.iterator.general}{23.6.3.1} +\cxxsec{ostream.iterator.cons.des}{23.6.3.2} +\cxxsec{ostream.iterator.ops}{23.6.3.3} +\cxxsec{istreambuf.iterator}{23.6.4} +\cxxsec{istreambuf.iterator.general}{23.6.4.1} +\cxxsec{istreambuf.iterator.proxy}{23.6.4.2} +\cxxsec{istreambuf.iterator.cons}{23.6.4.3} +\cxxsec{istreambuf.iterator.ops}{23.6.4.4} +\cxxsec{ostreambuf.iterator}{23.6.5} +\cxxsec{ostreambuf.iterator.general}{23.6.5.1} +\cxxsec{ostreambuf.iter.cons}{23.6.5.2} +\cxxsec{ostreambuf.iter.ops}{23.6.5.3} +\cxxsec{iterator.range}{23.7} +\cxxsec{lex}{Clause 5} +\cxxsec{lex.separate}{5.1} +\cxxsec{lex.phases}{5.2} +\cxxsec{lex.charset}{5.3} +\cxxsec{lex.pptoken}{5.4} +\cxxsec{lex.digraph}{5.5} +\cxxsec{tab:lex.digraph}{1} +\cxxsec{lex.token}{5.6} +\cxxsec{lex.comment}{5.7} +\cxxsec{lex.header}{5.8} +\cxxsec{lex.ppnumber}{5.9} +\cxxsec{lex.name}{5.10} +\cxxsec{tab:lex.name.allowed}{2} +\cxxsec{tab:lex.name.disallowed}{3} +\cxxsec{tab:lex.name.special}{4} +\cxxsec{lex.key}{5.11} +\cxxsec{tab:lex.key}{5} +\cxxsec{tab:lex.key.digraph}{6} +\cxxsec{lex.operators}{5.12} +\cxxsec{lex.literal}{5.13} +\cxxsec{lex.literal.kinds}{5.13.1} +\cxxsec{lex.icon}{5.13.2} +\cxxsec{tab:lex.icon.base}{7} +\cxxsec{tab:lex.icon.type}{8} +\cxxsec{lex.ccon}{5.13.3} +\cxxsec{tab:lex.ccon.esc}{9} +\cxxsec{lex.fcon}{5.13.4} +\cxxsec{tab:lex.fcon.type}{10} +\cxxsec{lex.string}{5.13.5} +\cxxsec{tab:lex.string.concat}{11} +\cxxsec{lex.bool}{5.13.6} +\cxxsec{lex.nullptr}{5.13.7} +\cxxsec{lex.ext}{5.13.8} +\cxxsec{library}{Clause 16} +\cxxsec{library.general}{16.1} +\cxxsec{tab:library.categories}{20} +\cxxsec{library.c}{16.2} +\cxxsec{description}{16.3} +\cxxsec{description.general}{16.3.1} +\cxxsec{structure}{16.3.2} +\cxxsec{structure.elements}{16.3.2.1} +\cxxsec{structure.summary}{16.3.2.2} +\cxxsec{structure.requirements}{16.3.2.3} +\cxxsec{structure.specifications}{16.3.2.4} +\cxxsec{structure.see.also}{16.3.2.5} +\cxxsec{conventions}{16.3.3} +\cxxsec{conventions.general}{16.3.3.1} +\cxxsec{expos.only.func}{16.3.3.2} +\cxxsec{type.descriptions}{16.3.3.3} +\cxxsec{type.descriptions.general}{16.3.3.3.1} +\cxxsec{expos.only.types}{16.3.3.3.2} +\cxxsec{enumerated.types}{16.3.3.3.3} +\cxxsec{bitmask.types}{16.3.3.3.4} +\cxxsec{character.seq}{16.3.3.3.5} +\cxxsec{character.seq.general}{16.3.3.3.5.1} +\cxxsec{byte.strings}{16.3.3.3.5.2} +\cxxsec{multibyte.strings}{16.3.3.3.5.3} +\cxxsec{customization.point.object}{16.3.3.3.6} +\cxxsec{functions.within.classes}{16.3.3.4} +\cxxsec{objects.within.classes}{16.3.3.5} +\cxxsec{requirements}{16.4} +\cxxsec{requirements.general}{16.4.1} +\cxxsec{organization}{16.4.2} +\cxxsec{organization.general}{16.4.2.1} +\cxxsec{contents}{16.4.2.2} +\cxxsec{headers}{16.4.2.3} +\cxxsec{tab:headers.cpp}{21} +\cxxsec{tab:headers.cpp.c}{22} +\cxxsec{tab:c.annex.k.names}{23} +\cxxsec{compliance}{16.4.2.4} +\cxxsec{using}{16.4.3} +\cxxsec{using.overview}{16.4.3.1} +\cxxsec{tab:headers.cpp.fs}{24} +\cxxsec{using.headers}{16.4.3.2} +\cxxsec{using.linkage}{16.4.3.3} +\cxxsec{utility.requirements}{16.4.4} +\cxxsec{utility.requirements.general}{16.4.4.1} +\cxxsec{utility.arg.requirements}{16.4.4.2} +\cxxsec{tab:cpp17.equalitycomparable}{25} +\cxxsec{tab:cpp17.lessthancomparable}{26} +\cxxsec{tab:cpp17.defaultconstructible}{27} +\cxxsec{tab:cpp17.moveconstructible}{28} +\cxxsec{swappable.requirements}{16.4.4.3} +\cxxsec{tab:cpp17.copyconstructible}{29} +\cxxsec{tab:cpp17.moveassignable}{30} +\cxxsec{tab:cpp17.copyassignable}{31} +\cxxsec{tab:cpp17.destructible}{32} +\cxxsec{nullablepointer.requirements}{16.4.4.4} +\cxxsec{hash.requirements}{16.4.4.5} +\cxxsec{tab:cpp17.nullablepointer}{33} +\cxxsec{tab:cpp17.hash}{34} +\cxxsec{allocator.requirements}{16.4.4.6} +\cxxsec{allocator.requirements.general}{16.4.4.6.1} +\cxxsec{tab:cpp17.allocator}{36} +\cxxsec{tab:allocator.req.var}{35} +\cxxsec{allocator.requirements.completeness}{16.4.4.6.2} +\cxxsec{constraints}{16.4.5} +\cxxsec{constraints.overview}{16.4.5.1} +\cxxsec{namespace.constraints}{16.4.5.2} +\cxxsec{namespace.std}{16.4.5.2.1} +\cxxsec{namespace.posix}{16.4.5.2.2} +\cxxsec{namespace.future}{16.4.5.2.3} +\cxxsec{reserved.names}{16.4.5.3} +\cxxsec{reserved.names.general}{16.4.5.3.1} +\cxxsec{zombie.names}{16.4.5.3.2} +\cxxsec{macro.names}{16.4.5.3.3} +\cxxsec{extern.names}{16.4.5.3.4} +\cxxsec{extern.types}{16.4.5.3.5} +\cxxsec{usrlit.suffix}{16.4.5.3.6} +\cxxsec{alt.headers}{16.4.5.4} +\cxxsec{derived.classes}{16.4.5.5} +\cxxsec{replacement.functions}{16.4.5.6} +\cxxsec{handler.functions}{16.4.5.7} +\cxxsec{res.on.functions}{16.4.5.8} +\cxxsec{res.on.arguments}{16.4.5.9} +\cxxsec{res.on.objects}{16.4.5.10} +\cxxsec{res.on.requirements}{16.4.5.11} +\cxxsec{conforming}{16.4.6} +\cxxsec{conforming.overview}{16.4.6.1} +\cxxsec{res.on.headers}{16.4.6.2} +\cxxsec{res.on.macro.definitions}{16.4.6.3} +\cxxsec{global.functions}{16.4.6.4} +\cxxsec{member.functions}{16.4.6.5} +\cxxsec{hidden.friends}{16.4.6.6} +\cxxsec{constexpr.functions}{16.4.6.7} +\cxxsec{algorithm.stable}{16.4.6.8} +\cxxsec{reentrancy}{16.4.6.9} +\cxxsec{res.on.data.races}{16.4.6.10} +\cxxsec{protection.within.classes}{16.4.6.11} +\cxxsec{derivation}{16.4.6.12} +\cxxsec{res.on.exception.handling}{16.4.6.13} +\cxxsec{res.on.pointer.storage}{16.4.6.14} +\cxxsec{value.error.codes}{16.4.6.15} +\cxxsec{lib.types.movedfrom}{16.4.6.16} +\cxxsec{implimits}{Annex B} +\cxxsec{localization}{Clause 28} +\cxxsec{localization.general}{28.1} +\cxxsec{tab:localization.summary}{101} +\cxxsec{locale.syn}{28.2} +\cxxsec{locales}{28.3} +\cxxsec{locale}{28.3.1} +\cxxsec{locale.general}{28.3.1.1} +\cxxsec{locale.types}{28.3.1.2} +\cxxsec{locale.category}{28.3.1.2.1} +\cxxsec{tab:locale.category.facets}{102} +\cxxsec{tab:locale.spec}{103} +\cxxsec{locale.facet}{28.3.1.2.2} +\cxxsec{locale.id}{28.3.1.2.3} +\cxxsec{locale.cons}{28.3.1.3} +\cxxsec{locale.members}{28.3.1.4} +\cxxsec{locale.operators}{28.3.1.5} +\cxxsec{locale.statics}{28.3.1.6} +\cxxsec{locale.global.templates}{28.3.2} +\cxxsec{locale.convenience}{28.3.3} +\cxxsec{classification}{28.3.3.1} +\cxxsec{conversions.character}{28.3.3.2} +\cxxsec{locale.categories}{28.4} +\cxxsec{locale.categories.general}{28.4.1} +\cxxsec{category.ctype}{28.4.2} +\cxxsec{category.ctype.general}{28.4.2.1} +\cxxsec{locale.ctype}{28.4.2.2} +\cxxsec{locale.ctype.general}{28.4.2.2.1} +\cxxsec{locale.ctype.members}{28.4.2.2.2} +\cxxsec{locale.ctype.virtuals}{28.4.2.2.3} +\cxxsec{locale.ctype.byname}{28.4.2.3} +\cxxsec{facet.ctype.special}{28.4.2.4} +\cxxsec{facet.ctype.special.general}{28.4.2.4.1} +\cxxsec{facet.ctype.char.dtor}{28.4.2.4.2} +\cxxsec{facet.ctype.char.members}{28.4.2.4.3} +\cxxsec{facet.ctype.char.statics}{28.4.2.4.4} +\cxxsec{facet.ctype.char.virtuals}{28.4.2.4.5} +\cxxsec{locale.codecvt}{28.4.2.5} +\cxxsec{locale.codecvt.general}{28.4.2.5.1} +\cxxsec{locale.codecvt.members}{28.4.2.5.2} +\cxxsec{locale.codecvt.virtuals}{28.4.2.5.3} +\cxxsec{tab:locale.codecvt.inout}{104} +\cxxsec{tab:locale.codecvt.unshift}{105} +\cxxsec{locale.codecvt.byname}{28.4.2.6} +\cxxsec{category.numeric}{28.4.3} +\cxxsec{category.numeric.general}{28.4.3.1} +\cxxsec{locale.num.get}{28.4.3.2} +\cxxsec{locale.num.get.general}{28.4.3.2.1} +\cxxsec{facet.num.get.members}{28.4.3.2.2} +\cxxsec{facet.num.get.virtuals}{28.4.3.2.3} +\cxxsec{tab:facet.num.get.int}{106} +\cxxsec{tab:facet.num.get.length}{107} +\cxxsec{locale.nm.put}{28.4.3.3} +\cxxsec{locale.nm.put.general}{28.4.3.3.1} +\cxxsec{facet.num.put.members}{28.4.3.3.2} +\cxxsec{facet.num.put.virtuals}{28.4.3.3.3} +\cxxsec{tab:facet.num.put.int}{108} +\cxxsec{tab:facet.num.put.fp}{109} +\cxxsec{tab:facet.num.put.length}{110} +\cxxsec{tab:facet.num.put.conv}{111} +\cxxsec{tab:facet.num.put.fill}{112} +\cxxsec{facet.numpunct}{28.4.4} +\cxxsec{locale.numpunct}{28.4.4.1} +\cxxsec{locale.numpunct.general}{28.4.4.1.1} +\cxxsec{facet.numpunct.members}{28.4.4.1.2} +\cxxsec{facet.numpunct.virtuals}{28.4.4.1.3} +\cxxsec{locale.numpunct.byname}{28.4.4.2} +\cxxsec{category.collate}{28.4.5} +\cxxsec{locale.collate}{28.4.5.1} +\cxxsec{locale.collate.general}{28.4.5.1.1} +\cxxsec{locale.collate.members}{28.4.5.1.2} +\cxxsec{locale.collate.virtuals}{28.4.5.1.3} +\cxxsec{locale.collate.byname}{28.4.5.2} +\cxxsec{category.time}{28.4.6} +\cxxsec{category.time.general}{28.4.6.1} +\cxxsec{locale.time.get}{28.4.6.2} +\cxxsec{locale.time.get.general}{28.4.6.2.1} +\cxxsec{locale.time.get.members}{28.4.6.2.2} +\cxxsec{locale.time.get.virtuals}{28.4.6.2.3} +\cxxsec{tab:locale.time.get.dogetdate}{113} +\cxxsec{locale.time.get.byname}{28.4.6.3} +\cxxsec{locale.time.put}{28.4.6.4} +\cxxsec{locale.time.put.members}{28.4.6.4.1} +\cxxsec{locale.time.put.virtuals}{28.4.6.4.2} +\cxxsec{locale.time.put.byname}{28.4.6.5} +\cxxsec{category.monetary}{28.4.7} +\cxxsec{category.monetary.general}{28.4.7.1} +\cxxsec{locale.money.get}{28.4.7.2} +\cxxsec{locale.money.get.members}{28.4.7.2.1} +\cxxsec{locale.money.get.virtuals}{28.4.7.2.2} +\cxxsec{locale.money.put}{28.4.7.3} +\cxxsec{locale.money.put.members}{28.4.7.3.1} +\cxxsec{locale.money.put.virtuals}{28.4.7.3.2} +\cxxsec{locale.moneypunct}{28.4.7.4} +\cxxsec{locale.moneypunct.general}{28.4.7.4.1} +\cxxsec{locale.moneypunct.members}{28.4.7.4.2} +\cxxsec{locale.moneypunct.virtuals}{28.4.7.4.3} +\cxxsec{locale.moneypunct.byname}{28.4.7.5} +\cxxsec{category.messages}{28.4.8} +\cxxsec{category.messages.general}{28.4.8.1} +\cxxsec{locale.messages}{28.4.8.2} +\cxxsec{locale.messages.general}{28.4.8.2.1} +\cxxsec{locale.messages.members}{28.4.8.2.2} +\cxxsec{locale.messages.virtuals}{28.4.8.2.3} +\cxxsec{locale.messages.byname}{28.4.8.3} +\cxxsec{c.locales}{28.5} +\cxxsec{clocale.syn}{28.5.1} +\cxxsec{clocale.data.races}{28.5.2} +\cxxsec{tab:setlocale.data.races}{114} +\cxxsec{module}{Clause 10} +\cxxsec{module.unit}{10.1} +\cxxsec{module.interface}{10.2} +\cxxsec{module.import}{10.3} +\cxxsec{module.global.frag}{10.4} +\cxxsec{module.private.frag}{10.5} +\cxxsec{module.context}{10.6} +\cxxsec{module.reach}{10.7} +\cxxsec{numerics}{Clause 26} +\cxxsec{numerics.general}{26.1} +\cxxsec{tab:numerics.summary}{92} +\cxxsec{numeric.requirements}{26.2} +\cxxsec{cfenv}{26.3} +\cxxsec{cfenv.syn}{26.3.1} +\cxxsec{cfenv.thread}{26.3.2} +\cxxsec{complex.numbers}{26.4} +\cxxsec{complex.numbers.general}{26.4.1} +\cxxsec{complex.syn}{26.4.2} +\cxxsec{complex}{26.4.3} +\cxxsec{complex.special}{26.4.4} +\cxxsec{complex.members}{26.4.5} +\cxxsec{complex.member.ops}{26.4.6} +\cxxsec{complex.ops}{26.4.7} +\cxxsec{complex.value.ops}{26.4.8} +\cxxsec{complex.transcendentals}{26.4.9} +\cxxsec{cmplx.over}{26.4.10} +\cxxsec{complex.literals}{26.4.11} +\cxxsec{bit}{26.5} +\cxxsec{bit.general}{26.5.1} +\cxxsec{bit.syn}{26.5.2} +\cxxsec{bit.cast}{26.5.3} +\cxxsec{bit.pow.two}{26.5.4} +\cxxsec{bit.rotate}{26.5.5} +\cxxsec{bit.count}{26.5.6} +\cxxsec{bit.endian}{26.5.7} +\cxxsec{rand}{26.6} +\cxxsec{rand.general}{26.6.1} +\cxxsec{rand.synopsis}{26.6.2} +\cxxsec{rand.req}{26.6.3} +\cxxsec{rand.req.genl}{26.6.3.1} +\cxxsec{rand.req.seedseq}{26.6.3.2} +\cxxsec{tab:rand.req.seedseq}{93} +\cxxsec{rand.req.urng}{26.6.3.3} +\cxxsec{rand.req.eng}{26.6.3.4} +\cxxsec{tab:rand.req.eng}{94} +\cxxsec{rand.req.adapt}{26.6.3.5} +\cxxsec{rand.req.dist}{26.6.3.6} +\cxxsec{tab:rand.req.dist}{95} +\cxxsec{rand.eng}{26.6.4} +\cxxsec{rand.eng.general}{26.6.4.1} +\cxxsec{rand.eng.lcong}{26.6.4.2} +\cxxsec{rand.eng.mers}{26.6.4.3} +\cxxsec{rand.eng.sub}{26.6.4.4} +\cxxsec{rand.adapt}{26.6.5} +\cxxsec{rand.adapt.general}{26.6.5.1} +\cxxsec{rand.adapt.disc}{26.6.5.2} +\cxxsec{rand.adapt.ibits}{26.6.5.3} +\cxxsec{rand.adapt.shuf}{26.6.5.4} +\cxxsec{rand.predef}{26.6.6} +\cxxsec{rand.device}{26.6.7} +\cxxsec{rand.util}{26.6.8} +\cxxsec{rand.util.seedseq}{26.6.8.1} +\cxxsec{rand.util.canonical}{26.6.8.2} +\cxxsec{rand.dist}{26.6.9} +\cxxsec{rand.dist.general}{26.6.9.1} +\cxxsec{rand.dist.uni}{26.6.9.2} +\cxxsec{rand.dist.uni.int}{26.6.9.2.1} +\cxxsec{rand.dist.uni.real}{26.6.9.2.2} +\cxxsec{rand.dist.bern}{26.6.9.3} +\cxxsec{rand.dist.bern.bernoulli}{26.6.9.3.1} +\cxxsec{rand.dist.bern.bin}{26.6.9.3.2} +\cxxsec{rand.dist.bern.geo}{26.6.9.3.3} +\cxxsec{rand.dist.bern.negbin}{26.6.9.3.4} +\cxxsec{rand.dist.pois}{26.6.9.4} +\cxxsec{rand.dist.pois.poisson}{26.6.9.4.1} +\cxxsec{rand.dist.pois.exp}{26.6.9.4.2} +\cxxsec{rand.dist.pois.gamma}{26.6.9.4.3} +\cxxsec{rand.dist.pois.weibull}{26.6.9.4.4} +\cxxsec{rand.dist.pois.extreme}{26.6.9.4.5} +\cxxsec{rand.dist.norm}{26.6.9.5} +\cxxsec{rand.dist.norm.normal}{26.6.9.5.1} +\cxxsec{rand.dist.norm.lognormal}{26.6.9.5.2} +\cxxsec{rand.dist.norm.chisq}{26.6.9.5.3} +\cxxsec{rand.dist.norm.cauchy}{26.6.9.5.4} +\cxxsec{rand.dist.norm.f}{26.6.9.5.5} +\cxxsec{rand.dist.norm.t}{26.6.9.5.6} +\cxxsec{rand.dist.samp}{26.6.9.6} +\cxxsec{rand.dist.samp.discrete}{26.6.9.6.1} +\cxxsec{rand.dist.samp.pconst}{26.6.9.6.2} +\cxxsec{rand.dist.samp.plinear}{26.6.9.6.3} +\cxxsec{c.math.rand}{26.6.10} +\cxxsec{numarray}{26.7} +\cxxsec{valarray.syn}{26.7.1} +\cxxsec{template.valarray}{26.7.2} +\cxxsec{template.valarray.overview}{26.7.2.1} +\cxxsec{valarray.cons}{26.7.2.2} +\cxxsec{valarray.assign}{26.7.2.3} +\cxxsec{valarray.access}{26.7.2.4} +\cxxsec{valarray.sub}{26.7.2.5} +\cxxsec{valarray.unary}{26.7.2.6} +\cxxsec{valarray.cassign}{26.7.2.7} +\cxxsec{valarray.members}{26.7.2.8} +\cxxsec{valarray.nonmembers}{26.7.3} +\cxxsec{valarray.binary}{26.7.3.1} +\cxxsec{valarray.comparison}{26.7.3.2} +\cxxsec{valarray.transcend}{26.7.3.3} +\cxxsec{valarray.special}{26.7.3.4} +\cxxsec{class.slice}{26.7.4} +\cxxsec{class.slice.overview}{26.7.4.1} +\cxxsec{cons.slice}{26.7.4.2} +\cxxsec{slice.access}{26.7.4.3} +\cxxsec{slice.ops}{26.7.4.4} +\cxxsec{template.slice.array}{26.7.5} +\cxxsec{template.slice.array.overview}{26.7.5.1} +\cxxsec{slice.arr.assign}{26.7.5.2} +\cxxsec{slice.arr.comp.assign}{26.7.5.3} +\cxxsec{slice.arr.fill}{26.7.5.4} +\cxxsec{class.gslice}{26.7.6} +\cxxsec{class.gslice.overview}{26.7.6.1} +\cxxsec{gslice.cons}{26.7.6.2} +\cxxsec{gslice.access}{26.7.6.3} +\cxxsec{template.gslice.array}{26.7.7} +\cxxsec{template.gslice.array.overview}{26.7.7.1} +\cxxsec{gslice.array.assign}{26.7.7.2} +\cxxsec{gslice.array.comp.assign}{26.7.7.3} +\cxxsec{gslice.array.fill}{26.7.7.4} +\cxxsec{template.mask.array}{26.7.8} +\cxxsec{template.mask.array.overview}{26.7.8.1} +\cxxsec{mask.array.assign}{26.7.8.2} +\cxxsec{mask.array.comp.assign}{26.7.8.3} +\cxxsec{mask.array.fill}{26.7.8.4} +\cxxsec{template.indirect.array}{26.7.9} +\cxxsec{template.indirect.array.overview}{26.7.9.1} +\cxxsec{indirect.array.assign}{26.7.9.2} +\cxxsec{indirect.array.comp.assign}{26.7.9.3} +\cxxsec{indirect.array.fill}{26.7.9.4} +\cxxsec{valarray.range}{26.7.10} +\cxxsec{c.math}{26.8} +\cxxsec{cmath.syn}{26.8.1} +\cxxsec{c.math.abs}{26.8.2} +\cxxsec{c.math.hypot3}{26.8.3} +\cxxsec{c.math.lerp}{26.8.4} +\cxxsec{c.math.fpclass}{26.8.5} +\cxxsec{sf.cmath}{26.8.6} +\cxxsec{sf.cmath.general}{26.8.6.1} +\cxxsec{sf.cmath.assoc.laguerre}{26.8.6.2} +\cxxsec{sf.cmath.assoc.legendre}{26.8.6.3} +\cxxsec{sf.cmath.beta}{26.8.6.4} +\cxxsec{sf.cmath.comp.ellint.1}{26.8.6.5} +\cxxsec{sf.cmath.comp.ellint.2}{26.8.6.6} +\cxxsec{sf.cmath.comp.ellint.3}{26.8.6.7} +\cxxsec{sf.cmath.cyl.bessel.i}{26.8.6.8} +\cxxsec{sf.cmath.cyl.bessel.j}{26.8.6.9} +\cxxsec{sf.cmath.cyl.bessel.k}{26.8.6.10} +\cxxsec{sf.cmath.cyl.neumann}{26.8.6.11} +\cxxsec{sf.cmath.ellint.1}{26.8.6.12} +\cxxsec{sf.cmath.ellint.2}{26.8.6.13} +\cxxsec{sf.cmath.ellint.3}{26.8.6.14} +\cxxsec{sf.cmath.expint}{26.8.6.15} +\cxxsec{sf.cmath.hermite}{26.8.6.16} +\cxxsec{sf.cmath.laguerre}{26.8.6.17} +\cxxsec{sf.cmath.legendre}{26.8.6.18} +\cxxsec{sf.cmath.riemann.zeta}{26.8.6.19} +\cxxsec{sf.cmath.sph.bessel}{26.8.6.20} +\cxxsec{sf.cmath.sph.legendre}{26.8.6.21} +\cxxsec{sf.cmath.sph.neumann}{26.8.6.22} +\cxxsec{numbers}{26.9} +\cxxsec{numbers.syn}{26.9.1} +\cxxsec{math.constants}{26.9.2} +\cxxsec{over}{Clause 12} +\cxxsec{over.pre}{12.1} +\cxxsec{over.load}{12.2} +\cxxsec{over.dcl}{12.3} +\cxxsec{over.match}{12.4} +\cxxsec{over.match.general}{12.4.1} +\cxxsec{over.match.funcs}{12.4.2} +\cxxsec{over.match.funcs.general}{12.4.2.1} +\cxxsec{over.match.call}{12.4.2.2} +\cxxsec{over.match.call.general}{12.4.2.2.1} +\cxxsec{over.call.func}{12.4.2.2.2} +\cxxsec{over.call.object}{12.4.2.2.3} +\cxxsec{over.match.oper}{12.4.2.3} +\cxxsec{tab:over.match.oper}{15} +\cxxsec{over.match.ctor}{12.4.2.4} +\cxxsec{over.match.copy}{12.4.2.5} +\cxxsec{over.match.conv}{12.4.2.6} +\cxxsec{over.match.ref}{12.4.2.7} +\cxxsec{over.match.list}{12.4.2.8} +\cxxsec{over.match.class.deduct}{12.4.2.9} +\cxxsec{over.match.viable}{12.4.3} +\cxxsec{over.match.best}{12.4.4} +\cxxsec{over.match.best.general}{12.4.4.1} +\cxxsec{over.best.ics}{12.4.4.2} +\cxxsec{over.best.ics.general}{12.4.4.2.1} +\cxxsec{over.ics.scs}{12.4.4.2.2} +\cxxsec{tab:over.ics.scs}{16} +\cxxsec{over.ics.user}{12.4.4.2.3} +\cxxsec{over.ics.ellipsis}{12.4.4.2.4} +\cxxsec{over.ics.ref}{12.4.4.2.5} +\cxxsec{over.ics.list}{12.4.4.2.6} +\cxxsec{over.ics.rank}{12.4.4.3} +\cxxsec{over.over}{12.5} +\cxxsec{over.oper}{12.6} +\cxxsec{over.oper.general}{12.6.1} +\cxxsec{over.unary}{12.6.2} +\cxxsec{over.binary}{12.6.3} +\cxxsec{over.binary.general}{12.6.3.1} +\cxxsec{over.ass}{12.6.3.2} +\cxxsec{over.call}{12.6.4} +\cxxsec{over.sub}{12.6.5} +\cxxsec{over.ref}{12.6.6} +\cxxsec{over.inc}{12.6.7} +\cxxsec{over.built}{12.7} +\cxxsec{over.literal}{12.8} +\cxxsec{cpp}{Clause 15} +\cxxsec{cpp.pre}{15.1} +\cxxsec{cpp.cond}{15.2} +\cxxsec{tab:cpp.cond.ha}{18} +\cxxsec{cpp.include}{15.3} +\cxxsec{cpp.module}{15.4} +\cxxsec{cpp.import}{15.5} +\cxxsec{cpp.replace}{15.6} +\cxxsec{cpp.replace.general}{15.6.1} +\cxxsec{cpp.subst}{15.6.2} +\cxxsec{cpp.stringize}{15.6.3} +\cxxsec{cpp.concat}{15.6.4} +\cxxsec{cpp.rescan}{15.6.5} +\cxxsec{cpp.scope}{15.6.6} +\cxxsec{cpp.line}{15.7} +\cxxsec{cpp.error}{15.8} +\cxxsec{cpp.pragma}{15.9} +\cxxsec{cpp.null}{15.10} +\cxxsec{cpp.predefined}{15.11} +\cxxsec{tab:cpp.predefined.ft}{19} +\cxxsec{cpp.pragma.op}{15.12} +\cxxsec{ranges}{Clause 24} +\cxxsec{ranges.general}{24.1} +\cxxsec{tab:range.summary}{90} +\cxxsec{ranges.syn}{24.2} +\cxxsec{range.access}{24.3} +\cxxsec{range.access.general}{24.3.1} +\cxxsec{range.access.begin}{24.3.2} +\cxxsec{range.access.end}{24.3.3} +\cxxsec{range.access.cbegin}{24.3.4} +\cxxsec{range.access.cend}{24.3.5} +\cxxsec{range.access.rbegin}{24.3.6} +\cxxsec{range.access.rend}{24.3.7} +\cxxsec{range.access.crbegin}{24.3.8} +\cxxsec{range.access.crend}{24.3.9} +\cxxsec{range.prim.size}{24.3.10} +\cxxsec{range.prim.ssize}{24.3.11} +\cxxsec{range.prim.empty}{24.3.12} +\cxxsec{range.prim.data}{24.3.13} +\cxxsec{range.prim.cdata}{24.3.14} +\cxxsec{range.req}{24.4} +\cxxsec{range.req.general}{24.4.1} +\cxxsec{range.range}{24.4.2} +\cxxsec{range.sized}{24.4.3} +\cxxsec{range.view}{24.4.4} +\cxxsec{range.refinements}{24.4.5} +\cxxsec{range.utility}{24.5} +\cxxsec{range.utility.general}{24.5.1} +\cxxsec{range.utility.helpers}{24.5.2} +\cxxsec{view.interface}{24.5.3} +\cxxsec{view.interface.general}{24.5.3.1} +\cxxsec{view.interface.members}{24.5.3.2} +\cxxsec{range.subrange}{24.5.4} +\cxxsec{range.subrange.general}{24.5.4.1} +\cxxsec{range.subrange.ctor}{24.5.4.2} +\cxxsec{range.subrange.access}{24.5.4.3} +\cxxsec{range.dangling}{24.5.5} +\cxxsec{range.factories}{24.6} +\cxxsec{range.factories.general}{24.6.1} +\cxxsec{range.empty}{24.6.2} +\cxxsec{range.empty.overview}{24.6.2.1} +\cxxsec{range.empty.view}{24.6.2.2} +\cxxsec{range.single}{24.6.3} +\cxxsec{range.single.overview}{24.6.3.1} +\cxxsec{range.single.view}{24.6.3.2} +\cxxsec{range.iota}{24.6.4} +\cxxsec{range.iota.overview}{24.6.4.1} +\cxxsec{range.iota.view}{24.6.4.2} +\cxxsec{range.iota.iterator}{24.6.4.3} +\cxxsec{range.iota.sentinel}{24.6.4.4} +\cxxsec{range.istream}{24.6.5} +\cxxsec{range.istream.overview}{24.6.5.1} +\cxxsec{range.istream.view}{24.6.5.2} +\cxxsec{range.istream.iterator}{24.6.5.3} +\cxxsec{range.adaptors}{24.7} +\cxxsec{range.adaptors.general}{24.7.1} +\cxxsec{range.adaptor.object}{24.7.2} +\cxxsec{range.semi.wrap}{24.7.3} +\cxxsec{range.all}{24.7.4} +\cxxsec{range.all.general}{24.7.4.1} +\cxxsec{range.ref.view}{24.7.4.2} +\cxxsec{range.filter}{24.7.5} +\cxxsec{range.filter.overview}{24.7.5.1} +\cxxsec{range.filter.view}{24.7.5.2} +\cxxsec{range.filter.iterator}{24.7.5.3} +\cxxsec{range.filter.sentinel}{24.7.5.4} +\cxxsec{range.transform}{24.7.6} +\cxxsec{range.transform.overview}{24.7.6.1} +\cxxsec{range.transform.view}{24.7.6.2} +\cxxsec{range.transform.iterator}{24.7.6.3} +\cxxsec{range.transform.sentinel}{24.7.6.4} +\cxxsec{range.take}{24.7.7} +\cxxsec{range.take.overview}{24.7.7.1} +\cxxsec{range.take.view}{24.7.7.2} +\cxxsec{range.take.sentinel}{24.7.7.3} +\cxxsec{range.take.while}{24.7.8} +\cxxsec{range.take.while.overview}{24.7.8.1} +\cxxsec{range.take.while.view}{24.7.8.2} +\cxxsec{range.take.while.sentinel}{24.7.8.3} +\cxxsec{range.drop}{24.7.9} +\cxxsec{range.drop.overview}{24.7.9.1} +\cxxsec{range.drop.view}{24.7.9.2} +\cxxsec{range.drop.while}{24.7.10} +\cxxsec{range.drop.while.overview}{24.7.10.1} +\cxxsec{range.drop.while.view}{24.7.10.2} +\cxxsec{range.join}{24.7.11} +\cxxsec{range.join.overview}{24.7.11.1} +\cxxsec{range.join.view}{24.7.11.2} +\cxxsec{range.join.iterator}{24.7.11.3} +\cxxsec{range.join.sentinel}{24.7.11.4} +\cxxsec{range.split}{24.7.12} +\cxxsec{range.split.overview}{24.7.12.1} +\cxxsec{range.split.view}{24.7.12.2} +\cxxsec{range.split.outer}{24.7.12.3} +\cxxsec{range.split.outer.value}{24.7.12.4} +\cxxsec{range.split.inner}{24.7.12.5} +\cxxsec{range.counted}{24.7.13} +\cxxsec{range.common}{24.7.14} +\cxxsec{range.common.overview}{24.7.14.1} +\cxxsec{range.common.view}{24.7.14.2} +\cxxsec{range.reverse}{24.7.15} +\cxxsec{range.reverse.overview}{24.7.15.1} +\cxxsec{range.reverse.view}{24.7.15.2} +\cxxsec{range.elements}{24.7.16} +\cxxsec{range.elements.overview}{24.7.16.1} +\cxxsec{range.elements.view}{24.7.16.2} +\cxxsec{range.elements.iterator}{24.7.16.3} +\cxxsec{range.elements.sentinel}{24.7.16.4} +\cxxsec{re}{Clause 30} +\cxxsec{re.general}{30.1} +\cxxsec{tab:re.summary}{134} +\cxxsec{re.def}{30.2} +\cxxsec{defns.regex.collating.element}{30.2.1} +\cxxsec{defns.regex.finite.state.machine}{30.2.2} +\cxxsec{defns.regex.format.specifier}{30.2.3} +\cxxsec{defns.regex.matched}{30.2.4} +\cxxsec{defns.regex.primary.equivalence.class}{30.2.5} +\cxxsec{defns.regex.regular.expression}{30.2.6} +\cxxsec{defns.regex.subexpression}{30.2.7} +\cxxsec{re.req}{30.3} +\cxxsec{tab:re.req}{135} +\cxxsec{re.syn}{30.4} +\cxxsec{re.const}{30.5} +\cxxsec{re.const.general}{30.5.1} +\cxxsec{re.synopt}{30.5.2} +\cxxsec{re.matchflag}{30.5.3} +\cxxsec{tab:re.synopt}{136} +\cxxsec{tab:re.matchflag}{137} +\cxxsec{re.err}{30.5.4} +\cxxsec{tab:re.err}{138} +\cxxsec{re.badexp}{30.6} +\cxxsec{re.traits}{30.7} +\cxxsec{re.regex}{30.8} +\cxxsec{re.regex.general}{30.8.1} +\cxxsec{tab:re.traits.classnames}{139} +\cxxsec{re.regex.construct}{30.8.2} +\cxxsec{re.regex.assign}{30.8.3} +\cxxsec{re.regex.operations}{30.8.4} +\cxxsec{re.regex.locale}{30.8.5} +\cxxsec{re.regex.swap}{30.8.6} +\cxxsec{re.regex.nonmemb}{30.8.7} +\cxxsec{re.submatch}{30.9} +\cxxsec{re.submatch.general}{30.9.1} +\cxxsec{re.submatch.members}{30.9.2} +\cxxsec{re.submatch.op}{30.9.3} +\cxxsec{re.results}{30.10} +\cxxsec{re.results.general}{30.10.1} +\cxxsec{re.results.const}{30.10.2} +\cxxsec{tab:re.results.const}{140} +\cxxsec{re.results.state}{30.10.3} +\cxxsec{re.results.size}{30.10.4} +\cxxsec{re.results.acc}{30.10.5} +\cxxsec{re.results.form}{30.10.6} +\cxxsec{re.results.all}{30.10.7} +\cxxsec{re.results.swap}{30.10.8} +\cxxsec{re.results.nonmember}{30.10.9} +\cxxsec{re.alg}{30.11} +\cxxsec{re.except}{30.11.1} +\cxxsec{re.alg.match}{30.11.2} +\cxxsec{tab:re.alg.match}{141} +\cxxsec{re.alg.search}{30.11.3} +\cxxsec{tab:re.alg.search}{142} +\cxxsec{re.alg.replace}{30.11.4} +\cxxsec{re.iter}{30.12} +\cxxsec{re.regiter}{30.12.1} +\cxxsec{re.regiter.general}{30.12.1.1} +\cxxsec{re.regiter.cnstr}{30.12.1.2} +\cxxsec{re.regiter.comp}{30.12.1.3} +\cxxsec{re.regiter.deref}{30.12.1.4} +\cxxsec{re.regiter.incr}{30.12.1.5} +\cxxsec{re.tokiter}{30.12.2} +\cxxsec{re.tokiter.general}{30.12.2.1} +\cxxsec{re.tokiter.cnstr}{30.12.2.2} +\cxxsec{re.tokiter.comp}{30.12.2.3} +\cxxsec{re.tokiter.deref}{30.12.2.4} +\cxxsec{re.tokiter.incr}{30.12.2.5} +\cxxsec{re.grammar}{30.13} +\cxxsec{stmt.stmt}{Clause 8} +\cxxsec{stmt.pre}{8.1} +\cxxsec{stmt.label}{8.2} +\cxxsec{stmt.expr}{8.3} +\cxxsec{stmt.block}{8.4} +\cxxsec{stmt.select}{8.5} +\cxxsec{stmt.select.general}{8.5.1} +\cxxsec{stmt.if}{8.5.2} +\cxxsec{stmt.switch}{8.5.3} +\cxxsec{stmt.iter}{8.6} +\cxxsec{stmt.iter.general}{8.6.1} +\cxxsec{stmt.while}{8.6.2} +\cxxsec{stmt.do}{8.6.3} +\cxxsec{stmt.for}{8.6.4} +\cxxsec{stmt.ranged}{8.6.5} +\cxxsec{stmt.jump}{8.7} +\cxxsec{stmt.jump.general}{8.7.1} +\cxxsec{stmt.break}{8.7.2} +\cxxsec{stmt.cont}{8.7.3} +\cxxsec{stmt.return}{8.7.4} +\cxxsec{stmt.return.coroutine}{8.7.5} +\cxxsec{stmt.goto}{8.7.6} +\cxxsec{stmt.dcl}{8.8} +\cxxsec{stmt.ambig}{8.9} +\cxxsec{strings}{Clause 21} +\cxxsec{strings.general}{21.1} +\cxxsec{tab:strings.summary}{68} +\cxxsec{char.traits}{21.2} +\cxxsec{char.traits.general}{21.2.1} +\cxxsec{char.traits.require}{21.2.2} +\cxxsec{tab:char.traits.req}{69} +\cxxsec{char.traits.typedefs}{21.2.3} +\cxxsec{char.traits.specializations}{21.2.4} +\cxxsec{char.traits.specializations.general}{21.2.4.1} +\cxxsec{char.traits.specializations.char}{21.2.4.2} +\cxxsec{char.traits.specializations.char8.t}{21.2.4.3} +\cxxsec{char.traits.specializations.char16.t}{21.2.4.4} +\cxxsec{char.traits.specializations.char32.t}{21.2.4.5} +\cxxsec{char.traits.specializations.wchar.t}{21.2.4.6} +\cxxsec{string.classes}{21.3} +\cxxsec{string.classes.general}{21.3.1} +\cxxsec{string.syn}{21.3.2} +\cxxsec{basic.string}{21.3.3} +\cxxsec{basic.string.general}{21.3.3.1} +\cxxsec{string.require}{21.3.3.2} +\cxxsec{string.cons}{21.3.3.3} +\cxxsec{string.iterators}{21.3.3.4} +\cxxsec{string.capacity}{21.3.3.5} +\cxxsec{string.access}{21.3.3.6} +\cxxsec{string.modifiers}{21.3.3.7} +\cxxsec{string.op.append}{21.3.3.7.1} +\cxxsec{string.append}{21.3.3.7.2} +\cxxsec{string.assign}{21.3.3.7.3} +\cxxsec{string.insert}{21.3.3.7.4} +\cxxsec{string.erase}{21.3.3.7.5} +\cxxsec{string.replace}{21.3.3.7.6} +\cxxsec{string.copy}{21.3.3.7.7} +\cxxsec{string.swap}{21.3.3.7.8} +\cxxsec{string.ops}{21.3.3.8} +\cxxsec{string.accessors}{21.3.3.8.1} +\cxxsec{string.find}{21.3.3.8.2} +\cxxsec{string.substr}{21.3.3.8.3} +\cxxsec{string.compare}{21.3.3.8.4} +\cxxsec{string.starts.with}{21.3.3.8.5} +\cxxsec{string.ends.with}{21.3.3.8.6} +\cxxsec{string.nonmembers}{21.3.4} +\cxxsec{string.op.plus}{21.3.4.1} +\cxxsec{string.cmp}{21.3.4.2} +\cxxsec{string.special}{21.3.4.3} +\cxxsec{string.io}{21.3.4.4} +\cxxsec{string.erasure}{21.3.4.5} +\cxxsec{string.conversions}{21.3.5} +\cxxsec{basic.string.hash}{21.3.6} +\cxxsec{basic.string.literals}{21.3.7} +\cxxsec{string.view}{21.4} +\cxxsec{string.view.general}{21.4.1} +\cxxsec{string.view.synop}{21.4.2} +\cxxsec{string.view.template}{21.4.3} +\cxxsec{string.view.template.general}{21.4.3.1} +\cxxsec{string.view.cons}{21.4.3.2} +\cxxsec{string.view.iterators}{21.4.3.3} +\cxxsec{string.view.capacity}{21.4.3.4} +\cxxsec{string.view.access}{21.4.3.5} +\cxxsec{string.view.modifiers}{21.4.3.6} +\cxxsec{string.view.ops}{21.4.3.7} +\cxxsec{tab:string.view.compare}{70} +\cxxsec{string.view.find}{21.4.3.8} +\cxxsec{string.view.deduct}{21.4.4} +\cxxsec{string.view.comparison}{21.4.5} +\cxxsec{tab:string.view.comparison.overloads}{71} +\cxxsec{string.view.io}{21.4.6} +\cxxsec{string.view.hash}{21.4.7} +\cxxsec{string.view.literals}{21.4.8} +\cxxsec{c.strings}{21.5} +\cxxsec{cctype.syn}{21.5.1} +\cxxsec{cwctype.syn}{21.5.2} +\cxxsec{cstring.syn}{21.5.3} +\cxxsec{cwchar.syn}{21.5.4} +\cxxsec{cuchar.syn}{21.5.5} +\cxxsec{c.mb.wcs}{21.5.6} +\cxxsec{support}{Clause 17} +\cxxsec{support.general}{17.1} +\cxxsec{tab:support.summary}{37} +\cxxsec{support.types}{17.2} +\cxxsec{cstddef.syn}{17.2.1} +\cxxsec{cstdlib.syn}{17.2.2} +\cxxsec{support.types.nullptr}{17.2.3} +\cxxsec{support.types.layout}{17.2.4} +\cxxsec{support.types.byteops}{17.2.5} +\cxxsec{support.limits}{17.3} +\cxxsec{support.limits.general}{17.3.1} +\cxxsec{version.syn}{17.3.2} +\cxxsec{limits.syn}{17.3.3} +\cxxsec{fp.style}{17.3.4} +\cxxsec{round.style}{17.3.4.1} +\cxxsec{denorm.style}{17.3.4.2} +\cxxsec{numeric.limits}{17.3.5} +\cxxsec{numeric.limits.general}{17.3.5.1} +\cxxsec{numeric.limits.members}{17.3.5.2} +\cxxsec{numeric.special}{17.3.5.3} +\cxxsec{climits.syn}{17.3.6} +\cxxsec{cfloat.syn}{17.3.7} +\cxxsec{cstdint}{17.4} +\cxxsec{cstdint.general}{17.4.1} +\cxxsec{cstdint.syn}{17.4.2} +\cxxsec{support.start.term}{17.5} +\cxxsec{support.dynamic}{17.6} +\cxxsec{support.dynamic.general}{17.6.1} +\cxxsec{new.syn}{17.6.2} +\cxxsec{new.delete}{17.6.3} +\cxxsec{new.delete.general}{17.6.3.1} +\cxxsec{new.delete.single}{17.6.3.2} +\cxxsec{new.delete.array}{17.6.3.3} +\cxxsec{new.delete.placement}{17.6.3.4} +\cxxsec{new.delete.dataraces}{17.6.3.5} +\cxxsec{alloc.errors}{17.6.4} +\cxxsec{bad.alloc}{17.6.4.1} +\cxxsec{new.badlength}{17.6.4.2} +\cxxsec{new.handler}{17.6.4.3} +\cxxsec{set.new.handler}{17.6.4.4} +\cxxsec{get.new.handler}{17.6.4.5} +\cxxsec{ptr.launder}{17.6.5} +\cxxsec{hardware.interference}{17.6.6} +\cxxsec{support.rtti}{17.7} +\cxxsec{support.rtti.general}{17.7.1} +\cxxsec{typeinfo.syn}{17.7.2} +\cxxsec{type.info}{17.7.3} +\cxxsec{bad.cast}{17.7.4} +\cxxsec{bad.typeid}{17.7.5} +\cxxsec{support.srcloc}{17.8} +\cxxsec{source.location.syn}{17.8.1} +\cxxsec{support.srcloc.class}{17.8.2} +\cxxsec{support.srcloc.class.general}{17.8.2.1} +\cxxsec{support.srcloc.cons}{17.8.2.2} +\cxxsec{tab:support.srcloc.current}{38} +\cxxsec{support.srcloc.obs}{17.8.2.3} +\cxxsec{support.exception}{17.9} +\cxxsec{support.exception.general}{17.9.1} +\cxxsec{exception.syn}{17.9.2} +\cxxsec{exception}{17.9.3} +\cxxsec{bad.exception}{17.9.4} +\cxxsec{exception.terminate}{17.9.5} +\cxxsec{terminate.handler}{17.9.5.1} +\cxxsec{set.terminate}{17.9.5.2} +\cxxsec{get.terminate}{17.9.5.3} +\cxxsec{terminate}{17.9.5.4} +\cxxsec{uncaught.exceptions}{17.9.6} +\cxxsec{propagation}{17.9.7} +\cxxsec{except.nested}{17.9.8} +\cxxsec{support.initlist}{17.10} +\cxxsec{support.initlist.general}{17.10.1} +\cxxsec{initializer.list.syn}{17.10.2} +\cxxsec{support.initlist.cons}{17.10.3} +\cxxsec{support.initlist.access}{17.10.4} +\cxxsec{support.initlist.range}{17.10.5} +\cxxsec{cmp}{17.11} +\cxxsec{compare.syn}{17.11.1} +\cxxsec{cmp.categories}{17.11.2} +\cxxsec{cmp.categories.pre}{17.11.2.1} +\cxxsec{cmp.partialord}{17.11.2.2} +\cxxsec{cmp.weakord}{17.11.2.3} +\cxxsec{cmp.strongord}{17.11.2.4} +\cxxsec{cmp.common}{17.11.3} +\cxxsec{cmp.concept}{17.11.4} +\cxxsec{cmp.result}{17.11.5} +\cxxsec{cmp.alg}{17.11.6} +\cxxsec{support.coroutine}{17.12} +\cxxsec{support.coroutine.general}{17.12.1} +\cxxsec{coroutine.syn}{17.12.2} +\cxxsec{coroutine.traits}{17.12.3} +\cxxsec{coroutine.traits.general}{17.12.3.1} +\cxxsec{coroutine.traits.primary}{17.12.3.2} +\cxxsec{coroutine.handle}{17.12.4} +\cxxsec{coroutine.handle.general}{17.12.4.1} +\cxxsec{coroutine.handle.con}{17.12.4.2} +\cxxsec{coroutine.handle.export.import}{17.12.4.3} +\cxxsec{coroutine.handle.observers}{17.12.4.4} +\cxxsec{coroutine.handle.resumption}{17.12.4.5} +\cxxsec{coroutine.handle.promise}{17.12.4.6} +\cxxsec{coroutine.handle.compare}{17.12.4.7} +\cxxsec{coroutine.handle.hash}{17.12.4.8} +\cxxsec{coroutine.noop}{17.12.5} +\cxxsec{coroutine.promise.noop}{17.12.5.1} +\cxxsec{coroutine.handle.noop}{17.12.5.2} +\cxxsec{coroutine.handle.noop.observers}{17.12.5.2.1} +\cxxsec{coroutine.handle.noop.resumption}{17.12.5.2.2} +\cxxsec{coroutine.handle.noop.promise}{17.12.5.2.3} +\cxxsec{coroutine.handle.noop.address}{17.12.5.2.4} +\cxxsec{coroutine.noop.coroutine}{17.12.5.3} +\cxxsec{coroutine.trivial.awaitables}{17.12.6} +\cxxsec{support.runtime}{17.13} +\cxxsec{support.runtime.general}{17.13.1} +\cxxsec{cstdarg.syn}{17.13.2} +\cxxsec{csetjmp.syn}{17.13.3} +\cxxsec{csignal.syn}{17.13.4} +\cxxsec{support.signal}{17.13.5} +\cxxsec{temp}{Clause 13} +\cxxsec{temp.pre}{13.1} +\cxxsec{temp.param}{13.2} +\cxxsec{temp.names}{13.3} +\cxxsec{temp.arg}{13.4} +\cxxsec{temp.arg.general}{13.4.1} +\cxxsec{temp.arg.type}{13.4.2} +\cxxsec{temp.arg.nontype}{13.4.3} +\cxxsec{temp.arg.template}{13.4.4} +\cxxsec{temp.constr}{13.5} +\cxxsec{temp.constr.general}{13.5.1} +\cxxsec{temp.constr.constr}{13.5.2} +\cxxsec{temp.constr.constr.general}{13.5.2.1} +\cxxsec{temp.constr.op}{13.5.2.2} +\cxxsec{temp.constr.atomic}{13.5.2.3} +\cxxsec{temp.constr.decl}{13.5.3} +\cxxsec{temp.constr.normal}{13.5.4} +\cxxsec{temp.constr.order}{13.5.5} +\cxxsec{temp.type}{13.6} +\cxxsec{temp.decls}{13.7} +\cxxsec{temp.decls.general}{13.7.1} +\cxxsec{temp.class}{13.7.2} +\cxxsec{temp.class.general}{13.7.2.1} +\cxxsec{temp.mem.func}{13.7.2.2} +\cxxsec{temp.deduct.guide}{13.7.2.3} +\cxxsec{temp.mem.class}{13.7.2.4} +\cxxsec{temp.static}{13.7.2.5} +\cxxsec{temp.mem.enum}{13.7.2.6} +\cxxsec{temp.mem}{13.7.3} +\cxxsec{temp.variadic}{13.7.4} +\cxxsec{tab:temp.fold.empty}{17} +\cxxsec{temp.friend}{13.7.5} +\cxxsec{temp.class.spec}{13.7.6} +\cxxsec{temp.class.spec.general}{13.7.6.1} +\cxxsec{temp.class.spec.match}{13.7.6.2} +\cxxsec{temp.class.order}{13.7.6.3} +\cxxsec{temp.class.spec.mfunc}{13.7.6.4} +\cxxsec{temp.fct}{13.7.7} +\cxxsec{temp.fct.general}{13.7.7.1} +\cxxsec{temp.over.link}{13.7.7.2} +\cxxsec{temp.func.order}{13.7.7.3} +\cxxsec{temp.alias}{13.7.8} +\cxxsec{temp.concept}{13.7.9} +\cxxsec{temp.res}{13.8} +\cxxsec{temp.res.general}{13.8.1} +\cxxsec{temp.local}{13.8.2} +\cxxsec{temp.dep}{13.8.3} +\cxxsec{temp.dep.general}{13.8.3.1} +\cxxsec{temp.dep.type}{13.8.3.2} +\cxxsec{temp.dep.expr}{13.8.3.3} +\cxxsec{temp.dep.constexpr}{13.8.3.4} +\cxxsec{temp.dep.temp}{13.8.3.5} +\cxxsec{temp.nondep}{13.8.4} +\cxxsec{temp.dep.res}{13.8.5} +\cxxsec{temp.point}{13.8.5.1} +\cxxsec{temp.dep.candidate}{13.8.5.2} +\cxxsec{temp.inject}{13.8.6} +\cxxsec{temp.spec}{13.9} +\cxxsec{temp.spec.general}{13.9.1} +\cxxsec{temp.inst}{13.9.2} +\cxxsec{temp.explicit}{13.9.3} +\cxxsec{temp.expl.spec}{13.9.4} +\cxxsec{temp.fct.spec}{13.10} +\cxxsec{temp.fct.spec.general}{13.10.1} +\cxxsec{temp.arg.explicit}{13.10.2} +\cxxsec{temp.deduct}{13.10.3} +\cxxsec{temp.deduct.general}{13.10.3.1} +\cxxsec{temp.deduct.call}{13.10.3.2} +\cxxsec{temp.deduct.funcaddr}{13.10.3.3} +\cxxsec{temp.deduct.conv}{13.10.3.4} +\cxxsec{temp.deduct.partial}{13.10.3.5} +\cxxsec{temp.deduct.type}{13.10.3.6} +\cxxsec{temp.deduct.decl}{13.10.3.7} +\cxxsec{temp.over}{13.10.4} +\cxxsec{thread}{Clause 32} +\cxxsec{thread.general}{32.1} +\cxxsec{tab:thread.summary}{146} +\cxxsec{thread.req}{32.2} +\cxxsec{thread.req.paramname}{32.2.1} +\cxxsec{thread.req.exception}{32.2.2} +\cxxsec{thread.req.native}{32.2.3} +\cxxsec{thread.req.timing}{32.2.4} +\cxxsec{thread.req.lockable}{32.2.5} +\cxxsec{thread.req.lockable.general}{32.2.5.1} +\cxxsec{thread.req.lockable.basic}{32.2.5.2} +\cxxsec{thread.req.lockable.req}{32.2.5.3} +\cxxsec{thread.req.lockable.timed}{32.2.5.4} +\cxxsec{thread.stoptoken}{32.3} +\cxxsec{thread.stoptoken.intro}{32.3.1} +\cxxsec{thread.stoptoken.syn}{32.3.2} +\cxxsec{stoptoken}{32.3.3} +\cxxsec{stoptoken.general}{32.3.3.1} +\cxxsec{stoptoken.cons}{32.3.3.2} +\cxxsec{stoptoken.mem}{32.3.3.3} +\cxxsec{stoptoken.nonmembers}{32.3.3.4} +\cxxsec{stopsource}{32.3.4} +\cxxsec{stopsource.general}{32.3.4.1} +\cxxsec{stopsource.cons}{32.3.4.2} +\cxxsec{stopsource.mem}{32.3.4.3} +\cxxsec{stopsource.nonmembers}{32.3.4.4} +\cxxsec{stopcallback}{32.3.5} +\cxxsec{stopcallback.general}{32.3.5.1} +\cxxsec{stopcallback.cons}{32.3.5.2} +\cxxsec{thread.threads}{32.4} +\cxxsec{thread.threads.general}{32.4.1} +\cxxsec{thread.syn}{32.4.2} +\cxxsec{thread.thread.class}{32.4.3} +\cxxsec{thread.thread.class.general}{32.4.3.1} +\cxxsec{thread.thread.id}{32.4.3.2} +\cxxsec{thread.thread.constr}{32.4.3.3} +\cxxsec{thread.thread.destr}{32.4.3.4} +\cxxsec{thread.thread.assign}{32.4.3.5} +\cxxsec{thread.thread.member}{32.4.3.6} +\cxxsec{thread.thread.static}{32.4.3.7} +\cxxsec{thread.thread.algorithm}{32.4.3.8} +\cxxsec{thread.jthread.class}{32.4.4} +\cxxsec{thread.jthread.class.general}{32.4.4.1} +\cxxsec{thread.jthread.cons}{32.4.4.2} +\cxxsec{thread.jthread.mem}{32.4.4.3} +\cxxsec{thread.jthread.stop}{32.4.4.4} +\cxxsec{thread.jthread.special}{32.4.4.5} +\cxxsec{thread.jthread.static}{32.4.4.6} +\cxxsec{thread.thread.this}{32.4.5} +\cxxsec{thread.mutex}{32.5} +\cxxsec{thread.mutex.general}{32.5.1} +\cxxsec{mutex.syn}{32.5.2} +\cxxsec{shared.mutex.syn}{32.5.3} +\cxxsec{thread.mutex.requirements}{32.5.4} +\cxxsec{thread.mutex.requirements.general}{32.5.4.1} +\cxxsec{thread.mutex.requirements.mutex}{32.5.4.2} +\cxxsec{thread.mutex.requirements.mutex.general}{32.5.4.2.1} +\cxxsec{thread.mutex.class}{32.5.4.2.2} +\cxxsec{thread.mutex.recursive}{32.5.4.2.3} +\cxxsec{thread.timedmutex.requirements}{32.5.4.3} +\cxxsec{thread.timedmutex.requirements.general}{32.5.4.3.1} +\cxxsec{thread.timedmutex.class}{32.5.4.3.2} +\cxxsec{thread.timedmutex.recursive}{32.5.4.3.3} +\cxxsec{thread.sharedmutex.requirements}{32.5.4.4} +\cxxsec{thread.sharedmutex.requirements.general}{32.5.4.4.1} +\cxxsec{thread.sharedmutex.class}{32.5.4.4.2} +\cxxsec{thread.sharedtimedmutex.requirements}{32.5.4.5} +\cxxsec{thread.sharedtimedmutex.requirements.general}{32.5.4.5.1} +\cxxsec{thread.sharedtimedmutex.class}{32.5.4.5.2} +\cxxsec{thread.lock}{32.5.5} +\cxxsec{thread.lock.general}{32.5.5.1} +\cxxsec{thread.lock.guard}{32.5.5.2} +\cxxsec{thread.lock.scoped}{32.5.5.3} +\cxxsec{thread.lock.unique}{32.5.5.4} +\cxxsec{thread.lock.unique.general}{32.5.5.4.1} +\cxxsec{thread.lock.unique.cons}{32.5.5.4.2} +\cxxsec{thread.lock.unique.locking}{32.5.5.4.3} +\cxxsec{thread.lock.unique.mod}{32.5.5.4.4} +\cxxsec{thread.lock.unique.obs}{32.5.5.4.5} +\cxxsec{thread.lock.shared}{32.5.5.5} +\cxxsec{thread.lock.shared.general}{32.5.5.5.1} +\cxxsec{thread.lock.shared.cons}{32.5.5.5.2} +\cxxsec{thread.lock.shared.locking}{32.5.5.5.3} +\cxxsec{thread.lock.shared.mod}{32.5.5.5.4} +\cxxsec{thread.lock.shared.obs}{32.5.5.5.5} +\cxxsec{thread.lock.algorithm}{32.5.6} +\cxxsec{thread.once}{32.5.7} +\cxxsec{thread.once.onceflag}{32.5.7.1} +\cxxsec{thread.once.callonce}{32.5.7.2} +\cxxsec{thread.condition}{32.6} +\cxxsec{thread.condition.general}{32.6.1} +\cxxsec{condition.variable.syn}{32.6.2} +\cxxsec{thread.condition.nonmember}{32.6.3} +\cxxsec{thread.condition.condvar}{32.6.4} +\cxxsec{thread.condition.condvarany}{32.6.5} +\cxxsec{thread.condition.condvarany.general}{32.6.5.1} +\cxxsec{thread.condvarany.wait}{32.6.5.2} +\cxxsec{thread.condvarany.intwait}{32.6.5.3} +\cxxsec{thread.sema}{32.7} +\cxxsec{thread.sema.general}{32.7.1} +\cxxsec{semaphore.syn}{32.7.2} +\cxxsec{thread.sema.cnt}{32.7.3} +\cxxsec{thread.coord}{32.8} +\cxxsec{thread.coord.general}{32.8.1} +\cxxsec{thread.latch}{32.8.2} +\cxxsec{thread.latch.general}{32.8.2.1} +\cxxsec{latch.syn}{32.8.2.2} +\cxxsec{thread.latch.class}{32.8.2.3} +\cxxsec{thread.barrier}{32.8.3} +\cxxsec{thread.barrier.general}{32.8.3.1} +\cxxsec{barrier.syn}{32.8.3.2} +\cxxsec{thread.barrier.class}{32.8.3.3} +\cxxsec{futures}{32.9} +\cxxsec{futures.overview}{32.9.1} +\cxxsec{future.syn}{32.9.2} +\cxxsec{futures.errors}{32.9.3} +\cxxsec{futures.future.error}{32.9.4} +\cxxsec{futures.state}{32.9.5} +\cxxsec{futures.promise}{32.9.6} +\cxxsec{futures.unique.future}{32.9.7} +\cxxsec{futures.shared.future}{32.9.8} +\cxxsec{futures.async}{32.9.9} +\cxxsec{futures.task}{32.9.10} +\cxxsec{futures.task.general}{32.9.10.1} +\cxxsec{futures.task.members}{32.9.10.2} +\cxxsec{futures.task.nonmembers}{32.9.10.3} +\cxxsec{time}{Clause 27} +\cxxsec{time.general}{27.1} +\cxxsec{tab:time.summary}{96} +\cxxsec{time.syn}{27.2} +\cxxsec{time.clock.req}{27.3} +\cxxsec{tab:time.clock}{97} +\cxxsec{time.traits}{27.4} +\cxxsec{time.traits.is.fp}{27.4.1} +\cxxsec{time.traits.duration.values}{27.4.2} +\cxxsec{time.traits.specializations}{27.4.3} +\cxxsec{time.traits.is.clock}{27.4.4} +\cxxsec{time.duration}{27.5} +\cxxsec{time.duration.general}{27.5.1} +\cxxsec{time.duration.cons}{27.5.2} +\cxxsec{time.duration.observer}{27.5.3} +\cxxsec{time.duration.arithmetic}{27.5.4} +\cxxsec{time.duration.special}{27.5.5} +\cxxsec{time.duration.nonmember}{27.5.6} +\cxxsec{time.duration.comparisons}{27.5.7} +\cxxsec{time.duration.cast}{27.5.8} +\cxxsec{time.duration.literals}{27.5.9} +\cxxsec{time.duration.alg}{27.5.10} +\cxxsec{time.duration.io}{27.5.11} +\cxxsec{time.point}{27.6} +\cxxsec{time.point.general}{27.6.1} +\cxxsec{time.point.cons}{27.6.2} +\cxxsec{time.point.observer}{27.6.3} +\cxxsec{time.point.arithmetic}{27.6.4} +\cxxsec{time.point.special}{27.6.5} +\cxxsec{time.point.nonmember}{27.6.6} +\cxxsec{time.point.comparisons}{27.6.7} +\cxxsec{time.point.cast}{27.6.8} +\cxxsec{time.clock}{27.7} +\cxxsec{time.clock.general}{27.7.1} +\cxxsec{time.clock.system}{27.7.2} +\cxxsec{time.clock.system.overview}{27.7.2.1} +\cxxsec{time.clock.system.members}{27.7.2.2} +\cxxsec{time.clock.system.nonmembers}{27.7.2.3} +\cxxsec{time.clock.utc}{27.7.3} +\cxxsec{time.clock.utc.overview}{27.7.3.1} +\cxxsec{time.clock.utc.members}{27.7.3.2} +\cxxsec{time.clock.utc.nonmembers}{27.7.3.3} +\cxxsec{time.clock.tai}{27.7.4} +\cxxsec{time.clock.tai.overview}{27.7.4.1} +\cxxsec{time.clock.tai.members}{27.7.4.2} +\cxxsec{time.clock.tai.nonmembers}{27.7.4.3} +\cxxsec{time.clock.gps}{27.7.5} +\cxxsec{time.clock.gps.overview}{27.7.5.1} +\cxxsec{time.clock.gps.members}{27.7.5.2} +\cxxsec{time.clock.gps.nonmembers}{27.7.5.3} +\cxxsec{time.clock.file}{27.7.6} +\cxxsec{time.clock.file.overview}{27.7.6.1} +\cxxsec{time.clock.file.members}{27.7.6.2} +\cxxsec{time.clock.file.nonmembers}{27.7.6.3} +\cxxsec{time.clock.steady}{27.7.7} +\cxxsec{time.clock.hires}{27.7.8} +\cxxsec{time.clock.local}{27.7.9} +\cxxsec{time.clock.cast}{27.7.10} +\cxxsec{time.clock.conv}{27.7.10.1} +\cxxsec{time.clock.cast.id}{27.7.10.2} +\cxxsec{time.clock.cast.sys.utc}{27.7.10.3} +\cxxsec{time.clock.cast.sys}{27.7.10.4} +\cxxsec{time.clock.cast.utc}{27.7.10.5} +\cxxsec{time.clock.cast.fn}{27.7.10.6} +\cxxsec{time.cal}{27.8} +\cxxsec{time.cal.general}{27.8.1} +\cxxsec{time.cal.last}{27.8.2} +\cxxsec{time.cal.day}{27.8.3} +\cxxsec{time.cal.day.overview}{27.8.3.1} +\cxxsec{time.cal.day.members}{27.8.3.2} +\cxxsec{time.cal.day.nonmembers}{27.8.3.3} +\cxxsec{time.cal.month}{27.8.4} +\cxxsec{time.cal.month.overview}{27.8.4.1} +\cxxsec{time.cal.month.members}{27.8.4.2} +\cxxsec{time.cal.month.nonmembers}{27.8.4.3} +\cxxsec{time.cal.year}{27.8.5} +\cxxsec{time.cal.year.overview}{27.8.5.1} +\cxxsec{time.cal.year.members}{27.8.5.2} +\cxxsec{time.cal.year.nonmembers}{27.8.5.3} +\cxxsec{time.cal.wd}{27.8.6} +\cxxsec{time.cal.wd.overview}{27.8.6.1} +\cxxsec{time.cal.wd.members}{27.8.6.2} +\cxxsec{time.cal.wd.nonmembers}{27.8.6.3} +\cxxsec{time.cal.wdidx}{27.8.7} +\cxxsec{time.cal.wdidx.overview}{27.8.7.1} +\cxxsec{time.cal.wdidx.members}{27.8.7.2} +\cxxsec{time.cal.wdidx.nonmembers}{27.8.7.3} +\cxxsec{time.cal.wdlast}{27.8.8} +\cxxsec{time.cal.wdlast.overview}{27.8.8.1} +\cxxsec{time.cal.wdlast.members}{27.8.8.2} +\cxxsec{time.cal.wdlast.nonmembers}{27.8.8.3} +\cxxsec{time.cal.md}{27.8.9} +\cxxsec{time.cal.md.overview}{27.8.9.1} +\cxxsec{time.cal.md.members}{27.8.9.2} +\cxxsec{time.cal.md.nonmembers}{27.8.9.3} +\cxxsec{time.cal.mdlast}{27.8.10} +\cxxsec{time.cal.mwd}{27.8.11} +\cxxsec{time.cal.mwd.overview}{27.8.11.1} +\cxxsec{time.cal.mwd.members}{27.8.11.2} +\cxxsec{time.cal.mwd.nonmembers}{27.8.11.3} +\cxxsec{time.cal.mwdlast}{27.8.12} +\cxxsec{time.cal.mwdlast.overview}{27.8.12.1} +\cxxsec{time.cal.mwdlast.members}{27.8.12.2} +\cxxsec{time.cal.mwdlast.nonmembers}{27.8.12.3} +\cxxsec{time.cal.ym}{27.8.13} +\cxxsec{time.cal.ym.overview}{27.8.13.1} +\cxxsec{time.cal.ym.members}{27.8.13.2} +\cxxsec{time.cal.ym.nonmembers}{27.8.13.3} +\cxxsec{time.cal.ymd}{27.8.14} +\cxxsec{time.cal.ymd.overview}{27.8.14.1} +\cxxsec{time.cal.ymd.members}{27.8.14.2} +\cxxsec{time.cal.ymd.nonmembers}{27.8.14.3} +\cxxsec{time.cal.ymdlast}{27.8.15} +\cxxsec{time.cal.ymdlast.overview}{27.8.15.1} +\cxxsec{time.cal.ymdlast.members}{27.8.15.2} +\cxxsec{time.cal.ymdlast.nonmembers}{27.8.15.3} +\cxxsec{time.cal.ymwd}{27.8.16} +\cxxsec{time.cal.ymwd.overview}{27.8.16.1} +\cxxsec{time.cal.ymwd.members}{27.8.16.2} +\cxxsec{time.cal.ymwd.nonmembers}{27.8.16.3} +\cxxsec{time.cal.ymwdlast}{27.8.17} +\cxxsec{time.cal.ymwdlast.overview}{27.8.17.1} +\cxxsec{time.cal.ymwdlast.members}{27.8.17.2} +\cxxsec{time.cal.ymwdlast.nonmembers}{27.8.17.3} +\cxxsec{time.cal.operators}{27.8.18} +\cxxsec{time.hms}{27.9} +\cxxsec{time.hms.overview}{27.9.1} +\cxxsec{time.hms.members}{27.9.2} +\cxxsec{tab:time.hms.width}{98} +\cxxsec{time.hms.nonmembers}{27.9.3} +\cxxsec{time.12}{27.10} +\cxxsec{time.zone}{27.11} +\cxxsec{time.zone.general}{27.11.1} +\cxxsec{time.zone.db}{27.11.2} +\cxxsec{time.zone.db.tzdb}{27.11.2.1} +\cxxsec{time.zone.db.list}{27.11.2.2} +\cxxsec{time.zone.db.access}{27.11.2.3} +\cxxsec{time.zone.db.remote}{27.11.2.4} +\cxxsec{time.zone.exception}{27.11.3} +\cxxsec{time.zone.exception.nonexist}{27.11.3.1} +\cxxsec{time.zone.exception.ambig}{27.11.3.2} +\cxxsec{time.zone.info}{27.11.4} +\cxxsec{time.zone.info.sys}{27.11.4.1} +\cxxsec{time.zone.info.local}{27.11.4.2} +\cxxsec{time.zone.timezone}{27.11.5} +\cxxsec{time.zone.overview}{27.11.5.1} +\cxxsec{time.zone.members}{27.11.5.2} +\cxxsec{time.zone.nonmembers}{27.11.5.3} +\cxxsec{time.zone.zonedtraits}{27.11.6} +\cxxsec{time.zone.zonedtime}{27.11.7} +\cxxsec{time.zone.zonedtime.overview}{27.11.7.1} +\cxxsec{time.zone.zonedtime.ctor}{27.11.7.2} +\cxxsec{time.zone.zonedtime.members}{27.11.7.3} +\cxxsec{time.zone.zonedtime.nonmembers}{27.11.7.4} +\cxxsec{time.zone.leap}{27.11.8} +\cxxsec{time.zone.leap.overview}{27.11.8.1} +\cxxsec{time.zone.leap.members}{27.11.8.2} +\cxxsec{time.zone.leap.nonmembers}{27.11.8.3} +\cxxsec{time.zone.link}{27.11.9} +\cxxsec{time.zone.link.overview}{27.11.9.1} +\cxxsec{time.zone.link.members}{27.11.9.2} +\cxxsec{time.zone.link.nonmembers}{27.11.9.3} +\cxxsec{time.format}{27.12} +\cxxsec{tab:time.format.spec}{99} +\cxxsec{time.parse}{27.13} +\cxxsec{tab:time.parse.spec}{100} +\cxxsec{ctime.syn}{27.14} +\cxxsec{utilities}{Clause 20} +\cxxsec{utilities.general}{20.1} +\cxxsec{tab:utilities.summary}{41} +\cxxsec{utility}{20.2} +\cxxsec{utility.syn}{20.2.1} +\cxxsec{utility.swap}{20.2.2} +\cxxsec{utility.exchange}{20.2.3} +\cxxsec{forward}{20.2.4} +\cxxsec{utility.as.const}{20.2.5} +\cxxsec{declval}{20.2.6} +\cxxsec{utility.intcmp}{20.2.7} +\cxxsec{intseq}{20.3} +\cxxsec{intseq.general}{20.3.1} +\cxxsec{intseq.intseq}{20.3.2} +\cxxsec{intseq.make}{20.3.3} +\cxxsec{pairs}{20.4} +\cxxsec{pairs.general}{20.4.1} +\cxxsec{pairs.pair}{20.4.2} +\cxxsec{pairs.spec}{20.4.3} +\cxxsec{pair.astuple}{20.4.4} +\cxxsec{pair.piecewise}{20.4.5} +\cxxsec{tuple}{20.5} +\cxxsec{tuple.general}{20.5.1} +\cxxsec{tuple.syn}{20.5.2} +\cxxsec{tuple.tuple}{20.5.3} +\cxxsec{tuple.cnstr}{20.5.3.1} +\cxxsec{tuple.assign}{20.5.3.2} +\cxxsec{tuple.swap}{20.5.3.3} +\cxxsec{tuple.creation}{20.5.4} +\cxxsec{tuple.apply}{20.5.5} +\cxxsec{tuple.helper}{20.5.6} +\cxxsec{tuple.elem}{20.5.7} +\cxxsec{tuple.rel}{20.5.8} +\cxxsec{tuple.traits}{20.5.9} +\cxxsec{tuple.special}{20.5.10} +\cxxsec{optional}{20.6} +\cxxsec{optional.general}{20.6.1} +\cxxsec{optional.syn}{20.6.2} +\cxxsec{optional.optional}{20.6.3} +\cxxsec{optional.optional.general}{20.6.3.1} +\cxxsec{optional.ctor}{20.6.3.2} +\cxxsec{optional.dtor}{20.6.3.3} +\cxxsec{optional.assign}{20.6.3.4} +\cxxsec{tab:optional.assign.copy}{42} +\cxxsec{tab:optional.assign.move}{43} +\cxxsec{tab:optional.assign.copy.templ}{44} +\cxxsec{tab:optional.assign.move.templ}{45} +\cxxsec{optional.swap}{20.6.3.5} +\cxxsec{tab:optional.swap}{46} +\cxxsec{optional.observe}{20.6.3.6} +\cxxsec{optional.mod}{20.6.3.7} +\cxxsec{optional.nullopt}{20.6.4} +\cxxsec{optional.bad.access}{20.6.5} +\cxxsec{optional.relops}{20.6.6} +\cxxsec{optional.nullops}{20.6.7} +\cxxsec{optional.comp.with.t}{20.6.8} +\cxxsec{optional.specalg}{20.6.9} +\cxxsec{optional.hash}{20.6.10} +\cxxsec{variant}{20.7} +\cxxsec{variant.general}{20.7.1} +\cxxsec{variant.syn}{20.7.2} +\cxxsec{variant.variant}{20.7.3} +\cxxsec{variant.variant.general}{20.7.3.1} +\cxxsec{variant.ctor}{20.7.3.2} +\cxxsec{variant.dtor}{20.7.3.3} +\cxxsec{variant.assign}{20.7.3.4} +\cxxsec{variant.mod}{20.7.3.5} +\cxxsec{variant.status}{20.7.3.6} +\cxxsec{variant.swap}{20.7.3.7} +\cxxsec{variant.helper}{20.7.4} +\cxxsec{variant.get}{20.7.5} +\cxxsec{variant.relops}{20.7.6} +\cxxsec{variant.visit}{20.7.7} +\cxxsec{variant.monostate}{20.7.8} +\cxxsec{variant.monostate.relops}{20.7.9} +\cxxsec{variant.specalg}{20.7.10} +\cxxsec{variant.bad.access}{20.7.11} +\cxxsec{variant.hash}{20.7.12} +\cxxsec{any}{20.8} +\cxxsec{any.general}{20.8.1} +\cxxsec{any.synop}{20.8.2} +\cxxsec{any.bad.any.cast}{20.8.3} +\cxxsec{any.class}{20.8.4} +\cxxsec{any.class.general}{20.8.4.1} +\cxxsec{any.cons}{20.8.4.2} +\cxxsec{any.assign}{20.8.4.3} +\cxxsec{any.modifiers}{20.8.4.4} +\cxxsec{any.observers}{20.8.4.5} +\cxxsec{any.nonmembers}{20.8.5} +\cxxsec{bitset}{20.9} +\cxxsec{bitset.syn}{20.9.1} +\cxxsec{template.bitset}{20.9.2} +\cxxsec{template.bitset.general}{20.9.2.1} +\cxxsec{bitset.cons}{20.9.2.2} +\cxxsec{bitset.members}{20.9.2.3} +\cxxsec{bitset.hash}{20.9.3} +\cxxsec{bitset.operators}{20.9.4} +\cxxsec{memory}{20.10} +\cxxsec{memory.general}{20.10.1} +\cxxsec{memory.syn}{20.10.2} +\cxxsec{pointer.traits}{20.10.3} +\cxxsec{pointer.traits.general}{20.10.3.1} +\cxxsec{pointer.traits.types}{20.10.3.2} +\cxxsec{pointer.traits.functions}{20.10.3.3} +\cxxsec{pointer.traits.optmem}{20.10.3.4} +\cxxsec{pointer.conversion}{20.10.4} +\cxxsec{util.dynamic.safety}{20.10.5} +\cxxsec{ptr.align}{20.10.6} +\cxxsec{allocator.tag}{20.10.7} +\cxxsec{allocator.uses}{20.10.8} +\cxxsec{allocator.uses.trait}{20.10.8.1} +\cxxsec{allocator.uses.construction}{20.10.8.2} +\cxxsec{allocator.traits}{20.10.9} +\cxxsec{allocator.traits.general}{20.10.9.1} +\cxxsec{allocator.traits.types}{20.10.9.2} +\cxxsec{allocator.traits.members}{20.10.9.3} +\cxxsec{default.allocator}{20.10.10} +\cxxsec{default.allocator.general}{20.10.10.1} +\cxxsec{allocator.members}{20.10.10.2} +\cxxsec{allocator.globals}{20.10.10.3} +\cxxsec{specialized.addressof}{20.10.11} +\cxxsec{c.malloc}{20.10.12} +\cxxsec{smartptr}{20.11} +\cxxsec{unique.ptr}{20.11.1} +\cxxsec{unique.ptr.general}{20.11.1.1} +\cxxsec{unique.ptr.dltr}{20.11.1.2} +\cxxsec{unique.ptr.dltr.general}{20.11.1.2.1} +\cxxsec{unique.ptr.dltr.dflt}{20.11.1.2.2} +\cxxsec{unique.ptr.dltr.dflt1}{20.11.1.2.3} +\cxxsec{unique.ptr.single}{20.11.1.3} +\cxxsec{unique.ptr.single.general}{20.11.1.3.1} +\cxxsec{unique.ptr.single.ctor}{20.11.1.3.2} +\cxxsec{unique.ptr.single.dtor}{20.11.1.3.3} +\cxxsec{unique.ptr.single.asgn}{20.11.1.3.4} +\cxxsec{unique.ptr.single.observers}{20.11.1.3.5} +\cxxsec{unique.ptr.single.modifiers}{20.11.1.3.6} +\cxxsec{unique.ptr.runtime}{20.11.1.4} +\cxxsec{unique.ptr.runtime.general}{20.11.1.4.1} +\cxxsec{unique.ptr.runtime.ctor}{20.11.1.4.2} +\cxxsec{unique.ptr.runtime.asgn}{20.11.1.4.3} +\cxxsec{unique.ptr.runtime.observers}{20.11.1.4.4} +\cxxsec{unique.ptr.runtime.modifiers}{20.11.1.4.5} +\cxxsec{unique.ptr.create}{20.11.1.5} +\cxxsec{unique.ptr.special}{20.11.1.6} +\cxxsec{unique.ptr.io}{20.11.1.7} +\cxxsec{util.smartptr.weak.bad}{20.11.2} +\cxxsec{util.smartptr.shared}{20.11.3} +\cxxsec{util.smartptr.shared.general}{20.11.3.1} +\cxxsec{util.smartptr.shared.const}{20.11.3.2} +\cxxsec{util.smartptr.shared.dest}{20.11.3.3} +\cxxsec{util.smartptr.shared.assign}{20.11.3.4} +\cxxsec{util.smartptr.shared.mod}{20.11.3.5} +\cxxsec{util.smartptr.shared.obs}{20.11.3.6} +\cxxsec{util.smartptr.shared.create}{20.11.3.7} +\cxxsec{util.smartptr.shared.cmp}{20.11.3.8} +\cxxsec{util.smartptr.shared.spec}{20.11.3.9} +\cxxsec{util.smartptr.shared.cast}{20.11.3.10} +\cxxsec{util.smartptr.getdeleter}{20.11.3.11} +\cxxsec{util.smartptr.shared.io}{20.11.3.12} +\cxxsec{util.smartptr.weak}{20.11.4} +\cxxsec{util.smartptr.weak.general}{20.11.4.1} +\cxxsec{util.smartptr.weak.const}{20.11.4.2} +\cxxsec{util.smartptr.weak.dest}{20.11.4.3} +\cxxsec{util.smartptr.weak.assign}{20.11.4.4} +\cxxsec{util.smartptr.weak.mod}{20.11.4.5} +\cxxsec{util.smartptr.weak.obs}{20.11.4.6} +\cxxsec{util.smartptr.weak.spec}{20.11.4.7} +\cxxsec{util.smartptr.ownerless}{20.11.5} +\cxxsec{util.smartptr.enab}{20.11.6} +\cxxsec{util.smartptr.hash}{20.11.7} +\cxxsec{mem.res}{20.12} +\cxxsec{mem.res.syn}{20.12.1} +\cxxsec{mem.res.class}{20.12.2} +\cxxsec{mem.res.class.general}{20.12.2.1} +\cxxsec{mem.res.public}{20.12.2.2} +\cxxsec{mem.res.private}{20.12.2.3} +\cxxsec{mem.res.eq}{20.12.2.4} +\cxxsec{mem.poly.allocator.class}{20.12.3} +\cxxsec{mem.poly.allocator.class.general}{20.12.3.1} +\cxxsec{mem.poly.allocator.ctor}{20.12.3.2} +\cxxsec{mem.poly.allocator.mem}{20.12.3.3} +\cxxsec{mem.poly.allocator.eq}{20.12.3.4} +\cxxsec{mem.res.global}{20.12.4} +\cxxsec{mem.res.pool}{20.12.5} +\cxxsec{mem.res.pool.overview}{20.12.5.1} +\cxxsec{mem.res.pool.options}{20.12.5.2} +\cxxsec{mem.res.pool.ctor}{20.12.5.3} +\cxxsec{mem.res.pool.mem}{20.12.5.4} +\cxxsec{mem.res.monotonic.buffer}{20.12.6} +\cxxsec{mem.res.monotonic.buffer.general}{20.12.6.1} +\cxxsec{mem.res.monotonic.buffer.ctor}{20.12.6.2} +\cxxsec{mem.res.monotonic.buffer.mem}{20.12.6.3} +\cxxsec{allocator.adaptor}{20.13} +\cxxsec{allocator.adaptor.syn}{20.13.1} +\cxxsec{allocator.adaptor.types}{20.13.2} +\cxxsec{allocator.adaptor.cnstr}{20.13.3} +\cxxsec{allocator.adaptor.members}{20.13.4} +\cxxsec{scoped.adaptor.operators}{20.13.5} +\cxxsec{function.objects}{20.14} +\cxxsec{function.objects.general}{20.14.1} +\cxxsec{functional.syn}{20.14.2} +\cxxsec{func.def}{20.14.3} +\cxxsec{func.require}{20.14.4} +\cxxsec{func.invoke}{20.14.5} +\cxxsec{refwrap}{20.14.6} +\cxxsec{refwrap.general}{20.14.6.1} +\cxxsec{refwrap.const}{20.14.6.2} +\cxxsec{refwrap.assign}{20.14.6.3} +\cxxsec{refwrap.access}{20.14.6.4} +\cxxsec{refwrap.invoke}{20.14.6.5} +\cxxsec{refwrap.helpers}{20.14.6.6} +\cxxsec{arithmetic.operations}{20.14.7} +\cxxsec{arithmetic.operations.general}{20.14.7.1} +\cxxsec{arithmetic.operations.plus}{20.14.7.2} +\cxxsec{arithmetic.operations.minus}{20.14.7.3} +\cxxsec{arithmetic.operations.multiplies}{20.14.7.4} +\cxxsec{arithmetic.operations.divides}{20.14.7.5} +\cxxsec{arithmetic.operations.modulus}{20.14.7.6} +\cxxsec{arithmetic.operations.negate}{20.14.7.7} +\cxxsec{comparisons}{20.14.8} +\cxxsec{comparisons.general}{20.14.8.1} +\cxxsec{comparisons.equal.to}{20.14.8.2} +\cxxsec{comparisons.not.equal.to}{20.14.8.3} +\cxxsec{comparisons.greater}{20.14.8.4} +\cxxsec{comparisons.less}{20.14.8.5} +\cxxsec{comparisons.greater.equal}{20.14.8.6} +\cxxsec{comparisons.less.equal}{20.14.8.7} +\cxxsec{comparisons.three.way}{20.14.8.8} +\cxxsec{range.cmp}{20.14.9} +\cxxsec{logical.operations}{20.14.10} +\cxxsec{logical.operations.general}{20.14.10.1} +\cxxsec{logical.operations.and}{20.14.10.2} +\cxxsec{logical.operations.or}{20.14.10.3} +\cxxsec{logical.operations.not}{20.14.10.4} +\cxxsec{bitwise.operations}{20.14.11} +\cxxsec{bitwise.operations.general}{20.14.11.1} +\cxxsec{bitwise.operations.and}{20.14.11.2} +\cxxsec{bitwise.operations.or}{20.14.11.3} +\cxxsec{bitwise.operations.xor}{20.14.11.4} +\cxxsec{bitwise.operations.not}{20.14.11.5} +\cxxsec{func.identity}{20.14.12} +\cxxsec{func.not.fn}{20.14.13} +\cxxsec{func.bind.front}{20.14.14} +\cxxsec{func.bind}{20.14.15} +\cxxsec{func.bind.general}{20.14.15.1} +\cxxsec{func.bind.isbind}{20.14.15.2} +\cxxsec{func.bind.isplace}{20.14.15.3} +\cxxsec{func.bind.bind}{20.14.15.4} +\cxxsec{func.bind.place}{20.14.15.5} +\cxxsec{func.memfn}{20.14.16} +\cxxsec{func.wrap}{20.14.17} +\cxxsec{func.wrap.general}{20.14.17.1} +\cxxsec{func.wrap.badcall}{20.14.17.2} +\cxxsec{func.wrap.func}{20.14.17.3} +\cxxsec{func.wrap.func.general}{20.14.17.3.1} +\cxxsec{func.wrap.func.con}{20.14.17.3.2} +\cxxsec{func.wrap.func.mod}{20.14.17.3.3} +\cxxsec{func.wrap.func.cap}{20.14.17.3.4} +\cxxsec{func.wrap.func.inv}{20.14.17.3.5} +\cxxsec{func.wrap.func.targ}{20.14.17.3.6} +\cxxsec{func.wrap.func.nullptr}{20.14.17.3.7} +\cxxsec{func.wrap.func.alg}{20.14.17.3.8} +\cxxsec{func.search}{20.14.18} +\cxxsec{func.search.general}{20.14.18.1} +\cxxsec{func.search.default}{20.14.18.2} +\cxxsec{func.search.bm}{20.14.18.3} +\cxxsec{func.search.bmh}{20.14.18.4} +\cxxsec{unord.hash}{20.14.19} +\cxxsec{meta}{20.15} +\cxxsec{meta.general}{20.15.1} +\cxxsec{meta.rqmts}{20.15.2} +\cxxsec{meta.type.synop}{20.15.3} +\cxxsec{meta.help}{20.15.4} +\cxxsec{meta.unary}{20.15.5} +\cxxsec{meta.unary.general}{20.15.5.1} +\cxxsec{meta.unary.cat}{20.15.5.2} +\cxxsec{tab:meta.unary.cat}{47} +\cxxsec{meta.unary.comp}{20.15.5.3} +\cxxsec{tab:meta.unary.comp}{48} +\cxxsec{meta.unary.prop}{20.15.5.4} +\cxxsec{tab:meta.unary.prop}{49} +\cxxsec{meta.unary.prop.query}{20.15.6} +\cxxsec{tab:meta.unary.prop.query}{50} +\cxxsec{meta.rel}{20.15.7} +\cxxsec{tab:meta.rel}{51} +\cxxsec{meta.trans}{20.15.8} +\cxxsec{meta.trans.general}{20.15.8.1} +\cxxsec{meta.trans.cv}{20.15.8.2} +\cxxsec{tab:meta.trans.cv}{52} +\cxxsec{meta.trans.ref}{20.15.8.3} +\cxxsec{tab:meta.trans.ref}{53} +\cxxsec{meta.trans.sign}{20.15.8.4} +\cxxsec{tab:meta.trans.sign}{54} +\cxxsec{meta.trans.arr}{20.15.8.5} +\cxxsec{tab:meta.trans.arr}{55} +\cxxsec{meta.trans.ptr}{20.15.8.6} +\cxxsec{tab:meta.trans.ptr}{56} +\cxxsec{meta.trans.other}{20.15.8.7} +\cxxsec{tab:meta.trans.other}{57} +\cxxsec{meta.logical}{20.15.9} +\cxxsec{meta.member}{20.15.10} +\cxxsec{meta.const.eval}{20.15.11} +\cxxsec{ratio}{20.16} +\cxxsec{ratio.general}{20.16.1} +\cxxsec{ratio.syn}{20.16.2} +\cxxsec{ratio.ratio}{20.16.3} +\cxxsec{ratio.arithmetic}{20.16.4} +\cxxsec{tab:ratio.arithmetic}{58} +\cxxsec{ratio.comparison}{20.16.5} +\cxxsec{ratio.si}{20.16.6} +\cxxsec{type.index}{20.17} +\cxxsec{type.index.synopsis}{20.17.1} +\cxxsec{type.index.overview}{20.17.2} +\cxxsec{type.index.members}{20.17.3} +\cxxsec{type.index.hash}{20.17.4} +\cxxsec{execpol}{20.18} +\cxxsec{execpol.general}{20.18.1} +\cxxsec{execution.syn}{20.18.2} +\cxxsec{execpol.type}{20.18.3} +\cxxsec{execpol.seq}{20.18.4} +\cxxsec{execpol.par}{20.18.5} +\cxxsec{execpol.parunseq}{20.18.6} +\cxxsec{execpol.unseq}{20.18.7} +\cxxsec{execpol.objects}{20.18.8} +\cxxsec{charconv}{20.19} +\cxxsec{charconv.syn}{20.19.1} +\cxxsec{charconv.to.chars}{20.19.2} +\cxxsec{charconv.from.chars}{20.19.3} +\cxxsec{format}{20.20} +\cxxsec{format.syn}{20.20.1} +\cxxsec{format.string}{20.20.2} +\cxxsec{format.string.general}{20.20.2.1} +\cxxsec{format.string.std}{20.20.2.2} +\cxxsec{tab:format.align}{59} +\cxxsec{tab:format.sign}{60} +\cxxsec{tab:format.type.string}{61} +\cxxsec{tab:format.type.int}{62} +\cxxsec{tab:format.type.char}{63} +\cxxsec{tab:format.type.bool}{64} +\cxxsec{format.err.report}{20.20.3} +\cxxsec{format.functions}{20.20.4} +\cxxsec{tab:format.type.float}{65} +\cxxsec{tab:format.type.ptr}{66} +\cxxsec{format.formatter}{20.20.5} +\cxxsec{formatter.requirements}{20.20.5.1} +\cxxsec{format.formatter.spec}{20.20.5.2} +\cxxsec{tab:formatter}{67} +\cxxsec{format.parse.ctx}{20.20.5.3} +\cxxsec{format.context}{20.20.5.4} +\cxxsec{format.arguments}{20.20.6} +\cxxsec{format.arg}{20.20.6.1} +\cxxsec{format.arg.store}{20.20.6.2} +\cxxsec{format.args}{20.20.6.3} +\cxxsec{format.error}{20.20.7} diff --git a/src/cxx.tex b/src/cxx.tex new file mode 100644 index 0000000..8617f33 --- /dev/null +++ b/src/cxx.tex @@ -0,0 +1,24 @@ +% Define section from the C++ standard that can be indexed +% using its dotted identifer. That is: +% +% \cxxsec{basic.def.odr}{3.2} +% +% This is used to make references to sections of the C++ Standard +% that are not labeled within this document. +\newcommand{\cxxsec}[2]{% + \expandafter\def\csname #1 \endcsname{#2}% +} + +% Generate a reference to the section with the given id. This +% expands to the full chapter/section/subsection number declared +% by \cxxsec. For example: +% +% \cxxref{basic.def.odr} +% +% Expands to the string 3.2. +\newcommand{\cxxref}[1]{% + \csname #1 \endcsname% +} + +\input{cxx-sections} + diff --git a/src/general.tex b/src/general.tex index eda9065..694b54e 100644 --- a/src/general.tex +++ b/src/general.tex @@ -3,7 +3,12 @@ \rSec0[scope]{Scope} \pnum -This document describes requirements for implementations of an interface that computer programs written in the C++ programming language may use to invoke algorithms with concurrent execution. The algorithms described by this document are realizable across a broad class of computer architectures. +This document describes requirements for implementations of an interface +that computer programs written in the C++ programming language +can use to express groups of +operations (known as transactions) that appear to execute atomically in +relation to other transactions (concurrent or otherwise). + \pnum {\cppstddocno} provide important context and specification for @@ -14,7 +19,7 @@ This document is non-normative. Some of the functionality described by this document may be considered for standardization in a future version of C++, but it is not currently part of any C++ standard. Some of the functionality in this document may never be standardized, and other functionality may be standardized in a substantially changed form. \pnum -The goal of this document is to build widespread existing practice for concurrency in the C++ standard algorithms library. It gives advice on extensions to those vendors who wish to provide them. +The goal of this document is to build widespread existing practice for eventually adopting transactional memory in C++. \rSec0[refs]{Normative references} @@ -26,10 +31,7 @@ \end{itemize} \pnum -ISO/IEC 14882:2020 is herein called the C++ Standard. References to clauses within the C++ Standard are written as ``\CppXref{3.2}''. The library described in \CppXref{16-32} is herein called the C++ Standard Library. - -\pnum -Unless otherwise specified, the whole of the C++ Standard's Library introduction (\CppXref{16}) is included into this Technical Specification by reference. +ISO/IEC 14882:2020 is herein called the C++ Standard. References to clauses within the C++ Standard are written as ``\CppXref{defns.arbitrary.stream}''. \rSec0[defs]{Terms and definitions} @@ -47,89 +49,14 @@ \rSec1[general.compliance]{Implementation compliance} \pnum -Conformance requirements for this document are those defined in \CppXref{4.1}, as applied to a merged document consisting of C++20 amended by this document. +Conformance requirements for this document are those defined in \CppXref{intro.compliance}, as applied to a merged document consisting of C++20 amended by this document. \begin{note} Conformance is defined in terms of the behavior of programs. \end{note} -\rSec1[general.namespaces]{Namespaces and headers and modifications to standard classes} -\pnum -Since the extensions described in this technical specification are experimental and not part of the C++ standard library, they are not declared directly within namespace \tcode{std}. Unless otherwise specified, all components described in this technical specification either: - -\begin{itemize} - \item modify an existing interface in the C++ Standard Library in-place, - \item are declared in a namespace whose name appends \tcode{::experimental::concurrency\_v2} to a namespace defined in the C++ Standard Library, such as \tcode{std}, or - \item are declared in a subnamespace of a namespace described in the previous bullet, whose name is not the same as an existing subnamespace of namespace \tcode{std}. -\end{itemize} - -\pnum -Whenever an unqualified name is used -in the specification of a declaration \tcode{D}, -its meaning is established -as-if by performing unqualified name lookup -in the context of \tcode{D}. -\begin{note} -Argument-dependent lookup is not performed. -\end{note} -Similarly, the meaning of a \grammarterm{qualified-id} is established -as-if by performing qualified name lookup -in the context of \tcode{D}. -\begin{note} -Operators in expressions are not so constrained. -\end{note} - -%%The header described in this document (see Table~\ref{tab:info.headers}) -%%shall import the contents of \tcode{::std::experimental::concurrency::v2} into -%%\tcode{::std::experimental::concurrency_v1} as if by: - -%%\begin{codeblock} -%%namespace std::experimental::concurrency_v1 { -%% inline namespace v2 {} -%%} -%%\end{codeblock} - - -%%\begin{floattable}{Concurrency\_v2 library headers}{tab:info.headers} -%%{l} -%%\topline -%%\tcode{} \\ -%%\end{floattable} - -\rSec1[general.feature.test]{Feature-testing recommendations (Informative)} -\pnum -An implementation that provides support for this document should define each feature test macro defined in \tref{intro.features} if no associated headers are indicated for that macro, and if associated headers are indicated for a macro, that macro is defined after inclusion of one of the corresponding headers specified in the table. - -\begin{floattable}{Feature-test macros}{tab:intro.features} -{lll} -\topline -\lhdr{Macro name} & \chdr{Value} & \rhdr{Header} \\ -\capsep -%%\tcode{__cpp_concurrency\_v2} & \tcode{\tsver} & none \\ -\tcode{__cpp_lib_concurrency\_v2} & \tcode{\tsver} & \tcode{} \\ -\end{floattable} -\rSec1[general.plans]{Future plans (Informative)} -\pnum -This section describes tentative plans for future versions of this technical specification and plans for moving content into -future versions of the C++ Standard. - -\pnum - The C++ committee intends to release a new version of this technical specification approximately every few years, containing -the concurrency extensions we hope to add to a near-future version of the C++ Standard. Future versions will define their -contents in \tcode{std::experimental::concurrency\_v3}, \tcode{std::experimental::concurrency\_v4}, etc., with the most recent -implemented version inlined into \tcode{std::ex\-perimental}. - -\pnum -When an extension defined in this or a future version of this technical specification represents enough existing practice, it -will be moved into the next version of the C++ Standard by removing the \tcode{experimental::con\-currency\_v$N$} segment of its -namespace and by removing the \tcode{experimental/} prefix from its header's path. - \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Paul McKenney, and Maged Michael. We also wish to thank people -who made valuable contributions within and outside these groups, including Jens Maurer, and many others not named +original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scott, Victor Luchangco, Mage Michael, and Paul McKenney. We also wish to thank people +who made valuable contributions within and outside these groups, including all SG 5 members and the original TM group, and many others not named here who contributed to the discussion. - - - - diff --git a/src/srHP.tex b/src/srHP.tex deleted file mode 100644 index ae593ae..0000000 --- a/src/srHP.tex +++ /dev/null @@ -1,525 +0,0 @@ -%!TEX root = ts.tex - -\rSec1[saferecl.hp]{Hazard pointers} - -\rSec2[saferecl.hp.general]{General} - -\pnum -A hazard pointer is a single-writer multi-reader pointer that can be owned by at most one thread at any time. Only the owner of the hazard pointer can set its value, while any number of threads may read its value. The owner thread sets the value of a hazard pointer to point to an object in order to indicate to concurrent threads\textemdash that may delete such an object\textemdash that the object is not yet safe to delete. - -\pnum -A class type \tcode{T} is \defn{hazard-protectable} if it has exactly one public base class of type \tcode{hazard_pointer_obj_base} for some \tcode{D} and no base classes of type \tcode{hazard_pointer_obj_base} for any other combination \tcode{T’}, \tcode{D’}. An object is \defn{hazard-protectable} if it is of hazard-protectable type. - -\pnum -The span between creation and destruction of a hazard pointer $h$ is partitioned into a series of \defn{protection epochs}; in each protection epoch, $h$ either is \defn{associated with} a hazard-protectable object, or is \defn{unassociated}. Upon creation, a hazard pointer is unassociated. Changing the association (possibly to the same object) initiates a new protection epoch and ends the preceding one. - -\pnum -A hazard pointer \defn{belongs to} exactly one \defn{domain}. - -\pnum -An object of type \tcode{hazard_pointer} is either empty or \defn{owns} a hazard pointer. Each hazard pointer is owned by exactly one object of type \tcode{hazard_pointer}. \begin{note} An empty \tcode{hazard_pointer} object is different from a \tcode{hazard_pointer} object that owns an unassociated hazard pointer. An empty \tcode{hazard_pointer} object does not own any hazard pointers. \end{note} - -\pnum -An object \tcode{x} of hazard-protectable type \tcode{T} is \defn{retired} to a domain with a deleter of type \tcode{D} when the member function \tcode{hazard_pointer_obj_base::retire} is invoked on \tcode{x}. Any given object \tcode{x} shall be retired at most once. - -\pnum -A retired object \tcode{x} is \defn{reclaimed} by invoking its deleter with a pointer to \tcode{x}. - -\pnum -A hazard-protectable object \tcode{x} is \defn{definitely reclaimable} in a domain $dom$ with respect to -an evaluation $A$ if: - -\begin{itemize} -\item \tcode{x} is not reclaimed, and -\item \tcode{x} is retired to $dom$ in an evaluation that happens before $A$, and -\item for all hazard pointers $h$ that belong to $dom$, the end of any protection epoch where $h$ is associated with \tcode{x} happens before $A$. -\end{itemize} - -\pnum -A hazard-protectable object \tcode{x} is \defn{possibly reclaimable} in domain $dom$ with respect to an -evaluation $A$ if: -\begin{itemize} -\item \tcode{x} is not reclaimed; and -\item \tcode{x} is retired to $dom$ in an evaluation $R$ and $A$ does not happen before $R$; and -\item for all hazard pointers $h$ that belong to $dom$, $A$ does not happen before the end of -any protection epoch where $h$ is associated with \tcode{x}; and -\item for all hazard pointers $h$ belonging to $dom$ and for every protection epoch $E$ of $h$ -during which $h$ is associated with \tcode{x}: -\begin{itemize} - \item $A$ does not happen before the end of $E$, and - \item if the beginning of $E$ happens before \tcode{x} is retired, the end of $E$ strongly -happens before $A$, and - \item if $E$ began by an evaluation of \tcode{try_protect} with argument \tcode{src}, label its -atomic load operation $L$. If there exists an atomic modification $B$ on \tcode{src} such that $L$ observes a modification that is modification-ordered before $B$, and $B$ happens before \tcode{x} is retired, the end of $E$ strongly happens before $A$. \begin{note} In typical use, a store to \tcode{src} sequenced before retiring \tcode{x} will be such an atomic operation $B$. \end{note} -\end{itemize} -\begin{note} The latter two conditions convey the informal notion that a protection epoch that began before retiring \tcode{x}, as implied either by the happens-before relation or the coherence order of some source, delays the reclamation of \tcode{x}. \end{note} -\end{itemize} - -\begin{example} The following example shows how hazard pointers allow updates to be carried out in the presence of concurrent readers. The object of type \tcode{hazard_pointer} in \tcode{print_name} protects the object \tcode{*ptr} from being reclaimed by \tcode{ptr->retire} until the end of the protection epoch. - -\begin{codeblock} -struct Name : public hazard_pointer_obj_base { /* details */ }; -atomic name; - -// called often and in parallel! -void print_name() { - hazard_pointer h = make_hazard_pointer(); - Name* ptr = h.protect(name); /* Protection epoch starts */ - /* ... safe to access *ptr ... */ -} /* Protection epoch ends. */ - -// called rarely, but possibly concurrently with print_name -void update_name(Name* new_name) { - Name* ptr = name.exchange(new_name); - ptr->retire(); -} -\end{codeblock} -\end{example} - -\rSec2[saferecl.hp.syn]{Header \tcode{} synopsis} - -\begin{codeblock} -namespace std::experimental::inline concurrency_v2 { - // \ref{saferecl.hp.domain}, class \tcode{hazard_pointer_domain} - class hazard_pointer_domain; - - // \ref{saferecl.hp.domain.default}, Default \tcode{hazard_pointer_domain} - hazard_pointer_domain& hazard_pointer_default_domain() noexcept; - - // \ref{saferecl.hp.cleanup}, Clean up - void hazard_pointer_clean_up(hazard_pointer_domain& domain = hazard_pointer_default_domain()) - noexcept; - - // \ref{saferecl.hp.base}, class template \tcode{hazard_pointer_obj_base} - template > class hazard_pointer_obj_base; - - // \ref{saferecl.hp.holder}, class \tcode{hazard_pointer} - class hazard_pointer; - - // \ref{saferecl.hp.make}, Construct non-empty \tcode{hazard_pointer} - hazard_pointer make_hazard_pointer( - hazard_pointer_domain& domain = hazard_pointer_default_domain()); - - // \ref{saferecl.hp.special}, Hazard pointer swap - void swap(hazard_pointer&, hazard_pointer&) noexcept; -} -\end{codeblock} - -\rSec2[saferecl.hp.domain]{Class \tcode{hazard_pointer_domain}} - -\rSec3[saferecl.hp.domain.general]{General} - -\pnum -The number of unreclaimed possibly-reclaimable objects retired to a domain is bounded. -The bound is implementation-defined. \begin{note} The bound can be independent of other -domains and can be a function of the number of hazard pointers belonging to the -domain, the number of threads that retire objects to the domain, and the number of -threads that use hazard pointers belonging to the domain. \end{note} - -\pnum -Concurrent access to a domain does not incur a data race (\CppXref{6.9.2.1}). - -\begin{codeblock} -class hazard_pointer_domain { -public: - hazard_pointer_domain() noexcept; - explicit hazard_pointer_domain(pmr::polymorphic_allocator poly_alloc) noexcept; - - hazard_pointer_domain(const hazard_pointer_domain&) = delete; - hazard_pointer_domain& operator=(const hazard_pointer_domain&) = delete; - - ~hazard_pointer_domain(); -}; -\end{codeblock} - -\rSec3[saferecl.hp.domain.mem]{Member functions} - -\begin{itemdecl} -hazard_pointer_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{hazard_pointer_domain(\{\})}. - -\end{itemdescr} - -\begin{itemdecl} -explicit hazard_pointer_domain(pmr::polymorphic_allocator poly_alloc) noexcept;} -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\remarks -All allocation and deallocation related to hazard pointers belonging to this -domain use a copy of \tcode{poly_alloc}. - -\end{itemdescr} - -\begin{itemdecl} -~hazard_pointer_domain(); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -All hazard pointers belonging to \tcode{*this} have been destroyed. - -\pnum -\effects -Reclaims all objects retired to this domain that have not yet been reclaimed. - -\end{itemdescr} - -\rSec2[saferecl.hp.domain.default]{Default \tcode{hazard_pointer_domain}} - -\begin{itemdecl} -hazard_pointer_domain& hazard_pointer_default_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -A reference to the default \tcode{hazard_pointer_domain}. - -\pnum -\remarks -The default domain has an unspecified allocator and has static storage -duration. The initialization of the default domain strongly happens before this function -returns; the sequencing is otherwise unspecified. - -\end{itemdescr} - -\rSec2[saferecl.hp.cleanup]{Clean up} - -\begin{itemdecl} -void hazard_pointer_clean_up(hazard_pointer_domain& domain = hazard_pointer_default_domain()) - noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -May reclaim possibly-reclaimable objects retired to \tcode{domain}. - -\pnum -\ensures -All definitely-reclaimable objects retired to \tcode{domain} have been reclaimed. - -\pnum -\sync -The completion of the deleter for each reclaimed object synchronizes with the return from this function call. - -\end{itemdescr} - -\rSec2[saferecl.hp.base]{Class template \tcode{hazard_pointer_obj_base}} - -\begin{codeblock} -template > -class hazard_pointer_obj_base { -public: - void retire( - D d = D(), - hazard_pointer_domain& domain = hazard_pointer_default_domain()) noexcept; - void retire(hazard_pointer_domain& domain) noexcept; -protected: - hazard_pointer_obj_base() = default; -private: - D @\exposid{deleter}@; // exposition only -}; -\end{codeblock} - -\pnum -A client-supplied template argument \tcode{D} shall be a function object type (\CppXref{20.14}) -for which, given a value \tcode{d} of type \tcode{D} and a value \tcode{ptr} of type \tcode{T*}, the expression \tcode{d(ptr)} is valid and has the effect of disposing of the pointer as appropriate for that deleter. - -\pnum -The behavior of a program that adds specializations for \tcode{hazard_pointer_obj_base} is undefined. - -\pnum -\tcode{D} shall meet the requirements for \oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. - -\pnum -\tcode{T} may be an incomplete type. - -\begin{itemdecl} -void retire(D d = D(), hazard_pointer_domain& domain = hazard_pointer_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\expects -\tcode{*this} is a base class subobject of an object \tcode{x} of type \tcode{T}. \tcode{x} is not retired. -Move-assigning \tcode{D} from \tcode{d} does not throw an exception. The expression \tcode{d(addressof(x))} has well-defined behavior and does not throw an exception. - -\pnum -\effects -Move-assigns \tcode{d} to \exposid{deleter}, thereby setting it as the deleter of \tcode{x}, then retires \tcode{x} -to \tcode{domain}. - -\pnum -Invoking the retire function may reclaim possibly-reclaimable objects retired to \tcode{domain}. - -\end{itemdescr} - -\begin{itemdecl} -void retire(hazard_pointer_domain& domain) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{retire(D(), domain)}. - -\end{itemdescr} - -\rSec2[saferecl.hp.holder]{Class \tcode{hazard_pointer}} - -\rSec3[saferecl.hp.holder.syn]{Synopsis} - -\begin{codeblock} -class hazard_pointer { -public: - hazard_pointer() noexcept; - hazard_pointer(hazard_pointer&&) noexcept; - hazard_pointer& operator=(hazard_pointer&&) noexcept; - ~hazard_pointer(); - - [[nodiscard]] bool empty() const noexcept; - template T* protect(const atomic& src) noexcept; - template bool try_protect(T*& ptr, const atomic& src) noexcept; - template void reset_protection(const T* ptr) noexcept; - void reset_protection(nullptr_t = nullptr) noexcept; - void swap(hazard_pointer&) noexcept; -}; -\end{codeblock} - -\rSec3[saferecl.hp.holder.ctor]{Constructors} - -\begin{itemdecl} -hazard_pointer() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\ensures -\tcode{*this} is empty. - -\end{itemdescr} - -\begin{itemdecl} -hazard_pointer(hazard_pointer&& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\ensures -If \tcode{other} is empty, \tcode{*this} is empty. Otherwise, \tcode{*this} owns the hazard pointer originally owned by \tcode{other}; \tcode{other} is empty. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.dtor]{Destructor} - -\begin{itemdecl} -~hazard_pointer(); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If \tcode{*this} is not empty, destroys the hazard pointer owned by \tcode{*this}, thereby ending its current protection epoch. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.assign]{Assignment} - -\begin{itemdecl} -hazard_pointer& operator=(hazard_pointer&& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If \tcode{this == \&other} is true, no effect. Otherwise, if \tcode{*this} is not empty, destroys -the hazard pointer owned by \tcode{*this}, thereby ending its current protection epoch. - -\pnum -\ensures -If \tcode{other} was empty, \tcode{*this} is empty. Otherwise, \tcode{*this} owns the hazard -pointer originally owned by other. If \tcode{this != \&other} is true, \tcode{other} is empty. - -\pnum -\returns -\tcode{*this}. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.mem]{Member functions} - -\begin{itemdecl} -[[nodiscard]] bool empty() const noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -\tcode{true} if and only if \tcode{*this} is empty. - -\end{itemdescr} - - -\begin{itemdecl} -template T* protect(const atomic& src) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to -\begin{codeblock} -T* ptr = src.load(memory_order_relaxed); -while (!try_protect(ptr, src)) {} -return ptr; -\end{codeblock} - -\end{itemdescr} - -\begin{itemdecl} -template bool try_protect(T*& ptr, const atomic& src) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\expects -\tcode{*this} is not empty. - -\pnum -\effects -\begin{itemize} -\item Initializes a variable \tcode{old} of type \tcode{T*} with the value of \tcode{ptr}. -\item Evaluates the function call \tcode{reset_protection(old)}. -\item Assigns the value of \tcode{src.load(std::memory_order_acquire)} to \tcode{ptr}. -\item If \tcode{old == ptr} is false, evaluates the function call \tcode{reset_protection()}. -\end{itemize} - -\pnum -\returns -\tcode{old == ptr}. \begin{note} It is possible for \tcode{try_protect} to return \tcode{true} when \tcode{ptr} is a null pointer. \end{note} - -\pnum -\complexity -Constant. - -\end{itemdescr} - -\begin{itemdecl} -template void reset_protection(const T* ptr) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\defn{Preconditions}: -\tcode{*this} is not empty. - -\pnum -\effects -If \tcode{ptr} is a null pointer value, invokes \tcode{reset_protection()}. Otherwise, associates the hazard pointer owned by \tcode{*this} with \tcode{*ptr}, thereby ending the current protection epoch. - -\end{itemdescr} - -\begin{itemdecl} -void reset_protection(nullptr_t = nullptr) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -\tcode{*this} is not empty. - -\pnum -\ensures -The hazard pointer owned by \tcode{*this} is unassociated. - -\end{itemdescr} - -\begin{itemdecl} -void swap(hazard_pointer& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Swaps the hazard pointer ownership of this object with that of other. \begin{note} The owned hazard pointers, if any, remain unchanged during the swap and continue to be associated with the respective objects that they were protecting before the swap, if any. No protection epochs are ended or initiated. \end{note} - -\pnum -\complexity -Constant. - -\end{itemdescr} - -\rSec2[saferecl.hp.make]{\tcode{make_hazard_pointer}} - -\begin{itemdecl} -hazard_pointer make_hazard_pointer( - hazard_pointer_domain& domain = hazard_pointer_default_domain()); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Constructs a hazard pointer belonging to \tcode{domain}. - -\pnum -\returns -A \tcode{hazard_pointer} object that owns the newly-constructed hazard pointer. - -\pnum -\throws -Any exception thrown by the allocator of \tcode{domain}. - -\end{itemdescr} - -\rSec2[saferecl.hp.special]{\tcode{hazard_pointer} specialized algorithms} - -\begin{itemdecl} -void swap(hazard_pointer& a, hazard_pointer& b) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{a.swap(b)}. - -\end{itemdescr} diff --git a/src/srgeneral.tex b/src/srgeneral.tex deleted file mode 100644 index 2c47292..0000000 --- a/src/srgeneral.tex +++ /dev/null @@ -1,8 +0,0 @@ -%!TEX root = ts.tex - -\rSec0[saferecl]{Safe reclamation} - -\rSec1[saferecl.general]{General} - -This clause adds safe-reclamation techniques, which are most frequently -used to straightforwardly resolve access-deletion races. diff --git a/src/srrcu.tex b/src/srrcu.tex deleted file mode 100644 index 165d58b..0000000 --- a/src/srrcu.tex +++ /dev/null @@ -1,354 +0,0 @@ -%!TEX root = ts.tex - -\rSec1[saferecl.rcu]{Read-copy update (RCU)} - -\rSec2[saferecl.rcu.general]{General} - -\pnum -RCU is a synchronization mechanism that can be used for linked data -structures that are frequently read, but seldom updated. RCU does -not provide mutual exclusion, but instead allows the user to schedule -specified actions such as deletion at some later time. - -\pnum -A class type \tcode{T} is \defn{rcu-protectable} if it has exactly one -public base class of type \tcode{rcu_obj_base} for some \tcode{D} -and no base classes of type \tcode{rcu_obj_base} for any other -combination \tcode{X}, \tcode{Y}. An object is rcu-protectable if it is -of rcu-protectable type. - -\pnum -An invocation of \tcode{unlock} $U$ on an \tcode{rcu_domain dom} corresponds -to an invocation of \tcode{lock} $L$ on \tcode{dom} if $L$ is -sequenced before $U$ and either - -\begin{itemize} -\item no other invocation of \tcode{lock} on \tcode{dom} is sequenced - after $L$ and before $U$ or -\item every invocation of \tcode{unlock} $U'$ on \tcode{dom} such - that $L$ is sequenced before $U'$ and $U'$ - is sequenced before $U$ corresponds to an invocation of - \tcode{lock} $L'$ on \tcode{dom} such that $L$ is sequenced - before $L'$ and $L'$ is sequenced before $U'$. -\end{itemize} -\begin{note} -This pairs nested locks and unlocks on a given domain in each thread. -\end{note} - -\pnum -A \defn{region of RCU protection} on a domain \tcode{dom} starts -with a \tcode{lock} $L$ on \tcode{dom} and ends with its corresponding -\tcode{unlock} $U$. - -\pnum -Given a region of RCU protection $R$ on a domain \tcode{dom} -and given an evaluation $E$ that scheduled another evaluation -$F$ in \tcode{dom}, if $E$ does not strongly happen before -the start of $R$, the end of $R$ strongly happens before -evaluating $F$. - -\pnum -The evaluation of a scheduled evaluation is potentially concurrent with -any other such evaluation. Each scheduled evaluation is evaluated at -most once. - -\rSec2[saferecl.rcu.syn]{Header \tcode{} synopsis} - -% \indexheader{rcu} -\begin{codeblock} -namespace std::experimental::inline concurrency_v2 { - // \ref{saferecl.rcu.base}, class template \tcode{rcu_obj_base} - template> - class rcu_obj_base; - - // \ref{saferecl.rcu.domain}, class \tcode{rcu_domain} - class rcu_domain; - - // \ref{saferecl.rcu.default.domain}, \tcode{rcu_default_domain} - rcu_domain& rcu_default_domain() noexcept; - - // \ref{saferecl.rcu.synchronize}, \tcode{rcu_synchronize} - void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; - - // \ref{saferecl.rcu.barrier}, \tcode{rcu_barrier} - void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; - - // \ref{saferecl.rcu.retire}, \tcode{rcu_retire} - template> - void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); -} -\end{codeblock} - -\rSec2[saferecl.rcu.base]{Class \tcode{rcu_obj_base}} - -% @@@ Added missing "of" in following sentence. - -Objects of type \tcode{T} to be protected by RCU inherit from a -specialization of \tcode{rcu_obj_base}. - -% @@@ Removed obsolete in-code reference to the now-nonexistent -% @@@ separate section for rcu_obj_base::retire. - -\begin{codeblock} -template> -class rcu_obj_base { -public: - void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; -protected: - rcu_obj_base() = default; -private: - D @\exposid{deleter}@; // exposition only -}; -\end{codeblock} - -\pnum -A client-supplied template argument \tcode{D} shall be a -function object type \CppXref{20.14} for which, -given a value \tcode{d} of type \tcode{D} and a value \tcode{ptr} -of type \tcode{T*}, the expression \tcode{d(ptr)} is valid and -has the effect of disposing of the pointer as appropriate for -that deleter. - -\pnum -The behavior of a program that adds specializations for -\tcode{rcu_obj_base} is undefined. - -\pnum -\tcode{D} shall meet the requirements for -\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. - -\pnum -\tcode{T} may be an incomplete type. - -\pnum -If \tcode{D} is trivially copyable, all specializations of -\tcode{rcu_obj_base} are trivially copyable. - -\begin{itemdecl} -void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is an rcu-protectable type. - -\pnum -\expects -\tcode{*this} is a base class subobject of -an object \tcode{x} of type \tcode{T}. The member function -\tcode{rcu_obj_base::retire} was not invoked on \tcode{x} -before. The assignment to \exposid{deleter} does not throw an -exception. The expression \tcode{\exposid{deleter}(addressof(x))} has -well-defined behavior and does not throw an exception. - -\pnum -\effects -Evaluates \tcode{\exposid{deleter} = std::move(d)} and schedules -the evaluation of the expression \tcode{de\-let\-er(ad\-dress\-of(x))} in the domain \tcode{dom}. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in \tcode{dom} can be invoked by the \tcode{retire} -function. -\begin{note} -If such evaluations acquire resources held across any invocation of -retire on \tcode{dom}, deadlock can occur. -\end{note} - -\end{itemdescr} - -\rSec2[saferecl.rcu.domain]{Class \tcode{rcu_domain}} - -% @@@ Removed the obsolete reference comments. - -This class meets the requirements of \oldconcept{BasicLockable} \CppXref{32.2.5.2} and provides regions of RCU protection. - -\begin{example} -\begin{codeblock} -std::scoped_lock rlock(rcu_default_domain()); -\end{codeblock} -\end{example} - -\begin{codeblock} -class rcu_domain { -public: - rcu_domain(const rcu_domain&) = delete; - rcu_domain& operator=(const rcu_domain&) = delete; - - void lock() noexcept; - void unlock() noexcept; -}; -\end{codeblock} - -The functions \tcode{lock} and \tcode{unlock} establish (possibly nested) -regions of RCU protection. - -\rSec3[saferecl.rcu.domain.lock]{\tcode{rcu_domain::lock}} - -\begin{itemdecl} -void lock() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Opens a region of RCU protection. - -\pnum -\remarks -Calls to the function lock do not introduce a data race -(\CppXref{6.9.2.1}) involving \tcode{*this}. - -\end{itemdescr} - -\rSec3[saferecl.rcu.domain.unlock]{\tcode{rcu_domain::unlock}} - -\begin{itemdecl} -void unlock() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -A call to the function \tcode{lock} that opened -an unclosed region of RCU protection is sequenced before the -call to \tcode{unlock}. - -\pnum -\effects -Closes the unclosed region of RCU protection that was -most recently opened. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in \tcode{*this} can be invoked by the \tcode{unlock} -function. -\begin{note} -If such evaluations acquire resources held across any invocation -of \tcode{unlock} on \tcode{*this}, deadlock can occur. -\end{note} -Calls to the function \tcode{unlock} do not introduce a data race -involving \tcode{*this}. -\begin{note} -Evaluation of scheduled evaluations can still cause a data race. -\end{note} - -\end{itemdescr} - -\rSec2[saferecl.rcu.default.domain]{\tcode{rcu_default_domain}} - -\begin{itemdecl} -rcu_domain& rcu_default_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -A reference to the default object of type \tcode{rcu_domain}. -A reference to the same object is returned every time this -function is called. - -\end{itemdescr} - -\rSec2[saferecl.rcu.synchronize]{\tcode{rcu_synchronize}} - -\begin{itemdecl} -void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If the call to \tcode{rcu_synchronize} does not strongly -happen before the lock opening an RCU protection region \tcode{R} -on \tcode{dom}, blocks until the \tcode{unlock} closing \tcode{R} -happens. - -\pnum -\sync -The \tcode{unlock} closing \tcode{R} strongly -happens before the return from \tcode{rcu_synchronize}. - -\end{itemdescr} - -\rSec2[saferecl.rcu.barrier]{\tcode{rcu_barrier}} - -\begin{itemdecl} -void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -May evaluate any scheduled evaluations in -\tcode{dom}. For any evaluation that happens before the call -to \tcode{rcu_barrier} and that schedules an evaluation $E$ -in \tcode{dom}, blocks until $E$ has been evaluated. - -\pnum -\sync -The evaluation of any such $E$ strongly -happens before the return from \tcode{rcu_barrier}. - -\end{itemdescr} - -\rSec2[saferecl.rcu.retire]{Template \tcode{rcu_retire}} - -\begin{itemdecl} -template> -void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{is_move_constructible_v} is true. - -\pnum -\expects -\tcode{D} meets the \oldconcept{MoveConstructible} and -\oldconcept{Destructible} requirements. -The expression \tcode{d1(p)}, where \tcode{d1} is defined below, is -well-formed and its evaluation does not exit via an exception. - -\pnum -\effects -May allocate memory. -It is unspecified whether the memory allocation is performed by -invoking \tcode{operator} \tcode{new}. -Initializes an object \tcode{d1} of type \tcode{D} from -\tcode{std::move(d)}. -Schedules the evaluation of \tcode{d1(p)} in the domain -\tcode{dom}. -\begin{note} -If \tcode{rcu_retire} exits via an exception, no evaluation -is scheduled. -\end{note} - -\pnum -\throws -Any exception that would be caught by a handler of type -\tcode{bad_alloc}. -Any exception thrown by the initialization of \tcode{d1}. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in dom can be invoked by the \tcode{rcu_retire} -function. -\begin{note} -If such evaluations acquire resources held across any invocation -of \tcode{rcu_retire} on \tcode{dom}, deadlock can occur. -\end{note} - -\end{itemdescr} diff --git a/src/tm.tex b/src/tm.tex new file mode 100644 index 0000000..c350306 --- /dev/null +++ b/src/tm.tex @@ -0,0 +1,387 @@ +%!TEX root = ts.tex +\setcounter{section}{9} +\rSec0[lex]{Lexical conventions} + + +\rSec1[lex.name]{Identifiers} + +In \CppXref{lex.name}, +add \added{\tcode{atomic}} to the table of identifiers with special meaning (Table 4). + +\rSec0[basic]{Basics} + +\setcounter{section}{8} + +\rSec1[basic.exec]{Program execution} + +\setcounter{section}{9} + +\rSec2[intro.execution]{Sequential execution} + +Change in \CppXref{intro.execution} paragraph 5 as indicated: + +\begin{quote} +\setcounter{Paras}{4} +\setcounter{Bullets1}{3} +\pnum +A \defn{full-expression} is + +\begin{itemize} +\item + ... +\item + an invocation of a destructor generated at the end of the lifetime of + an object other than a temporary object (6.7.7) whose lifetime has not + been extended, \removed{or} +\item + \added{the start or the end of an atomic block (\ref{stmt.tx}), + or} +\item + an expression that is not a subexpression of another expression and + that is not otherwise part of a full-expression. +\end{itemize} +\end{quote} + +\rSec2[intro.multithread]{Multi-threaded executions and data races} +\setcounter{subsubsection}{1} +\rSec3[intro.races]{Data races} + +Change in \CppXref{intro.races} paragraph 6 as indicated: + +\begin{quote} +\setcounter{Paras}{5} +\pnum +\removed{Certain} \added{Atomic blocks as well as certain} library +calls \added{may} \emph{synchronize with} other \added{atomic blocks +and} library calls performed by another thread. +\end{quote} + +Add a new paragraph after \CppXref{intro.races} paragraph 20: + +\begin{quote} +\pnum +\setcounter{Paras}{20} +\setcounter{note}{20} +The execution of an atomic block that is not dynamically nested within another atomic +block is termed a \defn{transaction}. +\begin{note} +Due to syntactic constraints, +blocks cannot overlap unless one is nested within the other. +\end{note} +There is a global total order of execution for all transactions. +If, in that total order, a transaction T1 is ordered before a transaction T2, +then + +\begin{itemize} +\item + no evaluation in T2 happens before any evaluation in T1 and +\item + if T1 and T2 perform conflicting expression evaluations, then the end + of T1 synchronizes with the start of T2. +\end{itemize} + +\begin{note} +If the evaluations in T1 and T2 do not conflict, they might be +executed concurrently. +\end{note} + +\pnum +Two actions are \defn{potentially concurrent} if ... +\end{quote} + +Change in \CppXref{intro.races} paragraph 21: + +\begin{quote} +\setcounter{Paras}{20} +\setcounter{note}{20} +\pnum +... +\begin{note} +It can be shown that programs that correctly use +mutexes\added{, atomic blocks,} and \tcode{memory_order::seq_cst} +operations to prevent all data races and use no other synchronization +operations behave as if the operations executed by their constituent +threads were simply interleaved, with each value computation of an +object being taken from the last side effect on that object in that +interleaving. This is normally referred to as "sequential consistency". +... +\end{note} +\end{quote} + +Add a new paragraph after \CppXref{intro.multithread.general} paragraph 21: + +\begin{quote} +\setcounter{Paras}{21} +\pnum +\begin{note} +The following holds for a data-race-free program: If the start +of an atomic block $T$ is sequenced before an evaluation $A$, $A$ is sequenced +before the end of $T$, $A$ strongly happens before some evaluation $B$, and $B$ +is not sequenced before the end of $T$, then the end of $T$ strongly happens +before $B$. If an evaluation $C$ strongly happens before that evaluation $A$ +and $C$ is not sequenced after the start of $T$, then $C$ strongly happens +before the start of $T$. These properties in turn imply that in any simple +interleaved (sequentially consistent) execution, the operations of each +atomic block appear to be contiguous in the interleaving. +\end{note} +\end{quote} + +\rSec3[intro.progress]{Forward progress} + +Change in \CppXref{intro.progress} paragraph 1 as indicated: + +\begin{quote} +\pnum +\removed{The implementation may assume that any thread will eventually do} +\added{An \defn{inter-thread side effect} is} one of the following: + +\begin{itemize} +\tightlist +\item + \removed{terminate,} +\item + a call to a library I/O function, +\item + an access through a volatile glvalue, or +\item + a synchronization operation or an atomic operation + \added{(\cxxref{atomics})}. +\end{itemize} + +\added{The implementation may assume that any thread will eventually +terminate or evaluate an inter-thread side effect.} +\begin{note} +This is intended to allow compiler transformations +such as removal of empty loops, even when termination cannot be proven. +\end{note} +\end{quote} + +\setcounter{chapter}{7} + +\rSec0[stmt.stmt]{Statements} +\rSec1[stmt.pre]{Preamble} +\pnum +Add a production to the grammar in \CppXref{stmt.pre} as indicated: + +\begin{quote} +\begin{bnf} +\nontermdef{statement}\br + labeled-statement\br + \opt{attribute-specifier-seq} expression-statement\br + \opt{attribute-specifier-seq} compound-statement\br + \opt{attribute-specifier-seq} selection-statement\br + \opt{attribute-specifier-seq} iteration-statement\br + \opt{attribute-specifier-seq} jump-statement\br + declaration-statement\br + \opt{attribute-specifier-seq} try-block\br + \added{atomic-statement} +\end{bnf} +\end{quote} + +\setcounter{section}{7} + +Add a new subclause before \CppXref{stmt.dcl}: + +\begin{quote} +\rSec1[stmt.tx]{Atomic statement} + +\begin{bnf} +\nontermdef{atomic-statement}\br + \keyword{atomic} \keyword{do} compound-statement +\end{bnf} + +\pnum +An \grammarterm{atomic-statement} is also called an \emph{atomic block}. + +\pnum +The start of the atomic block is immediately after the +opening \tcode{\{} of the \grammarterm{compound-statement}. +Evaluation of the end of the atomic block occurs +when the invocation of the destructor for a hypothetical automatic +variable of class type declared at the start of the atomic block would +happen (\cxxref{stmt.jump.general}). + +\begin{note} +Thus, variables with automatic storage duration +declared in the \grammarterm{compound-statement} +are destroyed prior to reaching the end of the atomic block; +see \cxxref{stmt.jump}. +\end{note} + +\pnum +A \keyword{case} or \keyword{default} label +appearing within an atomic block shall be associated with a +\keyword{switch} statement (\cxxref{stmt.switch}) within the same +atomic block. A label (\cxxref{stmt.label}) declared in an atomic block +shall only be referred to by a statement in the same atomic block. + +\pnum +If the execution of an atomic block evaluates an inter-thread side +effect\iref{intro.progress} or if an atomic block is exited +via an exception, the behavior is undefined. + +\pnum +\recommended +In case an atomic block is exited via an exception, +the program should be terminated +without invoking a terminate handler (\cxxref{exception.terminate}) or +destroying any objects +with static or thread storage duration (\cxxref{basic.start.term}). + +\pnum +If the execution of an atomic block evaluates any of the following +outside of a manifestly constant-evaluated context (\cxxref{expr.const}), +the behavior is implementation-defined: + +\begin{itemize} +\item + an \grammarterm{asm-declaration} (\cxxref{dcl.asm}); +\item + an invocation of a function, unless + \begin{itemize} + \tightlist + \item + {the function is inline with a reachable definition or} + \item + {the function is a library function that may be used in an atomic + block \ref{atomic.use};} + \end{itemize} + +\item + a virtual function call (\cxxref{expr.call}); +\item + a function call, unless overload resolution selects + + \begin{itemize} + \item + a named function (\cxxref{over.call.func}) or + \item + a function call operator (\cxxref{over.call.object}), + but not a surrogate call function; + \end{itemize} +\item + a \keyword{co_await} expression (\cxxref{expr.await}), a + \grammarterm{yield-expression} (\cxxref{expr.yield}), or a + \keyword{co_return} statement (\cxxref{stmt.return.coroutine}); +\item + dynamic initialization of a block-scope variable with static storage + duration; or +\item + dynamic initialization of a variable with thread storage duration. + {{[} Note: That includes the case when such an initialization is + evaluated within an atomic block because the initialization was + deferred (\cxxref{basic.start.dynamic}). -\/- end note {]}} + +\end{itemize} + +\begin{note} +The implementation can define that the behavior is +undefined in some or all of the cases above. +\end{note} + +\begin{example} +\begin{codeblock} +unsigned int f() +{ + static unsigned int i = 0; + atomic do { + ++i; + return i; + } +} +\end{codeblock} + +Each invocation of \tcode{f} +(even when called from several threads simultaneously) +retrieves a unique value (ignoring wrap-around). +\end{example} + +\begin{note} +Atomic blocks are likely to perform best where they execute +quickly and touch little data. +\end{note} +\end{quote} + +\setcounter{chapter}{14} + +\rSec0[cpp]{Preprocessor} + +\setcounter{section}{10} + +\rSec1[cpp.predefined]{Predefined macro names} + +Add a row to Table \cxxref{tab:cpp.predefined.ft} in \CppXref{cpp.predefined}: + +\setcounter{table}{18} + +\begin{floattable}{Feature-test macros}{tab:intro.features} +{ll} +\topline +\lhdr{Macro name} & \rhdr{Value} \\ +\capsep +\tcode{__cpp_transactional_memory} & \tcode{\tsver} \\ +\end{floattable} + + +\rSec0[library]{Library introduction} + +\setcounter{section}{3} + +\rSec1[requirements]{Library-wide requirements} + +\setcounter{subsection}{6} +\setcounter{subsubsection}{16} + +Add a new subclause after \CppXref{lib.types.movedfrom}: + +\begin{quote} +\rSec3[atomic.use]{Functions usable in an atomic block} + +\pnum +All library functions may be used in an atomic block\iref{stmt.tx}, except + +\begin{itemize} +\item + error category objects (\cxxref{syserr.errcat.objects}) +\item + time zone database (\cxxref{syserr.errcat.objects}) +\item + clocks (\cxxref{time.clock}) +\item + \tcode{signal} (\cxxref{support.signal}) and \tcode{raise} + (\cxxref{csignal.syn}) +\item + \tcode{set_new_handler}, \tcode{set_terminate}, + \tcode{get_new_handler}, \tcode{get_terminate} + (\cxxref{handler.functions}, \cxxref{alloc.errors}, \cxxref{exception.syn}) +\item + \tcode{system} (\cxxref{cstdlib.syn}) +\item + startup and termination (\cxxref{support.start.term}) except + \tcode{abort} +\item + \tcode{shared_ptr} (\cxxref{util.smartptr.shared}) and + \tcode{weak_ptr} (\cxxref{util.smartptr.weak}) +\item + \tcode{synchronized_pool_resource} (\cxxref{mem.res.pool}) +\item + program-wide \tcode{memory_resource} objects + (\cxxref{mem.res.global}) +\item + \tcode{setjmp} / \tcode{longjmp} (\cxxref{csetjmp.syn}) +\item + parallel algorithms (\cxxref{algorithms.parallel}) +\item + \tcode{random_device} (\cxxref{rand.device}) +\item + \tcode{locale} construction (\cxxref{locale.cons}) +\item + {\tcode{locale::global} (\cxxref {locale.statics})} +\item + input/output (\cxxref{input.output}) +\item + atomic operations (\cxxref{atomics}) +\item + thread support (\cxxref{thread}) +\end{itemize} +\end{quote} diff --git a/src/ts.tex b/src/ts.tex index 0180829..d6d9f37 100644 --- a/src/ts.tex +++ b/src/ts.tex @@ -29,8 +29,8 @@ \usepackage[T1]{fontenc} \usepackage[pdftex, final]{graphicx} \usepackage[pdftex, - pdftitle={C++ Concurrency Technical Specification 2}, - pdfsubject={C++ Concurrency Technical Specification 2}, + pdftitle={Extensions to C++ Transactional Memory 2}, + pdfsubject={Extensions to C++ Transactional Memory 2}, pdfcreator={Michael Wong, Maged Michael, and Paul E.~McKenney}, bookmarks=true, bookmarksnumbered=true, @@ -56,11 +56,9 @@ \makeindex[impldefindex] %%-------------------------------------------------- -%% macros specific to the Concurrency TS 2 -\newcommand{\completionsig}{\Fundesc{Completion signature}} -\newcommand{\DEDUCED}{\textit{\texttt{DEDUCED}}} +%% macros specific to the Extensions to C++ Transactional Memory 2 \newcommand{\nativeref}{see~\ref{socket.reqmts.native}} -\newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S#1} +\newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S\cxxref{#1}} % Alternative formatting of cross-references, resolving stable name to number. % Needs include{cxx} and CppXIV from cplusplus/draft/source/macros.tex. % \input{cxx} @@ -103,6 +101,10 @@ %% configuration \input{config} +%%-------------------------------------------------- +%% labels from C++20 +\input{cxx} + %%-------------------------------------------------- %% front matter \frontmatter @@ -116,9 +118,7 @@ \include{general} %%\include{modifications} -\include{srgeneral} -\include{srHP} -\include{srrcu} +\include{tm} % \include{classes} % \include{overloading} % \include{templates} diff --git a/tools/check-output.sh b/tools/check-output.sh old mode 100755 new mode 100644