[basic.fundamental] - C++20 → C++23

Files changed (1) hide show

tmp/tmpe048n5ml/{from.md → to.md} +55 -43

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

@@ -31,32 +31,32 @@ 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.[^22]
 [*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*]
 **Table: Minimum width** <a id="basic.fundamental.width">[basic.fundamental.width]</a>
 | Type            | Minimum width $N$ |
-| ------------- | ----------------- |
 | `signed char`   | 8                 |
-| `short` | 16                |
 | `int`           | 16                |
-| `long` | 32                |
-| `long long` | 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]] 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*]
@@ -83,30 +83,25 @@ representation, alignment requirements [[basic.align]], and range of
 representable values as the underlying type. Further, each value has the
 same representation in both types.
 Type `char` is a distinct type that has an *implementation-defined*
 choice of “`signed char`” or “`unsigned char`” as its underlying type.
-The values of type `char` can represent distinct codes for all members
-of the implementation’s basic character set. The three types `char`,
-`signed char`, and `unsigned char` are collectively called *ordinary
-character types*. The ordinary character types and `char8_t` are
-collectively called *narrow character types*. For narrow character
-types, each possible bit pattern of the object representation represents
-a distinct value.
 [*Note 5*: This requirement does not hold for other
 types. — *end note*]
 [*Note 6*: A bit-field of narrow character type whose width is larger
 than the width of that type has padding bits; see
-[[basic.types]]. — *end note*]
 Type `wchar_t` is a distinct type that has an *implementation-defined*
-signed or unsigned integer type as its underlying type. The values of
-type `wchar_t` can represent distinct codes for all members of the
-largest extended character set specified among the supported locales
-[[locale]].
 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>`.
@@ -117,53 +112,70 @@ value representation, and alignment requirements as an
 `bool` are `true` and `false`.
 [*Note 7*: There are no `signed`, `unsigned`, `short`, or `long bool`
 types or values. — *end note*]
-Types `bool`, `char`, `wchar_t`, `char8_t`, `char16_t`, `char32_t`, and
-the signed and unsigned integer types are collectively called *integral
 types*. A synonym for integral type is *integer type*.
 [*Note 8*: Enumerations [[dcl.enum]] are not integral; however,
 unscoped enumerations can be promoted to integral types as specified in
 [[conv.prom]]. — *end note*]
-There are three *floating-point types*: `float`, `double`, and
-`long double`. The type `double` provides at least as much precision as
-`float`, and the type `long double` provides at least as much precision
-as `double`. The set of values of the type `float` is a subset of the
-set of values of the type `double`; the set of values of the type
-`double` is a subset of the set of values of the type `long double`. The
-value representation of floating-point types is
 *implementation-defined*.
-[*Note 9*: This document imposes no requirements on the accuracy of
-floating-point operations; see also  [[support.limits]]. — *end note*]
-Integral and floating-point types are collectively called *arithmetic*
-types. Specializations of the standard library template
-`std::numeric_limits` [[support.limits]] shall specify the maximum and
-minimum values of each arithmetic type for an implementation.
 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 10*: Even if the implementation defines two or more fundamental
 types to have the same value representation, they are nevertheless
 different types. — *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*]
 **Table: Minimum width** <a id="basic.fundamental.width">[basic.fundamental.width]</a>
 | Type            | Minimum width $N$ |
+| --------------- | ----------------- |
 | `signed char`   | 8                 |
+| `short int` | 16                |
 | `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*]
 representable values as the underlying type. Further, each value has the
 same representation in both types.
 Type `char` is a distinct type that has an *implementation-defined*
 choice of “`signed char`” or “`unsigned char`” as its underlying type.
+The three types `char`, `signed char`, and `unsigned char` are
+collectively called *ordinary character types*. The ordinary character
+types and `char8_t` are collectively called *narrow character types*.
+For narrow character types, each possible bit pattern of the object
+representation represents a distinct value.
 [*Note 5*: This requirement does not hold for other
 types. — *end note*]
 [*Note 6*: A bit-field of narrow character type whose width is larger
 than the width of that type has padding bits; see
+[[basic.types.general]]. — *end note*]
 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>`.
 `bool` are `true` and `false`.
 [*Note 7*: There are no `signed`, `unsigned`, `short`, or `long bool`
 types or values. — *end note*]
+The types `char`, `wchar_t`, `char8_t`, `char16_t`, and `char32_t` are
+collectively called *character types*. The character types, `bool`, the
+signed and unsigned integer types, and cv-qualified versions
+[[basic.type.qualifier]] thereof, are collectively termed *integral
 types*. A synonym for integral type is *integer type*.
 [*Note 8*: Enumerations [[dcl.enum]] are not integral; however,
 unscoped enumerations can be promoted to integral types as specified in
 [[conv.prom]]. — *end note*]
+The three distinct types `float`, `double`, and `long double` can
+represent floating-point numbers. The type `double` provides at least as
+much precision as `float`, and the type `long double` provides at least
+as much precision as `double`. The set of values of the type `float` is
+a subset of the set of values of the type `double`; the set of values of
+the type `double` is a subset of the set of values of the type
+`long double`. The types `float`, `double`, and `long double`, and
+cv-qualified versions [[basic.type.qualifier]] thereof, are collectively
+termed *standard floating-point types*. An implementation may also
+provide additional types that represent floating-point values and define
+them (and cv-qualified versions thereof) to be *extended floating-point
+types*. The standard and extended floating-point types are collectively
+termed *floating-point types*.
+[*Note 9*: Any additional implementation-specific types representing
+floating-point values that are not defined by the implementation to be
+extended floating-point types are not considered to be floating-point
+types, and this document imposes no requirements on them or their
+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*]

Diff to HTML by rtfpessoa