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

Files changed (1) hide show

tmp/tmperuyupca/{from.md → to.md} +58 -38

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

@@ -10,47 +10,54 @@ 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. For unsigned
-narrow character types, all possible bit patterns of the value
-representation represent numbers. 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, 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.
@@ -66,49 +73,62 @@ 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] There are no
-`signed`, `unsigned`, `short`, or `long bool` types or values. 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] this International Standard permits 2’s
-complement, 1’s complement and signed magnitude representations for
-integral types.
-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*. *Integral* and *floating* types are
-collectively called *arithmetic* types. Specializations of the standard
-template `std::numeric_limits` ([[support.limits]]) shall specify the
-maximum and minimum values of each arithmetic type for an
-implementation.
-The `void` type has an empty set of values. The `void` type is an
-incomplete type that cannot be completed. 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 `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 `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*)`.
-Even if the implementation defines two or more basic types to have the
-same value representation, they are nevertheless different types.

 `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.
 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*]

Diff to HTML by rtfpessoa