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

Files changed (1) hide show

tmp/tmpj4m3gu7t/{from.md → to.md} +29 -22

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

@@ -5,38 +5,43 @@ 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. 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 character types, all bits of the object
 representation participate in the value representation. For unsigned
-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*.
 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[^20]; 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[^21]; 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
@@ -44,34 +49,36 @@ 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*.
-Unsigned integers, declared `unsigned`, 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.[^22]
 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 `<stdint.h>`, called the underlying types.
-Values of type `bool` are either `true` or `false`.[^23] 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.[^24] A synonym for integral type is *integer type*. The
 representations of integral types shall define values by use of a pure
-binary numeration system.[^25] 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
@@ -91,13 +98,13 @@ 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` 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*)`.

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

Diff to HTML by rtfpessoa