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

Files changed (1) hide show

tmp/tmpgpvsp_1m/{from.md → to.md} +135 -100

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

@@ -1,134 +1,169 @@
 ### Fundamental types <a id="basic.fundamental">[[basic.fundamental]]</a>
-Objects declared as characters (`char`) shall be large enough to store
-any member of the implementation’s basic character set. If a character
-from this set is stored in a character object, the integral value of
-that character object is equal to the value of the single character
-literal form of that character. It is *implementation-defined* whether a
-`char` object can hold negative values. Characters can be explicitly
-declared `unsigned` or `signed`. Plain `char`, `signed char`, and
-`unsigned char` are three distinct types, collectively called *narrow
-character types*. A `char`, a `signed char`, and an `unsigned char`
-occupy the same amount of storage and have the same alignment
-requirements ([[basic.align]]); that is, they have the same object
-representation. For narrow character types, all bits of the object
-representation participate in the value representation.
-[*Note 1*: A bit-field of narrow character type whose length is larger
-than the number of bits in the object representation of that type has
-padding bits; see  [[class.bit]]. — *end note*]
-For unsigned narrow character types, each possible bit pattern of the
-value representation represents a distinct number. These requirements do
-not hold for other types. In any particular implementation, a plain
-`char` object can take on either the same values as a `signed char` or
-an `unsigned
-char`; which one is *implementation-defined*. For each value *i* of type
-`unsigned char` in the range 0 to 255 inclusive, there exists a value
-*j* of type `char` such that the result of an integral conversion (
-[[conv.integral]]) from *i* to `char` is *j*, and the result of an
-integral conversion from *j* to `unsigned char` is *i*.
 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*. Plain `int`s have the
-natural size suggested by the architecture of the execution environment
-[^22]; the other signed integer types are provided to meet special
-needs.
 For each of the standard signed integer types, there exists a
 corresponding (but different) *standard unsigned integer type*:
 “`unsigned char`”, “`unsigned short int`”, “`unsigned int`”,
-“`unsigned long int`”, and “`unsigned long long int`”, each of which
-occupies the same amount of storage and has the same alignment
-requirements ([[basic.align]]) as the corresponding signed integer
-type[^23]; that is, each signed integer type has the same object
-representation as its corresponding unsigned integer type. Likewise, for
-each of the extended signed integer types there exists a corresponding
-*extended unsigned integer type* with the same amount of storage and
-alignment requirements. The standard and extended unsigned integer types
-are collectively called *unsigned integer types*. The range of
-non-negative values of a signed integer type is a subrange of the
-corresponding unsigned integer type, the representation of the same
-value in each of the two types is the same, and the value representation
-of each corresponding signed/unsigned type shall be the same. The
-standard signed integer types and standard unsigned integer types are
-collectively called the *standard integer types*, and the extended
-signed integer types and extended unsigned integer types are
-collectively called the *extended integer types*. The signed and
-unsigned integer types shall satisfy the constraints given in the C
-standard, section 5.2.4.2.1.
-Unsigned integers shall obey the laws of arithmetic modulo 2ⁿ where n is
-the number of bits in the value representation of that particular size
-of integer.[^24]
-Type `wchar_t` is a distinct type whose values can represent distinct
-codes for all members of the largest extended character set specified
-among the supported locales ([[locale]]). Type `wchar_t` shall have the
-same size, signedness, and alignment requirements ([[basic.align]]) as
-one of the other integral types, called its *underlying type*. Types
-`char16_t` and `char32_t` denote distinct types with the same size,
-signedness, and alignment as `uint_least16_t` and `uint_least32_t`,
-respectively, in `<cstdint>`, called the underlying types.
-Values of type `bool` are either `true` or `false`.[^25]
-[*Note 2*: There are no `signed`, `unsigned`, `short`, or `long bool`
 types or values. — *end note*]
-Values of type `bool` participate in integral promotions (
-[[conv.prom]]).
-Types `bool`, `char`, `char16_t`, `char32_t`, `wchar_t`, and the signed
-and unsigned integer types are collectively called *integral*
-types.[^26] A synonym for integral type is *integer type*. The
-representations of integral types shall define values by use of a pure
-binary numeration system.[^27]
-[*Example 1*: This International Standard permits two’s complement,
-ones’ complement and signed magnitude representations for integral
-types. — *end example*]
-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 3*: This International Standard imposes no requirements on the
-accuracy of floating-point operations; see also
-[[support.limits]]. — *end note*]
-Integral and floating 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.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*)`.
-[*Note 4*: Even if the implementation defines two or more basic types
-to have the same value representation, they are nevertheless different
-types. — *end note*]

 ### 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*]
 For each of the standard signed integer types, there exists a
 corresponding (but different) *standard unsigned integer type*:
 “`unsigned char`”, “`unsigned short int`”, “`unsigned int`”,
+“`unsigned long int`”, and “`unsigned long long int`”. Likewise, for
+each of the extended signed integer types, there exists a corresponding
+*extended unsigned integer type*. The standard and extended unsigned
+integer types are collectively called *unsigned integer types*. An
+unsigned integer type has the same width *N* as the corresponding signed
+integer type. The range of representable values for the unsigned type is
+0 to 2ᴺ-1 (inclusive); arithmetic for the unsigned type is performed
+modulo 2ᴺ.
+[*Note 2*: Unsigned arithmetic does not overflow. Overflow for signed
+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*]
+[*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
+representation $x = x_0 2^0 + x_1 2^1 + \ldots + x_{N-1} 2^{N-1}$, where
+each coefficient xᵢ is either 0 or 1; this is called the *base-2
+representation* of x. The base-2 representation of a value of signed
+integer type is the base-2 representation of the congruent value of the
+corresponding unsigned integer type. The standard signed integer types
+and standard unsigned integer types are collectively called the
+*standard integer types*, and the extended signed integer types and
+extended unsigned integer types are collectively called the *extended
+integer types*.
+A fundamental type specified to have a signed or unsigned integer type
+as its *underlying type* has the same object representation, value
+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>`.
+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`.
+[*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*]

Diff to HTML by rtfpessoa