[bit] - C++20 → C++23

Files changed (1) hide show

tmp/tmpj8nodt1m/{from.md → to.md} +385 -3

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

@@ -6,24 +6,29 @@ The header `<bit>` provides components to access, manipulate and process
 both individual bits and bit sequences.
 ### Header `<bit>` synopsis <a id="bit.syn">[[bit.syn]]</a>
 ``` cpp
 namespace std {
   // [bit.cast], bit_cast
   template<class To, class From>
     constexpr To bit_cast(const From& from) noexcept;
   // [bit.pow.two], integral powers of 2
   template<class T>
     constexpr bool has_single_bit(T x) noexcept;
   template<class T>
     constexpr T bit_ceil(T x);
   template<class T>
     constexpr T bit_floor(T x) noexcept;
   template<class T>
-    constexpr T bit_width(T x) noexcept;
   // [bit.rotate], rotating
   template<class T>
     [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
   template<class T>
@@ -68,21 +73,47 @@ within the result [[intro.object]]. Each bit of the value representation
 of the result is equal to the corresponding bit in the object
 representation of `from`. Padding bits of the result are unspecified.
 For the result and each object created within it, if there is no value
 of the object’s type corresponding to the value representation produced,
 the behavior is undefined. If there are multiple such values, which
-value is produced is unspecified.
 *Remarks:* This function is `constexpr` if and only if `To`, `From`, and
 the types of all subobjects of `To` and `From` are types `T` such that:
 - `is_union_v<T>` is `false`;
 - `is_pointer_v<T>` is `false`;
 - `is_member_pointer_v<T>` is `false`;
 - `is_volatile_v<T>` is `false`; and
 - `T` has no non-static data members of reference type.
 ### Integral powers of 2 <a id="bit.pow.two">[[bit.pow.two]]</a>
 ``` cpp
 template<class T>
   constexpr bool has_single_bit(T x) noexcept;
@@ -121,11 +152,11 @@ template<class T>
 *Returns:* If `x == 0`, `0`; otherwise the maximal value `y` such that
 `has_single_bit(y)` is `true` and `y <= x`.
 ``` cpp
 template<class T>
-  constexpr T bit_width(T x) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 *Returns:* If `x == 0`, `0`; otherwise one plus the base-2 logarithm of
@@ -248,5 +279,356 @@ If all scalar types have size 1 byte, then all of `endian::little`,
 big-endian, `endian::native` is equal to `endian::big`. If all scalar
 types are little-endian, `endian::native` is equal to `endian::little`.
 Otherwise, `endian::native` is not equal to either `endian::big` or
 `endian::little`.

 both individual bits and bit sequences.
 ### Header `<bit>` synopsis <a id="bit.syn">[[bit.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   // [bit.cast], bit_cast
   template<class To, class From>
     constexpr To bit_cast(const From& from) noexcept;
+  // [bit.byteswap], byteswap
+  template<class T>
+    constexpr T byteswap(T value) noexcept;
   // [bit.pow.two], integral powers of 2
   template<class T>
     constexpr bool has_single_bit(T x) noexcept;
   template<class T>
     constexpr T bit_ceil(T x);
   template<class T>
     constexpr T bit_floor(T x) noexcept;
   template<class T>
+    constexpr int bit_width(T x) noexcept;
   // [bit.rotate], rotating
   template<class T>
     [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
   template<class T>
 of the result is equal to the corresponding bit in the object
 representation of `from`. Padding bits of the result are unspecified.
 For the result and each object created within it, if there is no value
 of the object’s type corresponding to the value representation produced,
 the behavior is undefined. If there are multiple such values, which
+value is produced is unspecified. A bit in the value representation of
+the result is indeterminate if it does not correspond to a bit in the
+value representation of `from` or corresponds to a bit of an object that
+is not within its lifetime or has an indeterminate
+value [[basic.indet]]. For each bit in the value representation of the
+result that is indeterminate, the smallest object containing that bit
+has an indeterminate value; the behavior is undefined unless that object
+is of unsigned ordinary character type or `std::byte` type. The result
+does not otherwise contain any indeterminate values.
 *Remarks:* This function is `constexpr` if and only if `To`, `From`, and
 the types of all subobjects of `To` and `From` are types `T` such that:
 - `is_union_v<T>` is `false`;
 - `is_pointer_v<T>` is `false`;
 - `is_member_pointer_v<T>` is `false`;
 - `is_volatile_v<T>` is `false`; and
 - `T` has no non-static data members of reference type.
+### `byteswap` <a id="bit.byteswap">[[bit.byteswap]]</a>
+``` cpp
+template<class T>
+  constexpr T byteswap(T value) noexcept;
+```
+*Constraints:* `T` models `integral`.
+*Mandates:* `T` does not have padding bits [[basic.types.general]].
+Let the sequence R comprise the bytes of the object representation of
+`value` in reverse order.
+*Returns:* An object `v` of type `T` such that each byte in the object
+representation of `v` is equal to the byte in the corresponding position
+in R.
 ### Integral powers of 2 <a id="bit.pow.two">[[bit.pow.two]]</a>
 ``` cpp
 template<class T>
   constexpr bool has_single_bit(T x) noexcept;
 *Returns:* If `x == 0`, `0`; otherwise the maximal value `y` such that
 `has_single_bit(y)` is `true` and `y <= x`.
 ``` cpp
 template<class T>
+  constexpr int bit_width(T x) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 *Returns:* If `x == 0`, `0`; otherwise one plus the base-2 logarithm of
 big-endian, `endian::native` is equal to `endian::big`. If all scalar
 types are little-endian, `endian::native` is equal to `endian::little`.
 Otherwise, `endian::native` is not equal to either `endian::big` or
 `endian::little`.
+<!-- Link reference definitions -->
+[algorithms]: algorithms.md#algorithms
+[algorithms.general]: algorithms.md#algorithms.general
+[algorithms.requirements]: algorithms.md#algorithms.requirements
+[allocator.requirements.general]: library.md#allocator.requirements.general
+[allocator.uses.construction]: mem.md#allocator.uses.construction
+[any]: #any
+[any.assign]: #any.assign
+[any.bad.any.cast]: #any.bad.any.cast
+[any.class]: #any.class
+[any.class.general]: #any.class.general
+[any.cons]: #any.cons
+[any.general]: #any.general
+[any.modifiers]: #any.modifiers
+[any.nonmembers]: #any.nonmembers
+[any.observers]: #any.observers
+[any.synop]: #any.synop
+[arithmetic.operations]: #arithmetic.operations
+[arithmetic.operations.divides]: #arithmetic.operations.divides
+[arithmetic.operations.general]: #arithmetic.operations.general
+[arithmetic.operations.minus]: #arithmetic.operations.minus
+[arithmetic.operations.modulus]: #arithmetic.operations.modulus
+[arithmetic.operations.multiplies]: #arithmetic.operations.multiplies
+[arithmetic.operations.negate]: #arithmetic.operations.negate
+[arithmetic.operations.plus]: #arithmetic.operations.plus
+[associative]: containers.md#associative
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.indet]: basic.md#basic.indet
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.types.general]: basic.md#basic.types.general
+[bit]: #bit
+[bit.byteswap]: #bit.byteswap
+[bit.cast]: #bit.cast
+[bit.count]: #bit.count
+[bit.endian]: #bit.endian
+[bit.general]: #bit.general
+[bit.pow.two]: #bit.pow.two
+[bit.rotate]: #bit.rotate
+[bit.syn]: #bit.syn
+[bitmask.types]: library.md#bitmask.types
+[bitset]: #bitset
+[bitset.cons]: #bitset.cons
+[bitset.hash]: #bitset.hash
+[bitset.members]: #bitset.members
+[bitset.operators]: #bitset.operators
+[bitset.syn]: #bitset.syn
+[bitwise.operations]: #bitwise.operations
+[bitwise.operations.and]: #bitwise.operations.and
+[bitwise.operations.general]: #bitwise.operations.general
+[bitwise.operations.not]: #bitwise.operations.not
+[bitwise.operations.or]: #bitwise.operations.or
+[bitwise.operations.xor]: #bitwise.operations.xor
+[charconv]: #charconv
+[charconv.from.chars]: #charconv.from.chars
+[charconv.syn]: #charconv.syn
+[charconv.to.chars]: #charconv.to.chars
+[class.base.init]: class.md#class.base.init
+[class.copy.ctor]: class.md#class.copy.ctor
+[comparisons]: #comparisons
+[comparisons.equal.to]: #comparisons.equal.to
+[comparisons.general]: #comparisons.general
+[comparisons.greater]: #comparisons.greater
+[comparisons.greater.equal]: #comparisons.greater.equal
+[comparisons.less]: #comparisons.less
+[comparisons.less.equal]: #comparisons.less.equal
+[comparisons.not.equal.to]: #comparisons.not.equal.to
+[comparisons.three.way]: #comparisons.three.way
+[concepts.equality]: concepts.md#concepts.equality
+[cpp17.copyassignable]: #cpp17.copyassignable
+[cpp17.copyconstructible]: #cpp17.copyconstructible
+[cpp17.defaultconstructible]: #cpp17.defaultconstructible
+[cpp17.destructible]: #cpp17.destructible
+[cpp17.hash]: #cpp17.hash
+[cpp17.moveassignable]: #cpp17.moveassignable
+[cpp17.moveconstructible]: #cpp17.moveconstructible
+[dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.init.general]: dcl.md#dcl.init.general
+[declval]: #declval
+[defns.expression.equivalent]: intro.md#defns.expression.equivalent
+[defns.ntcts]: intro.md#defns.ntcts
+[defns.order.ptr]: #defns.order.ptr
+[defns.referenceable]: intro.md#defns.referenceable
+[except.terminate]: except.md#except.terminate
+[execpol]: #execpol
+[execpol.general]: #execpol.general
+[execpol.objects]: #execpol.objects
+[execpol.par]: #execpol.par
+[execpol.parunseq]: #execpol.parunseq
+[execpol.seq]: #execpol.seq
+[execpol.type]: #execpol.type
+[execpol.unseq]: #execpol.unseq
+[execution.syn]: #execution.syn
+[expected]: #expected
+[expected.bad]: #expected.bad
+[expected.bad.void]: #expected.bad.void
+[expected.expected]: #expected.expected
+[expected.general]: #expected.general
+[expected.object.assign]: #expected.object.assign
+[expected.object.cons]: #expected.object.cons
+[expected.object.dtor]: #expected.object.dtor
+[expected.object.eq]: #expected.object.eq
+[expected.object.general]: #expected.object.general
+[expected.object.monadic]: #expected.object.monadic
+[expected.object.obs]: #expected.object.obs
+[expected.object.swap]: #expected.object.swap
+[expected.syn]: #expected.syn
+[expected.un.cons]: #expected.un.cons
+[expected.un.eq]: #expected.un.eq
+[expected.un.general]: #expected.un.general
+[expected.un.obs]: #expected.un.obs
+[expected.un.swap]: #expected.un.swap
+[expected.unexpected]: #expected.unexpected
+[expected.void]: #expected.void
+[expected.void.assign]: #expected.void.assign
+[expected.void.cons]: #expected.void.cons
+[expected.void.dtor]: #expected.void.dtor
+[expected.void.eq]: #expected.void.eq
+[expected.void.general]: #expected.void.general
+[expected.void.monadic]: #expected.void.monadic
+[expected.void.obs]: #expected.void.obs
+[expected.void.swap]: #expected.void.swap
+[expr.add]: expr.md#expr.add
+[expr.bit.and]: expr.md#expr.bit.and
+[expr.call]: expr.md#expr.call
+[expr.const]: expr.md#expr.const
+[expr.eq]: expr.md#expr.eq
+[expr.log.and]: expr.md#expr.log.and
+[expr.log.or]: expr.md#expr.log.or
+[expr.mul]: expr.md#expr.mul
+[expr.or]: expr.md#expr.or
+[expr.rel]: expr.md#expr.rel
+[expr.unary.op]: expr.md#expr.unary.op
+[expr.xor]: expr.md#expr.xor
+[format]: #format
+[format.align]: #format.align
+[format.arg]: #format.arg
+[format.arg.store]: #format.arg.store
+[format.args]: #format.args
+[format.arguments]: #format.arguments
+[format.context]: #format.context
+[format.err.report]: #format.err.report
+[format.error]: #format.error
+[format.escape.sequences]: #format.escape.sequences
+[format.fmt.string]: #format.fmt.string
+[format.formattable]: #format.formattable
+[format.formatter]: #format.formatter
+[format.formatter.spec]: #format.formatter.spec
+[format.functions]: #format.functions
+[format.parse.ctx]: #format.parse.ctx
+[format.range]: #format.range
+[format.range.fmtdef]: #format.range.fmtdef
+[format.range.fmtkind]: #format.range.fmtkind
+[format.range.fmtmap]: #format.range.fmtmap
+[format.range.fmtset]: #format.range.fmtset
+[format.range.fmtstr]: #format.range.fmtstr
+[format.range.formatter]: #format.range.formatter
+[format.sign]: #format.sign
+[format.string]: #format.string
+[format.string.escaped]: #format.string.escaped
+[format.string.general]: #format.string.general
+[format.string.std]: #format.string.std
+[format.syn]: #format.syn
+[format.tuple]: #format.tuple
+[format.type.bool]: #format.type.bool
+[format.type.char]: #format.type.char
+[format.type.float]: #format.type.float
+[format.type.int]: #format.type.int
+[format.type.ptr]: #format.type.ptr
+[format.type.string]: #format.type.string
+[formatter]: #formatter
+[formatter.basic]: #formatter.basic
+[formatter.range.type]: #formatter.range.type
+[formatter.requirements]: #formatter.requirements
+[formatter.tuple.type]: #formatter.tuple.type
+[forward]: #forward
+[freestanding.item]: library.md#freestanding.item
+[func.bind]: #func.bind
+[func.bind.bind]: #func.bind.bind
+[func.bind.general]: #func.bind.general
+[func.bind.isbind]: #func.bind.isbind
+[func.bind.isplace]: #func.bind.isplace
+[func.bind.partial]: #func.bind.partial
+[func.bind.place]: #func.bind.place
+[func.def]: #func.def
+[func.identity]: #func.identity
+[func.invoke]: #func.invoke
+[func.memfn]: #func.memfn
+[func.not.fn]: #func.not.fn
+[func.require]: #func.require
+[func.search]: #func.search
+[func.search.bm]: #func.search.bm
+[func.search.bmh]: #func.search.bmh
+[func.search.default]: #func.search.default
+[func.search.general]: #func.search.general
+[func.wrap]: #func.wrap
+[func.wrap.badcall]: #func.wrap.badcall
+[func.wrap.func]: #func.wrap.func
+[func.wrap.func.alg]: #func.wrap.func.alg
+[func.wrap.func.cap]: #func.wrap.func.cap
+[func.wrap.func.con]: #func.wrap.func.con
+[func.wrap.func.general]: #func.wrap.func.general
+[func.wrap.func.inv]: #func.wrap.func.inv
+[func.wrap.func.mod]: #func.wrap.func.mod
+[func.wrap.func.nullptr]: #func.wrap.func.nullptr
+[func.wrap.func.targ]: #func.wrap.func.targ
+[func.wrap.general]: #func.wrap.general
+[func.wrap.move]: #func.wrap.move
+[func.wrap.move.class]: #func.wrap.move.class
+[func.wrap.move.ctor]: #func.wrap.move.ctor
+[func.wrap.move.general]: #func.wrap.move.general
+[func.wrap.move.inv]: #func.wrap.move.inv
+[func.wrap.move.util]: #func.wrap.move.util
+[function.objects]: #function.objects
+[function.objects.general]: #function.objects.general
+[functional.syn]: #functional.syn
+[intro.multithread]: basic.md#intro.multithread
+[intro.object]: basic.md#intro.object
+[invalid.argument]: diagnostics.md#invalid.argument
+[istream.formatted]: input.md#istream.formatted
+[iterator.concept.output]: iterators.md#iterator.concept.output
+[lex.string.literal]: lex.md#lex.string.literal
+[logical.operations]: #logical.operations
+[logical.operations.and]: #logical.operations.and
+[logical.operations.general]: #logical.operations.general
+[logical.operations.not]: #logical.operations.not
+[logical.operations.or]: #logical.operations.or
+[meta.rqmts]: meta.md#meta.rqmts
+[meta.trans.other]: meta.md#meta.trans.other
+[namespace.std]: library.md#namespace.std
+[optional]: #optional
+[optional.assign]: #optional.assign
+[optional.assign.copy]: #optional.assign.copy
+[optional.assign.copy.templ]: #optional.assign.copy.templ
+[optional.assign.move]: #optional.assign.move
+[optional.assign.move.templ]: #optional.assign.move.templ
+[optional.bad.access]: #optional.bad.access
+[optional.comp.with.t]: #optional.comp.with.t
+[optional.ctor]: #optional.ctor
+[optional.dtor]: #optional.dtor
+[optional.general]: #optional.general
+[optional.hash]: #optional.hash
+[optional.mod]: #optional.mod
+[optional.monadic]: #optional.monadic
+[optional.nullops]: #optional.nullops
+[optional.nullopt]: #optional.nullopt
+[optional.observe]: #optional.observe
+[optional.optional]: #optional.optional
+[optional.optional.general]: #optional.optional.general
+[optional.relops]: #optional.relops
+[optional.specalg]: #optional.specalg
+[optional.swap]: #optional.swap
+[optional.syn]: #optional.syn
+[ostream.formatted]: input.md#ostream.formatted
+[out.of.range]: diagnostics.md#out.of.range
+[over.match.call]: over.md#over.match.call
+[overflow.error]: diagnostics.md#overflow.error
+[pair.astuple]: #pair.astuple
+[pair.piecewise]: #pair.piecewise
+[pairs]: #pairs
+[pairs.general]: #pairs.general
+[pairs.pair]: #pairs.pair
+[pairs.spec]: #pairs.spec
+[range.cmp]: #range.cmp
+[range.utility.helpers]: ranges.md#range.utility.helpers
+[refwrap]: #refwrap
+[refwrap.access]: #refwrap.access
+[refwrap.assign]: #refwrap.assign
+[refwrap.common.ref]: #refwrap.common.ref
+[refwrap.const]: #refwrap.const
+[refwrap.general]: #refwrap.general
+[refwrap.helpers]: #refwrap.helpers
+[refwrap.invoke]: #refwrap.invoke
+[res.on.exception.handling]: library.md#res.on.exception.handling
+[round.style]: support.md#round.style
+[support.signal]: support.md#support.signal
+[swappable.requirements]: library.md#swappable.requirements
+[temp.param]: temp.md#temp.param
+[temp.type]: temp.md#temp.type
+[template.bitset]: #template.bitset
+[template.bitset.general]: #template.bitset.general
+[term.object.representation]: basic.md#term.object.representation
+[term.object.type]: basic.md#term.object.type
+[term.odr.use]: basic.md#term.odr.use
+[term.perfect.forwarding.call.wrapper]: #term.perfect.forwarding.call.wrapper
+[term.simple.call.wrapper]: #term.simple.call.wrapper
+[term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
+[time.format]: time.md#time.format
+[tuple]: #tuple
+[tuple.apply]: #tuple.apply
+[tuple.assign]: #tuple.assign
+[tuple.cnstr]: #tuple.cnstr
+[tuple.common.ref]: #tuple.common.ref
+[tuple.creation]: #tuple.creation
+[tuple.elem]: #tuple.elem
+[tuple.general]: #tuple.general
+[tuple.helper]: #tuple.helper
+[tuple.like]: #tuple.like
+[tuple.rel]: #tuple.rel
+[tuple.special]: #tuple.special
+[tuple.swap]: #tuple.swap
+[tuple.syn]: #tuple.syn
+[tuple.traits]: #tuple.traits
+[tuple.tuple]: #tuple.tuple
+[type.index]: #type.index
+[type.index.hash]: #type.index.hash
+[type.index.members]: #type.index.members
+[type.index.overview]: #type.index.overview
+[type.index.synopsis]: #type.index.synopsis
+[unord]: containers.md#unord
+[unord.hash]: #unord.hash
+[utilities]: #utilities
+[utilities.general]: #utilities.general
+[utilities.summary]: #utilities.summary
+[utility]: #utility
+[utility.as.const]: #utility.as.const
+[utility.exchange]: #utility.exchange
+[utility.intcmp]: #utility.intcmp
+[utility.swap]: #utility.swap
+[utility.syn]: #utility.syn
+[utility.underlying]: #utility.underlying
+[utility.unreachable]: #utility.unreachable
+[variant]: #variant
+[variant.assign]: #variant.assign
+[variant.bad.access]: #variant.bad.access
+[variant.ctor]: #variant.ctor
+[variant.dtor]: #variant.dtor
+[variant.general]: #variant.general
+[variant.get]: #variant.get
+[variant.hash]: #variant.hash
+[variant.helper]: #variant.helper
+[variant.mod]: #variant.mod
+[variant.monostate]: #variant.monostate
+[variant.monostate.relops]: #variant.monostate.relops
+[variant.relops]: #variant.relops
+[variant.specalg]: #variant.specalg
+[variant.status]: #variant.status
+[variant.swap]: #variant.swap
+[variant.syn]: #variant.syn
+[variant.variant]: #variant.variant
+[variant.variant.general]: #variant.variant.general
+[variant.visit]: #variant.visit
+[^1]: Such a type is a function pointer or a class type which has a
+    member `operator()` or a class type which has a conversion to a
+    pointer to function.
+[^2]: Windows® is a registered trademark of Microsoft Corporation. This
+    information is given for the convenience of users of this document
+    and does not constitute an endorsement by ISO or IEC of this
+    product.

Diff to HTML by rtfpessoa