[basic.types] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpo7q7ap9w/{from.md → to.md} +240 -94

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

@@ -10,11 +10,11 @@ functions [[dcl.fct]]. — *end note*]
 For any object (other than a potentially-overlapping subobject) of
 trivially copyable type `T`, whether or not the object holds a valid
 value of type `T`, the underlying bytes [[intro.memory]] making up the
 object can be copied into an array of `char`, `unsigned char`, or
-`std::byte` [[cstddef.syn]].[^14]
 If the content of that array is copied back into the object, the object
 shall subsequently hold its original value.
 [*Example 1*:
@@ -30,11 +30,11 @@ std::memcpy(&obj, buf, N);      // at this point, each subobject of obj of scala
 — *end example*]
 For two distinct objects `obj1` and `obj2` of trivially copyable type
 `T`, where neither `obj1` nor `obj2` is a potentially-overlapping
 subobject, if the underlying bytes [[intro.memory]] making up `obj1` are
-copied into `obj2`,[^15]
 `obj2` shall subsequently hold the same value as `obj1`.
 [*Example 2*:
@@ -47,23 +47,31 @@ std::memcpy(t1p, t2p, sizeof(T));
     // the same value as the corresponding subobject in *t2p
 ```
 — *end example*]
-The *object representation* of an object of type `T` is the sequence of
-*N* `unsigned char` objects taken up by the object of type `T`, where
-*N* equals `sizeof(T)`. The *value representation* of an object of type
-`T` is the set of bits that participate in representing a value of type
-`T`. Bits in the object representation that are not part of the value
-representation are *padding bits*. For trivially copyable types, the
-value representation is a set of bits in the object representation that
-determines a *value*, which is one discrete element of an
-*implementation-defined* set of values.[^16]
 A class that has been declared but not defined, an enumeration type in
 certain contexts [[dcl.enum]], or an array of unknown bound or of
-incomplete element type, is an *incompletely-defined object type*.[^17]
 Incompletely-defined object types and cv `void` are *incomplete types*
 [[basic.fundamental]].
 [*Note 2*: Objects cannot be defined to have an incomplete type
@@ -121,34 +129,36 @@ contexts incomplete types are prohibited. — *end note*]
 An *object type* is a (possibly cv-qualified) type that is not a
 function type, not a reference type, and not cv `void`.
 Arithmetic types [[basic.fundamental]], enumeration types, pointer
-types, pointer-to-member types [[basic.compound]], `std::nullptr_t`, and
-cv-qualified [[basic.type.qualifier]] versions of these types are
-collectively called *scalar types*. Scalar types, trivially copyable
-class types [[class.prop]], arrays of such types, and cv-qualified
-versions of these types are collectively called *trivially copyable
-types*. Scalar types, trivial class types [[class.prop]], arrays of such
-types and cv-qualified versions of these types are collectively called
-*trivial types*. Scalar types, standard-layout class types
-[[class.prop]], arrays of such types and cv-qualified versions of these
-types are collectively called *standard-layout types*. Scalar types,
-implicit-lifetime class types [[class.prop]], array types, and
-cv-qualified versions of these types are collectively called
-*implicit-lifetime types*.
 A type is a *literal type* if it is:
 - cv `void`; or
 - a scalar type; or
 - a reference type; or
 - an array of literal type; or
 - a possibly cv-qualified class type [[class]] that has all of the
   following properties:
   - it has a constexpr destructor [[dcl.constexpr]],
-  - all of its non-static non-variant data members and base classes are
     of non-volatile literal types, and
   - it
     - is a closure type [[expr.prim.lambda.closure]],
     - is an aggregate union type that has either no variant members or
       at least one variant member of non-volatile literal type,
@@ -168,20 +178,30 @@ expression. — *end note*]
 Two types *cv1* `T1` and *cv2* `T2` are *layout-compatible types* if
 `T1` and `T2` are the same type, layout-compatible enumerations
 [[dcl.enum]], or layout-compatible standard-layout class types
 [[class.mem]].
 ### Fundamental types <a id="basic.fundamental">[[basic.fundamental]]</a>
 There are five *standard signed integer types*: “`signed char`”,
 “`short int`”, “`int`”, “`long int`”, and “`long long int`”. In this
 list, each type provides at least as much storage as those preceding it
 in the list. There may also be *implementation-defined* *extended signed
 integer types*. The standard and extended signed integer types are
 collectively called *signed integer types*. The range of representable
-values for a signed integer type is -2ᴺ⁻¹ to 2ᴺ⁻¹-1 (inclusive), where
-*N* is called the *width* of the type.
 [*Note 1*: Plain `int`s are intended to have the natural width
 suggested by the architecture of the execution environment; the other
 signed integer types are provided to meet special needs. — *end note*]
@@ -203,11 +223,11 @@ arithmetic yields undefined behavior [[expr.pre]]. — *end note*]
 An unsigned integer type has the same object representation, value
 representation, and alignment requirements [[basic.align]] as the
 corresponding signed integer type. For each value x of a signed integer
 type, the value of the corresponding unsigned integer type congruent to
 x modulo 2ᴺ has the same value of corresponding bits in its value
-representation.[^18]
 [*Example 1*: The value -1 of a signed integer type has the same
 representation as the largest value of the corresponding unsigned
 type. — *end example*]
@@ -220,22 +240,22 @@ type. — *end example*]
 | `int`           | 16                |
 | `long int`      | 32                |
 | `long long int` | 64                |
-The width of each signed integer type shall not be less than the values
-specified in [[basic.fundamental.width]]. The value representation of a
-signed or unsigned integer type comprises N bits, where N is the
-respective width. Each set of values for any padding bits
 [[basic.types.general]] in the object representation are alternative
 representations of the value specified by the value representation.
 [*Note 3*: Padding bits have unspecified value, but cannot cause traps.
-In contrast, see ISO C 6.2.6.2. — *end note*]
 [*Note 4*: The signed and unsigned integer types satisfy the
-constraints given in ISO C 5.2.4.2.1. — *end note*]
 Except as specified above, the width of a signed or unsigned integer
 type is *implementation-defined*.
 Each value x of an unsigned integer type with width N has a unique
@@ -273,12 +293,12 @@ than the width of that type has padding bits; see
 Type `wchar_t` is a distinct type that has an *implementation-defined*
 signed or unsigned integer type as its underlying type.
 Type `char8_t` denotes a distinct type whose underlying type is
 `unsigned char`. Types `char16_t` and `char32_t` denote distinct types
-whose underlying types are `uint_least16_t` and `uint_least32_t`,
-respectively, in `<cstdint>`.
 Type `bool` is a distinct type that has the same object representation,
 value representation, and alignment requirements as an
 *implementation-defined* unsigned integer type. The values of type
 `bool` are `true` and `false`.
@@ -318,128 +338,233 @@ interactions with floating-point types. — *end note*]
 Except as specified in [[basic.extended.fp]], the object and value
 representations and accuracy of operations of floating-point types are
 *implementation-defined*.
 Integral and floating-point types are collectively termed *arithmetic
 types*.
-[*Note 10*: Properties of the arithmetic types, such as their minimum
 and maximum representable value, can be queried using the facilities in
 the standard library headers `<limits>`, `<climits>`, and
 `<cfloat>`. — *end note*]
 A type cv `void` is an incomplete type that cannot be completed; such a
 type has an empty set of values. It is used as the return type for
-functions that do not return a value. Any expression can be explicitly
-converted to type cv `void`
-[[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]. An expression
-of type cv `void` shall be used only as an expression statement
-[[stmt.expr]], as an operand of a comma expression [[expr.comma]], as a
-second or third operand of `?:` [[expr.cond]], as the operand of
-`typeid`, `noexcept`, or `decltype`, as the expression in a `return`
-statement [[stmt.return]] for a function with the return type cv `void`,
-or as the operand of an explicit conversion to type cv `void`.
-A value of type `std::nullptr_t` is a null pointer constant
-[[conv.ptr]]. Such values participate in the pointer and the
-pointer-to-member conversions [[conv.ptr]], [[conv.mem]].
-`sizeof(std::nullptr_t)` shall be equal to `sizeof(void*)`.
 The types described in this subclause are called *fundamental types*.
-[*Note 11*: Even if the implementation defines two or more fundamental
 types to have the same value representation, they are nevertheless
 different types. — *end note*]
 ### Optional extended floating-point types <a id="basic.extended.fp">[[basic.extended.fp]]</a>
 If the implementation supports an extended floating-point type
-[[basic.fundamental]] whose properties are specified by the ISO/IEC/IEEE
 60559 floating-point interchange format binary16, then the
-*typedef-name* `std::float16_t` is defined in the header `<stdfloat>`
 and names such a type, the macro `__STDCPP_FLOAT16_T__` is defined
 [[cpp.predefined]], and the floating-point literal suffixes `f16` and
 `F16` are supported [[lex.fcon]].
 If the implementation supports an extended floating-point type whose
-properties are specified by the ISO/IEC/IEEE 60559 floating-point
-interchange format binary32, then the *typedef-name* `std::float32_t` is
-defined in the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT32_T__` is defined, and the floating-point literal
 suffixes `f32` and `F32` are supported.
 If the implementation supports an extended floating-point type whose
-properties are specified by the ISO/IEC/IEEE 60559 floating-point
-interchange format binary64, then the *typedef-name* `std::float64_t` is
-defined in the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT64_T__` is defined, and the floating-point literal
 suffixes `f64` and `F64` are supported.
 If the implementation supports an extended floating-point type whose
-properties are specified by the ISO/IEC/IEEE 60559 floating-point
-interchange format binary128, then the *typedef-name* `std::float128_t`
-is defined in the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT128_T__` is defined, and the floating-point literal
 suffixes `f128` and `F128` are supported.
 If the implementation supports an extended floating-point type with the
-properties, as specified by ISO/IEC/IEEE 60559, of radix (b) of 2,
-storage width in bits (k) of 16, precision in bits (p) of 8, maximum
-exponent (emax) of 127, and exponent field width in bits (w) of 8, then
-the *typedef-name* `std::bfloat16_t` is defined in the header
-`<stdfloat>` and names such a type, the macro `__STDCPP_BFLOAT16_T__` is
-defined, and the floating-point literal suffixes `bf16` and `BF16` are
-supported.
 [*Note 1*: A summary of the parameters for each type is given in
 [[basic.extended.fp]]. The precision p includes the implicit 1 bit at
-the beginning of the mantissa, so the storage used for the mantissa is
-p-1 bits. ISO/IEC/IEEE 60559 does not assign a name for a type having
-the parameters specified for `std::bfloat16_t`. — *end note*]
 **Table: Properties of named extended floating-point types** <a id="basic.extended.fp">[basic.extended.fp]</a>
 | Parameter                         | `float16_t` | `float32_t` | `float64_t` | `float128_t` | `bfloat16_t` |
 | --------------------------------- | ----------- | ----------- | ----------- | ------------ | ------------ |
-| ISO/IEC/IEEE 60559 name | binary16    | binary32    | binary64    | binary128    |              |
 | $k$, storage width in bits        | 16          | 32          | 64          | 128          | 16           |
 | $p$, precision in bits            | 11          | 24          | 53          | 113          | 8            |
 | $emax$, maximum exponent          | 15          | 127         | 1023        | 16383        | 127          |
 | $w$, exponent field width in bits | 5           | 8           | 11          | 15           | 8            |
 *Recommended practice:* Any names that the implementation provides for
 the extended floating-point types described in this subsection that are
-in addition to the names defined in the `<stdfloat>` header should be
 chosen to increase compatibility and interoperability with the
 interchange types `_Float16`, `_Float32`, `_Float64`, and `_Float128`
-defined in ISO/IEC TS 18661-3 and with future versions of the C
-standard.
 ### Compound types <a id="basic.compound">[[basic.compound]]</a>
 Compound types can be constructed in the following ways:
 - *arrays* of objects of a given type, [[dcl.array]];
 - *functions*, which have parameters of given types and return `void` or
- references or objects of a given type, [[dcl.fct]];
 - *pointers* to cv `void` or objects or functions (including static
   members of classes) of a given type, [[dcl.ptr]];
 - *references* to objects or functions of a given type, [[dcl.ref]].
   There are two types of references:
   - lvalue reference
   - rvalue reference
-- *classes* containing a sequence of objects of various types [[class]],
-  a set of types, enumerations and functions for manipulating these
-  objects [[class.mfct]], and a set of restrictions on the access to
   these entities [[class.access]];
 - *unions*, which are classes capable of containing objects of different
   types at different times, [[class.union]];
 - *enumerations*, which comprise a set of named constant values,
   [[dcl.enum]];
-- *pointers to non-static class members*,[^19] which identify members of
   a given type within objects of a given class, [[dcl.mptr]]. Pointers
   to data members and pointers to member functions are collectively
   called *pointer-to-member* types.
 These methods of constructing types can be applied recursively;
@@ -463,46 +588,59 @@ to as a “pointer to `T`”.
 “pointer to `X`”. — *end example*]
 Except for pointers to static members, text referring to “pointers” does
 not apply to pointers to members. Pointers to incomplete types are
 allowed although there are restrictions on what can be done with them
-[[basic.align]]. Every value of pointer type is one of the following:
 - a *pointer to* an object or function (the pointer is said to *point*
   to the object or function), or
 - a *pointer past the end of* an object [[expr.add]], or
 - the *null pointer value* for that type, or
 - an *invalid pointer value*.
 A value of a pointer type that is a pointer to or past the end of an
 object *represents the address* of the first byte in memory
-[[intro.memory]] occupied by the object[^20]
 or the first byte in memory after the end of the storage occupied by the
 object, respectively.
 [*Note 2*: A pointer past the end of an object [[expr.add]] is not
 considered to point to an unrelated object of the object’s type, even if
-the unrelated object is located at that address. A pointer value becomes
-invalid when the storage it denotes reaches the end of its storage
-duration; see [[basic.stc]]. — *end note*]
 For purposes of pointer arithmetic [[expr.add]] and comparison
 [[expr.rel]], [[expr.eq]], a pointer past the end of the last element of
 an array `x` of n elements is considered to be equivalent to a pointer
-to a hypothetical array element n of `x` and an object of type `T` that
 is not an array element is considered to belong to an array with one
 element of type `T`. The value representation of pointer types is
 *implementation-defined*. Pointers to layout-compatible types shall have
 the same value representation and alignment requirements
 [[basic.align]].
 [*Note 3*: Pointers to over-aligned types [[basic.align]] have no
 special representation, but their range of valid values is restricted by
 the extended alignment requirement. — *end note*]
-Two objects *a* and *b* are *pointer-interconvertible* if:
 - they are the same object, or
 - one is a union object and the other is a non-static data member of
   that object [[class.union]], or
 - one is a standard-layout class object and the other is the first
@@ -514,11 +652,11 @@ Two objects *a* and *b* are *pointer-interconvertible* if:
 If two objects are pointer-interconvertible, then they have the same
 address, and it is possible to obtain a pointer to one from a pointer to
 the other via a `reinterpret_cast` [[expr.reinterpret.cast]].
-[*Note 4*: An array object and its first element are not
 pointer-interconvertible, even though they have the same
 address. — *end note*]
 A byte of storage *b* is *reachable through* a pointer value that points
 to an object *x* if there is an object *y*, pointer-interconvertible
@@ -535,11 +673,11 @@ alignment requirements as an object of type “pointer to cv `char`”.
 Each type other than a function or reference type is part of a group of
 four distinct, but related, types: a *cv-unqualified* version, a
 *const-qualified* version, a *volatile-qualified* version, and a
 *const-volatile-qualified* version. The types in each such group shall
 have the same representation and alignment requirements
-[[basic.align]].[^21]
 A function or reference type is always cv-unqualified.
 - A *const object* is an object of type `const T` or a non-mutable
   subobject of a const object.
@@ -647,11 +785,11 @@ integral promotions [[conv.prom]] and the usual arithmetic conversions
 [[expr.arith.conv]]. — *end note*]
 Every floating-point type has a *floating-point conversion rank* defined
 as follows:
-- The rank of a floating point type `T` is greater than the rank of any
   floating-point type whose set of values is a proper subset of the set
   of values of `T`.
 - The rank of `long double` is greater than the rank of `double`, which
   is greater than the rank of `float`.
 - Two extended floating-point types with the same set of values have
@@ -659,11 +797,19 @@ as follows:
 - An extended floating-point type with the same set of values as exactly
   one cv-unqualified standard floating-point type has a rank equal to
   the rank of that standard floating-point type.
 - An extended floating-point type with the same set of values as more
   than one cv-unqualified standard floating-point type has a rank equal
-  to the rank of `double`.
 [*Note 2*: The conversion ranks of floating-point types `T1` and `T2`
 are unordered if the set of values of `T1` is neither a subset nor a
 superset of the set of values of `T2`. This can happen when one type has
 both a larger range and a lower precision than the other. — *end note*]

 For any object (other than a potentially-overlapping subobject) of
 trivially copyable type `T`, whether or not the object holds a valid
 value of type `T`, the underlying bytes [[intro.memory]] making up the
 object can be copied into an array of `char`, `unsigned char`, or
+`std::byte` [[cstddef.syn]].[^12]
 If the content of that array is copied back into the object, the object
 shall subsequently hold its original value.
 [*Example 1*:
 — *end example*]
 For two distinct objects `obj1` and `obj2` of trivially copyable type
 `T`, where neither `obj1` nor `obj2` is a potentially-overlapping
 subobject, if the underlying bytes [[intro.memory]] making up `obj1` are
+copied into `obj2`,[^13]
 `obj2` shall subsequently hold the same value as `obj1`.
 [*Example 2*:
     // the same value as the corresponding subobject in *t2p
 ```
 — *end example*]
+The *object representation* of a complete object type `T` is the
+sequence of *N* `unsigned char` objects taken up by a non-bit-field
+complete object of type `T`, where *N* equals `sizeof(T)`. The *value
+representation* of a type `T` is the set of bits in the object
+representation of `T` that participate in representing a value of type
+`T`. The object and value representation of a non-bit-field complete
+object of type `T` are the bytes and bits, respectively, of the object
+corresponding to the object and value representation of its type. The
+object representation of a bit-field object is the sequence of *N* bits
+taken up by the object, where *N* is the width of the bit-field
+[[class.bit]]. The value representation of a bit-field object is the set
+of bits in the object representation that participate in representing
+its value. Bits in the object representation of a type or object that
+are not part of the value representation are *padding bits*. For
+trivially copyable types, the value representation is a set of bits in
+the object representation that determines a *value*, which is one
+discrete element of an *implementation-defined* set of values.[^14]
 A class that has been declared but not defined, an enumeration type in
 certain contexts [[dcl.enum]], or an array of unknown bound or of
+incomplete element type, is an *incompletely-defined object type*.[^15]
 Incompletely-defined object types and cv `void` are *incomplete types*
 [[basic.fundamental]].
 [*Note 2*: Objects cannot be defined to have an incomplete type
 An *object type* is a (possibly cv-qualified) type that is not a
 function type, not a reference type, and not cv `void`.
 Arithmetic types [[basic.fundamental]], enumeration types, pointer
+types, pointer-to-member types [[basic.compound]], `std::meta::{}info`,
+`std::nullptr_t`, and cv-qualified [[basic.type.qualifier]] versions of
+these types are collectively called *scalar types*. Scalar types,
+trivially copyable class types [[class.prop]], arrays of such types, and
+cv-qualified versions of these types are collectively called *trivially
+copyable types*. Scalar types, trivially relocatable class types
+[[class.prop]], arrays of such types, and cv-qualified versions of these
+types are collectively called *trivially relocatable types*.
+Cv-unqualified scalar types, replaceable class types [[class.prop]], and
+arrays of such types are collectively called *replaceable types*. Scalar
+types, standard-layout class types [[class.prop]], arrays of such types,
+and cv-qualified versions of these types are collectively called
+*standard-layout types*. Scalar types, implicit-lifetime class types
+[[class.prop]], array types, and cv-qualified versions of these types
+are collectively called *implicit-lifetime types*.
 A type is a *literal type* if it is:
 - cv `void`; or
 - a scalar type; or
 - a reference type; or
 - an array of literal type; or
 - a possibly cv-qualified class type [[class]] that has all of the
   following properties:
   - it has a constexpr destructor [[dcl.constexpr]],
+  - all of its non-variant non-static data members and base classes are
     of non-volatile literal types, and
   - it
     - is a closure type [[expr.prim.lambda.closure]],
     - is an aggregate union type that has either no variant members or
       at least one variant member of non-volatile literal type,
 Two types *cv1* `T1` and *cv2* `T2` are *layout-compatible types* if
 `T1` and `T2` are the same type, layout-compatible enumerations
 [[dcl.enum]], or layout-compatible standard-layout class types
 [[class.mem]].
+A type is *consteval-only* if it is either `std::meta::info` or a type
+compounded from a consteval-only type [[basic.compound]]. Every object
+of consteval-only type shall be
+- the object associated with a constexpr variable or a subobject
+  thereof,
+- a template parameter object [[temp.param]] or a subobject thereof, or
+- an object whose lifetime begins and ends during the evaluation of a
+  core constant expression.
 ### Fundamental types <a id="basic.fundamental">[[basic.fundamental]]</a>
 There are five *standard signed integer types*: “`signed char`”,
 “`short int`”, “`int`”, “`long int`”, and “`long long int`”. In this
 list, each type provides at least as much storage as those preceding it
 in the list. There may also be *implementation-defined* *extended signed
 integer types*. The standard and extended signed integer types are
 collectively called *signed integer types*. The range of representable
+values for a signed integer type is -2ᴺ⁻¹ to 2ᴺ⁻¹-1 (inclusive), where N
+is called the *width* of the type.
 [*Note 1*: Plain `int`s are intended to have the natural width
 suggested by the architecture of the execution environment; the other
 signed integer types are provided to meet special needs. — *end note*]
 An unsigned integer type has the same object representation, value
 representation, and alignment requirements [[basic.align]] as the
 corresponding signed integer type. For each value x of a signed integer
 type, the value of the corresponding unsigned integer type congruent to
 x modulo 2ᴺ has the same value of corresponding bits in its value
+representation.[^16]
 [*Example 1*: The value -1 of a signed integer type has the same
 representation as the largest value of the corresponding unsigned
 type. — *end example*]
 | `int`           | 16                |
 | `long int`      | 32                |
 | `long long int` | 64                |
+The width of each standard signed integer type shall not be less than
+the values specified in [[basic.fundamental.width]]. The value
+representation of a signed or unsigned integer type comprises N bits,
+where N is the respective width. Each set of values for any padding bits
 [[basic.types.general]] in the object representation are alternative
 representations of the value specified by the value representation.
 [*Note 3*: Padding bits have unspecified value, but cannot cause traps.
+In contrast, see ISO/IEC 9899:2018 (C) 6.2.6.2. — *end note*]
 [*Note 4*: The signed and unsigned integer types satisfy the
+constraints given in ISO/IEC 9899:2018 (C) 5.3.5.3.2. — *end note*]
 Except as specified above, the width of a signed or unsigned integer
 type is *implementation-defined*.
 Each value x of an unsigned integer type with width N has a unique
 Type `wchar_t` is a distinct type that has an *implementation-defined*
 signed or unsigned integer type as its underlying type.
 Type `char8_t` denotes a distinct type whose underlying type is
 `unsigned char`. Types `char16_t` and `char32_t` denote distinct types
+whose underlying types are `std::uint_least16_t` and
+`std::uint_least32_t`, respectively, in `<cstdint>`.
 Type `bool` is a distinct type that has the same object representation,
 value representation, and alignment requirements as an
 *implementation-defined* unsigned integer type. The values of type
 `bool` are `true` and `false`.
 Except as specified in [[basic.extended.fp]], the object and value
 representations and accuracy of operations of floating-point types are
 *implementation-defined*.
+The minimum range of representable values for a floating-point type is
+the most negative finite floating-point number representable in that
+type through the most positive finite floating-point number
+representable in that type. In addition, if negative infinity is
+representable in a type, the range of that type is extended to all
+negative real numbers; likewise, if positive infinity is representable
+in a type, the range of that type is extended to all positive real
+numbers.
+[*Note 10*: Since negative and positive infinity are representable in
+ISO/IEC 60559 formats, all real numbers lie within the range of
+representable values of a floating-point type adhering to ISO/IEC
+60559. — *end note*]
 Integral and floating-point types are collectively termed *arithmetic
 types*.
+[*Note 11*: Properties of the arithmetic types, such as their minimum
 and maximum representable value, can be queried using the facilities in
 the standard library headers `<limits>`, `<climits>`, and
 `<cfloat>`. — *end note*]
 A type cv `void` is an incomplete type that cannot be completed; such a
 type has an empty set of values. It is used as the return type for
+functions that do not return a value. An expression of type cv `void`
+shall be used only as
+- an expression statement [[stmt.expr]],
+- the expression in a `return` statement [[stmt.return]] for a function
+  with the return type cv `void`,
+- an operand of a comma expression [[expr.comma]],
+- the second or third operand of `?:` [[expr.cond]],
+- the operand of a `typeid` expression [[expr.typeid]],
+- the operand of a `noexcept` operator [[expr.unary.noexcept]],
+- the operand of a `decltype` specifier [[dcl.type.decltype]], or
+- the operand of an explicit conversion to type cv `void`
+ [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]].
+The types denoted by cv `std::nullptr_t` are distinct types. A prvalue
+of type `std::nullptr_t` is a null pointer constant [[conv.ptr]]. Such
+values participate in the pointer and the pointer-to-member conversions
+[[conv.ptr]], [[conv.mem]]. `sizeof(std::nullptr_t)` shall be equal to
+`sizeof(void*)`.
+A value of type `std::meta::info` is called a *reflection*. There exists
+a unique *null reflection*; every other reflection is a representation
+of
+- a value of scalar type [[temp.param]],
+- an object with static storage duration [[basic.stc]],
+- a variable [[basic.pre]],
+- a structured binding [[dcl.struct.bind]],
+- a function [[dcl.fct]],
+- a function parameter,
+- an enumerator [[dcl.enum]],
+- an annotation [[dcl.attr.grammar]],
+- a type alias [[dcl.typedef]],
+- a type [[basic.types]],
+- a class member [[class.mem]],
+- an unnamed bit-field [[class.bit]],
+- a class template [[temp.pre]],
+- a function template,
+- a variable template,
+- an alias template [[temp.alias]],
+- a concept [[temp.concept]],
+- a namespace alias [[namespace.alias]],
+- a namespace [[basic.namespace.general]],
+- a direct base class relationship [[class.derived.general]], or
+- a data member description [[class.mem.general]].
+A reflection is said to *represent* the corresponding construct.
+[*Note 12*: A reflection of a value can be produced by library
+functions such as `std::meta::constant_of` and
+`std::meta::reflect_constant`. — *end note*]
+[*Example 2*:
+``` cpp
+int arr[] = {1, 2, 3};
+auto [a1, a2, a3] = arr;
+[[=1]] void fn(int n);
+enum Enum { A };
+using Alias = int;
+struct B {};
+struct S : B {
+  int mem;
+  int : 0;
+};
+template<auto> struct TCls {};
+template<auto> void TFn();
+template<auto> int TVar;
+template<auto N> using TAlias = TCls<N>;
+template<auto> concept Concept = requires { true; };
+namespace NS {};
+namespace NSAlias = NS;
+constexpr auto ctx = std::meta::access_context::current();
+constexpr auto r1 = std::meta::reflect_constant(42);        // represents int value of 42
+constexpr auto r2 = std::meta::reflect_object(arr[1]);      // represents int object
+constexpr auto r3 = ^^arr;                                  // represents a variable
+constexpr auto r4 = ^^a3;                                   // represents a structured binding
+constexpr auto r5 = ^^fn;                                   // represents a function
+constexpr auto r6 = std::meta::parameters_of(^^fn)[0];      // represents a function parameter
+constexpr auto r7 = ^^Enum::A;                              // represents an enumerator
+constexpr auto r8 = std::meta::annotations_of(^^fn)[0];     // represents an annotation
+constexpr auto r9 = ^^Alias;                                // represents a type alias
+constexpr auto r10 = ^^S;                                   // represents a type
+constexpr auto r11 = ^^S::mem;                              // represents a class member
+constexpr auto r12 = std::meta::members_of(^^S, ctx)[1];    // represents an unnamed bit-field
+constexpr auto r13 = ^^TCls;                                // represents a class template
+constexpr auto r14 = ^^TFn;                                 // represents a function template
+constexpr auto r15 = ^^TVar;                                // represents a variable template
+constexpr auto r16 = ^^TAlias;                              // represents an alias template
+constexpr auto r17 = ^^Concept;                             // represents a concept
+constexpr auto r18 = ^^NSAlias;                             // represents a namespace alias
+constexpr auto r19 = ^^NS;                                  // represents a namespace
+constexpr auto r20 = std::meta::bases_of(^^S, ctx)[0];      // represents a direct base class relationship
+constexpr auto r21 =
+  std::meta::data_member_spec(^^int, {.name="member"});     // represents a data member description
+```
+— *end example*]
+*Recommended practice:* Implementations should not represent other
+constructs specified in this document, such as *using-declarator*s,
+partial template specializations, attributes, placeholder types,
+statements, or expressions, as values of type `std::meta::info`.
+[*Note 13*: Future revisions of this document can specify semantics for
+reflections representing any such constructs. — *end note*]
 The types described in this subclause are called *fundamental types*.
+[*Note 14*: Even if the implementation defines two or more fundamental
 types to have the same value representation, they are nevertheless
 different types. — *end note*]
 ### Optional extended floating-point types <a id="basic.extended.fp">[[basic.extended.fp]]</a>
 If the implementation supports an extended floating-point type
+[[basic.fundamental]] whose properties are specified by the ISO/IEC
 60559 floating-point interchange format binary16, then the
+*typedef-name* `std::float16_t` is declared in the header `<stdfloat>`
 and names such a type, the macro `__STDCPP_FLOAT16_T__` is defined
 [[cpp.predefined]], and the floating-point literal suffixes `f16` and
 `F16` are supported [[lex.fcon]].
 If the implementation supports an extended floating-point type whose
+properties are specified by the ISO/IEC 60559 floating-point interchange
+format binary32, then the *typedef-name* `std::float32_t` is declared in
+the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT32_T__` is defined, and the floating-point literal
 suffixes `f32` and `F32` are supported.
 If the implementation supports an extended floating-point type whose
+properties are specified by the ISO/IEC 60559 floating-point interchange
+format binary64, then the *typedef-name* `std::float64_t` is declared in
+the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT64_T__` is defined, and the floating-point literal
 suffixes `f64` and `F64` are supported.
 If the implementation supports an extended floating-point type whose
+properties are specified by the ISO/IEC 60559 floating-point interchange
+format binary128, then the *typedef-name* `std::float128_t` is declared
+in the header `<stdfloat>` and names such a type, the macro
 `__STDCPP_FLOAT128_T__` is defined, and the floating-point literal
 suffixes `f128` and `F128` are supported.
 If the implementation supports an extended floating-point type with the
+properties, as specified by ISO/IEC 60559, of radix (b) of 2, storage
+width in bits (k) of 16, precision in bits (p) of 8, maximum exponent
+(emax) of 127, and exponent field width in bits (w) of 8, then the
+*typedef-name* `std::bfloat16_t` is declared in the header `<stdfloat>`
+and names such a type, the macro `__STDCPP_BFLOAT16_T__` is defined, and
+the floating-point literal suffixes `bf16` and `BF16` are supported.
 [*Note 1*: A summary of the parameters for each type is given in
 [[basic.extended.fp]]. The precision p includes the implicit 1 bit at
+the beginning of the significand, so the storage used for the
+significand is p-1 bits. ISO/IEC 60559 does not assign a name for a type
+having the parameters specified for `std::bfloat16_t`. — *end note*]
 **Table: Properties of named extended floating-point types** <a id="basic.extended.fp">[basic.extended.fp]</a>
 | Parameter                         | `float16_t` | `float32_t` | `float64_t` | `float128_t` | `bfloat16_t` |
 | --------------------------------- | ----------- | ----------- | ----------- | ------------ | ------------ |
+| ISO/IEC 60559 name | binary16    | binary32    | binary64    | binary128    |              |
 | $k$, storage width in bits        | 16          | 32          | 64          | 128          | 16           |
 | $p$, precision in bits            | 11          | 24          | 53          | 113          | 8            |
 | $emax$, maximum exponent          | 15          | 127         | 1023        | 16383        | 127          |
 | $w$, exponent field width in bits | 5           | 8           | 11          | 15           | 8            |
 *Recommended practice:* Any names that the implementation provides for
 the extended floating-point types described in this subsection that are
+in addition to the names declared in the `<stdfloat>` header should be
 chosen to increase compatibility and interoperability with the
 interchange types `_Float16`, `_Float32`, `_Float64`, and `_Float128`
+defined in ISO/IEC TS 18661-3 and with future versions of \IsoCUndated.
 ### Compound types <a id="basic.compound">[[basic.compound]]</a>
 Compound types can be constructed in the following ways:
 - *arrays* of objects of a given type, [[dcl.array]];
 - *functions*, which have parameters of given types and return `void` or
+ a result of a given type, [[dcl.fct]];
 - *pointers* to cv `void` or objects or functions (including static
   members of classes) of a given type, [[dcl.ptr]];
 - *references* to objects or functions of a given type, [[dcl.ref]].
   There are two types of references:
   - lvalue reference
   - rvalue reference
+- *classes* containing a sequence of class members
+ [[class]], [[class.mem]], and a set of restrictions on the access to
   these entities [[class.access]];
 - *unions*, which are classes capable of containing objects of different
   types at different times, [[class.union]];
 - *enumerations*, which comprise a set of named constant values,
   [[dcl.enum]];
+- *pointers to non-static class members*,[^17] which identify members of
   a given type within objects of a given class, [[dcl.mptr]]. Pointers
   to data members and pointers to member functions are collectively
   called *pointer-to-member* types.
 These methods of constructing types can be applied recursively;
 “pointer to `X`”. — *end example*]
 Except for pointers to static members, text referring to “pointers” does
 not apply to pointers to members. Pointers to incomplete types are
 allowed although there are restrictions on what can be done with them
+[[basic.types.general]]. Every value of pointer type is one of the
+following:
 - a *pointer to* an object or function (the pointer is said to *point*
   to the object or function), or
 - a *pointer past the end of* an object [[expr.add]], or
 - the *null pointer value* for that type, or
 - an *invalid pointer value*.
 A value of a pointer type that is a pointer to or past the end of an
 object *represents the address* of the first byte in memory
+[[intro.memory]] occupied by the object[^18]
 or the first byte in memory after the end of the storage occupied by the
 object, respectively.
 [*Note 2*: A pointer past the end of an object [[expr.add]] is not
 considered to point to an unrelated object of the object’s type, even if
+the unrelated object is located at that address. — *end note*]
 For purposes of pointer arithmetic [[expr.add]] and comparison
 [[expr.rel]], [[expr.eq]], a pointer past the end of the last element of
 an array `x` of n elements is considered to be equivalent to a pointer
+to a hypothetical array element n of `x`, and an object of type `T` that
 is not an array element is considered to belong to an array with one
 element of type `T`. The value representation of pointer types is
 *implementation-defined*. Pointers to layout-compatible types shall have
 the same value representation and alignment requirements
 [[basic.align]].
 [*Note 3*: Pointers to over-aligned types [[basic.align]] have no
 special representation, but their range of valid values is restricted by
 the extended alignment requirement. — *end note*]
+A pointer value P is *valid in the context of* an evaluation E if P is a
+pointer to function or a null pointer value, or if it is a pointer to or
+past the end of an object O and E happens before the end of the duration
+of the region of storage for O. If a pointer value P is used in an
+evaluation E and P is not valid in the context of E, then the behavior
+is undefined if E is an indirection [[expr.unary.op]] or an invocation
+of a deallocation function [[basic.stc.dynamic.deallocation]], and
+*implementation-defined* otherwise.[^19]
+[*Note 4*: P can be valid in the context of E even if it points to a
+type unrelated to that of O or if O is not within its lifetime, although
+further restrictions apply to such pointer values
+[[basic.life]], [[basic.lval]], [[expr.add]]. — *end note*]
+Two objects *a* and *b* are *pointer-interconvertible* if
 - they are the same object, or
 - one is a union object and the other is a non-static data member of
   that object [[class.union]], or
 - one is a standard-layout class object and the other is the first
 If two objects are pointer-interconvertible, then they have the same
 address, and it is possible to obtain a pointer to one from a pointer to
 the other via a `reinterpret_cast` [[expr.reinterpret.cast]].
+[*Note 5*: An array object and its first element are not
 pointer-interconvertible, even though they have the same
 address. — *end note*]
 A byte of storage *b* is *reachable through* a pointer value that points
 to an object *x* if there is an object *y*, pointer-interconvertible
 Each type other than a function or reference type is part of a group of
 four distinct, but related, types: a *cv-unqualified* version, a
 *const-qualified* version, a *volatile-qualified* version, and a
 *const-volatile-qualified* version. The types in each such group shall
 have the same representation and alignment requirements
+[[basic.align]].[^20]
 A function or reference type is always cv-unqualified.
 - A *const object* is an object of type `const T` or a non-mutable
   subobject of a const object.
 [[expr.arith.conv]]. — *end note*]
 Every floating-point type has a *floating-point conversion rank* defined
 as follows:
+- The rank of a floating-point type `T` is greater than the rank of any
   floating-point type whose set of values is a proper subset of the set
   of values of `T`.
 - The rank of `long double` is greater than the rank of `double`, which
   is greater than the rank of `float`.
 - Two extended floating-point types with the same set of values have
 - An extended floating-point type with the same set of values as exactly
   one cv-unqualified standard floating-point type has a rank equal to
   the rank of that standard floating-point type.
 - An extended floating-point type with the same set of values as more
   than one cv-unqualified standard floating-point type has a rank equal
+  to the rank of `double`.\begin{tailnote}
+  The treatment of \texttt{std::float64_t} differs from
+  that of the analogous \texttt{\_Float64} in C,
+  for example on platforms where all of
+  \texttt{\texttt{long} \texttt{double}},
+  \texttt{double}, and
+  \texttt{std::float64_t}
+  have the same set of values (see ISO/IEC 9899:2018 (C)H.4.3).
+  \end{tailnote}
 [*Note 2*: The conversion ranks of floating-point types `T1` and `T2`
 are unordered if the set of values of `T1` is neither a subset nor a
 superset of the set of values of `T2`. This can happen when one type has
 both a larger range and a lower precision than the other. — *end note*]

Diff to HTML by rtfpessoa