[support.c.headers.other] - C++20 → C++23

Files changed (1) hide show

tmp/tmp7wxw54fz/{from.md → to.md} +307 -0

tmp/tmp7wxw54fz/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,307 @@

+### Other C headers <a id="support.c.headers.other">[[support.c.headers.other]]</a>
+Every C header other than `<complex.h>`, `<iso646.h>`, `<stdalign.h>`,
+`<stdatomic.h>`, `<stdbool.h>`, and `<tgmath.h>`, each of which has a
+name of the form `<name.h>`, behaves as if each name placed in the
+standard library namespace by the corresponding `<cname>` header is
+placed within the global namespace scope, except for the functions
+described in [[sf.cmath]], the `std::lerp` function overloads
+[[c.math.lerp]], the declaration of `std::byte` [[cstddef.syn]], and the
+functions and function templates described in [[support.types.byteops]].
+It is unspecified whether these names are first declared or defined
+within namespace scope [[basic.scope.namespace]] of the namespace `std`
+and are then injected into the global namespace scope by explicit
+*using-declaration*s [[namespace.udecl]].
+[*Example 1*: The header `<cstdlib>` assuredly provides its
+declarations and definitions within the namespace `std`. It may also
+provide these names within the global namespace. The header `<stdlib.h>`
+assuredly provides the same declarations and definitions within the
+global namespace, much as in the C Standard. It may also provide these
+names within the namespace `std`. — *end example*]
+<!-- Link reference definitions -->
+[alg.c.library]: algorithms.md#alg.c.library
+[alloc.errors]: #alloc.errors
+[atomics]: thread.md#atomics
+[bad.alloc]: #bad.alloc
+[bad.cast]: #bad.cast
+[bad.exception]: #bad.exception
+[bad.typeid]: #bad.typeid
+[basic.align]: basic.md#basic.align
+[basic.compound]: basic.md#basic.compound
+[basic.extended.fp]: basic.md#basic.extended.fp
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.life]: basic.md#basic.life
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.start.dynamic]: basic.md#basic.start.dynamic
+[basic.start.term]: basic.md#basic.start.term
+[basic.stc.dynamic]: basic.md#basic.stc.dynamic
+[basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
+[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[c.headers]: #c.headers
+[c.locales]: localization.md#c.locales
+[c.malloc]: mem.md#c.malloc
+[c.math.abs]: numerics.md#c.math.abs
+[c.math.lerp]: numerics.md#c.math.lerp
+[c.math.rand]: numerics.md#c.math.rand
+[c.mb.wcs]: strings.md#c.mb.wcs
+[cfloat.syn]: #cfloat.syn
+[class.mem]: class.md#class.mem
+[class.prop]: class.md#class.prop
+[class.spaceship]: class.md#class.spaceship
+[climits.syn]: #climits.syn
+[cmp]: #cmp
+[cmp.alg]: #cmp.alg
+[cmp.categories]: #cmp.categories
+[cmp.categories.pre]: #cmp.categories.pre
+[cmp.common]: #cmp.common
+[cmp.concept]: #cmp.concept
+[cmp.partialord]: #cmp.partialord
+[cmp.result]: #cmp.result
+[cmp.strongord]: #cmp.strongord
+[cmp.weakord]: #cmp.weakord
+[compare.syn]: #compare.syn
+[complex]: numerics.md#complex
+[complex.h.syn]: #complex.h.syn
+[concept.totallyordered]: concepts.md#concept.totallyordered
+[concepts.compare.general]: concepts.md#concepts.compare.general
+[constraints]: library.md#constraints
+[conv.prom]: expr.md#conv.prom
+[conv.ptr]: expr.md#conv.ptr
+[conv.qual]: expr.md#conv.qual
+[conv.rank]: basic.md#conv.rank
+[coroutine.handle]: #coroutine.handle
+[coroutine.handle.compare]: #coroutine.handle.compare
+[coroutine.handle.con]: #coroutine.handle.con
+[coroutine.handle.conv]: #coroutine.handle.conv
+[coroutine.handle.export.import]: #coroutine.handle.export.import
+[coroutine.handle.general]: #coroutine.handle.general
+[coroutine.handle.hash]: #coroutine.handle.hash
+[coroutine.handle.noop]: #coroutine.handle.noop
+[coroutine.handle.noop.address]: #coroutine.handle.noop.address
+[coroutine.handle.noop.conv]: #coroutine.handle.noop.conv
+[coroutine.handle.noop.observers]: #coroutine.handle.noop.observers
+[coroutine.handle.noop.promise]: #coroutine.handle.noop.promise
+[coroutine.handle.noop.resumption]: #coroutine.handle.noop.resumption
+[coroutine.handle.observers]: #coroutine.handle.observers
+[coroutine.handle.promise]: #coroutine.handle.promise
+[coroutine.handle.resumption]: #coroutine.handle.resumption
+[coroutine.noop]: #coroutine.noop
+[coroutine.noop.coroutine]: #coroutine.noop.coroutine
+[coroutine.promise.noop]: #coroutine.promise.noop
+[coroutine.syn]: #coroutine.syn
+[coroutine.traits]: #coroutine.traits
+[coroutine.traits.general]: #coroutine.traits.general
+[coroutine.traits.primary]: #coroutine.traits.primary
+[coroutine.trivial.awaitables]: #coroutine.trivial.awaitables
+[cpp.line]: cpp.md#cpp.line
+[cpp17.nullablepointer]: #cpp17.nullablepointer
+[csetjmp.syn]: #csetjmp.syn
+[csignal.syn]: #csignal.syn
+[cstdarg.syn]: #cstdarg.syn
+[cstddef.syn]: #cstddef.syn
+[cstdint.syn]: #cstdint.syn
+[cstdlib.syn]: #cstdlib.syn
+[customization.point.object]: library.md#customization.point.object
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
+[dcl.fct.default]: dcl.md#dcl.fct.default
+[dcl.init.list]: dcl.md#dcl.init.list
+[defns.expression.equivalent]: intro.md#defns.expression.equivalent
+[except.handle]: except.md#except.handle
+[except.nested]: #except.nested
+[except.spec]: except.md#except.spec
+[except.terminate]: except.md#except.terminate
+[except.uncaught]: except.md#except.uncaught
+[exception]: #exception
+[exception.syn]: #exception.syn
+[exception.terminate]: #exception.terminate
+[expr.add]: expr.md#expr.add
+[expr.await]: expr.md#expr.await
+[expr.call]: expr.md#expr.call
+[expr.context]: expr.md#expr.context
+[expr.delete]: expr.md#expr.delete
+[expr.dynamic.cast]: expr.md#expr.dynamic.cast
+[expr.eq]: expr.md#expr.eq
+[expr.new]: expr.md#expr.new
+[expr.prim.lambda]: expr.md#expr.prim.lambda
+[expr.rel]: expr.md#expr.rel
+[expr.sizeof]: expr.md#expr.sizeof
+[expr.spaceship]: expr.md#expr.spaceship
+[expr.typeid]: expr.md#expr.typeid
+[get.new.handler]: #get.new.handler
+[get.terminate]: #get.terminate
+[hardware.interference]: #hardware.interference
+[initializer.list.syn]: #initializer.list.syn
+[intro.multithread]: basic.md#intro.multithread
+[iso646.h.syn]: #iso646.h.syn
+[lex.key]: lex.md#lex.key
+[library.c]: library.md#library.c
+[limits.syn]: #limits.syn
+[locale.codecvt]: localization.md#locale.codecvt
+[multibyte.strings]: library.md#multibyte.strings
+[namespace.udecl]: dcl.md#namespace.udecl
+[new.badlength]: #new.badlength
+[new.delete]: #new.delete
+[new.delete.array]: #new.delete.array
+[new.delete.dataraces]: #new.delete.dataraces
+[new.delete.general]: #new.delete.general
+[new.delete.placement]: #new.delete.placement
+[new.delete.single]: #new.delete.single
+[new.handler]: #new.handler
+[new.syn]: #new.syn
+[numeric.limits]: #numeric.limits
+[numeric.limits.general]: #numeric.limits.general
+[numeric.limits.members]: #numeric.limits.members
+[numeric.special]: #numeric.special
+[propagation]: #propagation
+[ptr.launder]: #ptr.launder
+[res.on.data.races]: library.md#res.on.data.races
+[round.style]: #round.style
+[set.new.handler]: #set.new.handler
+[set.terminate]: #set.terminate
+[sf.cmath]: numerics.md#sf.cmath
+[source.location.syn]: #source.location.syn
+[stdalign.h.syn]: #stdalign.h.syn
+[stdbool.h.syn]: #stdbool.h.syn
+[stdfloat.syn]: #stdfloat.syn
+[stmt.dcl]: stmt.md#stmt.dcl
+[string.classes]: strings.md#string.classes
+[support]: #support
+[support.arith.types]: #support.arith.types
+[support.c.headers]: #support.c.headers
+[support.c.headers.general]: #support.c.headers.general
+[support.c.headers.other]: #support.c.headers.other
+[support.coroutine]: #support.coroutine
+[support.coroutine.general]: #support.coroutine.general
+[support.dynamic]: #support.dynamic
+[support.dynamic.general]: #support.dynamic.general
+[support.exception]: #support.exception
+[support.exception.general]: #support.exception.general
+[support.general]: #support.general
+[support.initlist]: #support.initlist
+[support.initlist.access]: #support.initlist.access
+[support.initlist.cons]: #support.initlist.cons
+[support.initlist.general]: #support.initlist.general
+[support.initlist.range]: #support.initlist.range
+[support.limits]: #support.limits
+[support.limits.general]: #support.limits.general
+[support.rtti]: #support.rtti
+[support.rtti.general]: #support.rtti.general
+[support.runtime]: #support.runtime
+[support.runtime.general]: #support.runtime.general
+[support.signal]: #support.signal
+[support.srcloc]: #support.srcloc
+[support.srcloc.class]: #support.srcloc.class
+[support.srcloc.class.general]: #support.srcloc.class.general
+[support.srcloc.cons]: #support.srcloc.cons
+[support.srcloc.current]: #support.srcloc.current
+[support.srcloc.obs]: #support.srcloc.obs
+[support.start.term]: #support.start.term
+[support.summary]: #support.summary
+[support.types]: #support.types
+[support.types.byteops]: #support.types.byteops
+[support.types.layout]: #support.types.layout
+[support.types.nullptr]: #support.types.nullptr
+[swappable.requirements]: library.md#swappable.requirements
+[temp.deduct]: temp.md#temp.deduct
+[temp.dep.constexpr]: temp.md#temp.dep.constexpr
+[temp.dep.expr]: temp.md#temp.dep.expr
+[temp.variadic]: temp.md#temp.variadic
+[term.odr.use]: basic.md#term.odr.use
+[terminate]: #terminate
+[terminate.handler]: #terminate.handler
+[tgmath.h.syn]: #tgmath.h.syn
+[type.info]: #type.info
+[typeinfo.syn]: #typeinfo.syn
+[uncaught.exceptions]: #uncaught.exceptions
+[unord.hash]: utilities.md#unord.hash
+[utility.arg.requirements]: library.md#utility.arg.requirements
+[version.syn]: #version.syn
+[^1]: Possible definitions include `0` and `0L`, but not `(void*)0`.
+[^2]: Note that `offsetof` is required to work as specified even if
+    unary `operator&` is overloaded for any of the types involved.
+[^3]: Equivalent to `CHAR_MIN`, `SHRT_MIN`, `FLT_MIN`, `DBL_MIN`, etc.
+[^4]: Equivalent to `CHAR_MAX`, `SHRT_MAX`, `FLT_MAX`, `DBL_MAX`, etc.
+[^5]: `lowest()` is necessary because not all floating-point
+    representations have a smallest (most negative) value that is the
+    negative of the largest (most positive) finite value.
+[^6]: Equivalent to `FLT_MANT_DIG`, `DBL_MANT_DIG`, `LDBL_MANT_DIG`.
+[^7]: Equivalent to `FLT_DIG`, `DBL_DIG`, `LDBL_DIG`.
+[^8]: Equivalent to `FLT_RADIX`.
+[^9]: Distinguishes types with bases other than 2 (e.g., BCD).
+[^10]: Equivalent to `FLT_EPSILON`, `DBL_EPSILON`, `LDBL_EPSILON`.
+[^11]: Rounding error is described in LIA-1 Section 5.2.4 and Annex C
+    Rationale Section C.5.2.4 — Rounding and rounding constants.
+[^12]: Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP`, `LDBL_MIN_EXP`.
+[^13]: Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP`,
+    `LDBL_MIN_10_EXP`.
+[^14]: Equivalent to `FLT_MAX_EXP`, `DBL_MAX_EXP`, `LDBL_MAX_EXP`.
+[^15]: Equivalent to `FLT_MAX_10_EXP`, `DBL_MAX_10_EXP`,
+    `LDBL_MAX_10_EXP`.
+[^16]: Required by LIA-1.
+[^17]: Required by LIA-1.
+[^18]: Required by LIA-1.
+[^19]: Required by LIA-1.
+[^20]: Required by LIA-1.
+[^21]: Required by LIA-1.
+[^22]: ISO/IEC/IEEE 60559:2020 is the same as IEEE 754-2019.
+[^23]: Required by LIA-1.
+[^24]: Required by LIA-1.
+[^25]: Required by LIA-1.
+[^26]: Refer to ISO/IEC/IEEE 60559. Required by LIA-1.
+[^27]: Equivalent to `FLT_ROUNDS`. Required by LIA-1.
+[^28]: A function is called for every time it is registered.
+[^29]: Objects with automatic storage duration are all destroyed in a
+    program whose `main` function [[basic.start.main]] contains no
+    objects with automatic storage duration and executes the call to
+    `exit()`. Control can be transferred directly to such a `main`
+    function by throwing an exception that is caught in `main`.
+[^30]: The macros `EXIT_FAILURE` and `EXIT_SUCCESS` are defined in
+    `<cstdlib>`.
+[^31]: It is not the direct responsibility of `operator new[]` or
+    `operator delete[]` to note the repetition count or element size of
+    the array. Those operations are performed elsewhere in the array
+    `new` and `delete` expressions. The array `new` expression, can,
+    however, increase the `size` argument to `operator new[]` to obtain
+    space to store supplemental information.
+[^32]: That is, `a < b`, `a == b`, and `a > b` might all be `false`.
+[^33]: Note that `va_start` is required to work as specified even if
+    unary `operator&` is overloaded for the type of `parmN`.
+[^34]: Such initialization can occur because it is the first odr-use
+    [[term.odr.use]] of that variable.

Diff to HTML by rtfpessoa