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

Files changed (1) hide show

tmp/tmp7w7dxbtb/{from.md → to.md} +312 -238

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

@@ -1,37 +1,38 @@
 ## Types <a id="basic.types">[[basic.types]]</a>
 [*Note 1*:  [[basic.types]] and the subclauses thereof impose
 requirements on implementations regarding the representation of types.
 There are two kinds of types: fundamental types and compound types.
-Types describe objects ([[intro.object]]), references ([[dcl.ref]]),
-or functions ([[dcl.fct]]). — *end note*]
-For any object (other than a base-class 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]]). [^18] If the content of that array is copied back into
-the object, the object shall subsequently hold its original value.
 [*Example 1*:
 ``` cpp
-#define N sizeof(T)
 char buf[N];
 T obj;                          // obj initialized to its original value
 std::memcpy(buf, &obj, N);      // between these two calls to std::memcpy, obj might be modified
 std::memcpy(&obj, buf, N);      // at this point, each subobject of obj of scalar type holds its original value
 ```
 — *end example*]
 For any trivially copyable type `T`, if two pointers to `T` point to
 distinct `T` objects `obj1` and `obj2`, where neither `obj1` nor `obj2`
-is a base-class subobject, if the underlying bytes ([[intro.memory]])
-making up `obj1` are copied into `obj2`,[^19] `obj2` shall subsequently
-hold the same value as `obj1`.
 [*Example 2*:
 ``` cpp
 T* t1p;
@@ -44,21 +45,23 @@ std::memcpy(t1p, t2p, sizeof(T));
 — *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 is the
-set of bits that hold the value of type `T`. 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.[^20]
 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*. [^21]
-Incompletely-defined object types and cv `void` are *incomplete types* (
-[[basic.fundamental]]). Objects shall not be defined to have an
 incomplete type.
 A class type (such as “`class X`”) might be incomplete at one point in a
 translation unit and complete later on; the type “`class X`” is the same
 type at both points. The declared type of an array object might be an
@@ -82,24 +85,24 @@ extern int arr[];               // the type of arr is incomplete
 typedef int UNKA[];             // UNKA is an incomplete type
 UNKA* arrp;                     // arrp is a pointer to an incomplete type
 UNKA** arrpp;
 void foo() {
-  xp++;                         // ill-formed: X is incomplete
-  arrp++;                       // ill-formed: incomplete type
   arrpp++;                      // OK: sizeof UNKA* is known
 }
 struct X { int i; };            // now X is a complete type
 int  arr[10];                   // now the type of arr is complete
 X x;
 void bar() {
   xp = &x;                      // OK; type is ``pointer to X''
-  arrp = &arr;                  // ill-formed: different types
   xp++;                         // OK:  X is complete
-  arrp++;                       // ill-formed: UNKA can't be completed
 }
 ```
 — *end example*]
@@ -107,375 +110,446 @@ void bar() {
 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, POD classes (Clause
-[[class]]), arrays of such types and cv-qualified versions of these
-types are collectively called *POD types*. Cv-unqualified scalar types,
-trivially copyable class types (Clause  [[class]]), arrays of such
-types, and cv-qualified versions of these types are collectively called
-*trivially copyable types*. Scalar types, trivial class types (Clause
-[[class]]), arrays of such types and cv-qualified versions of these
-types are collectively called *trivial types*. Scalar types,
-standard-layout class types (Clause  [[class]]), arrays of such types
-and cv-qualified versions of these types are collectively called
-*standard-layout types*.
 A type is a *literal type* if it is:
-- possibly cv-qualified `void`; or
 - a scalar type; or
 - a reference type; or
 - an array of literal type; or
-- a possibly cv-qualified class type (Clause  [[class]]) that has all of
- the following properties:
-  - it has a trivial destructor,
-  - it is either a closure type ([[expr.prim.lambda.closure]]), an
-    aggregate type ([[dcl.init.aggr]]), or has at least one constexpr
-    constructor or constructor template (possibly inherited (
-    [[namespace.udecl]]) from a base class) that is not a copy or move
     constructor,
   - if it is a union, at least one of its non-static data members is of
     non-volatile literal type, and
   - if it is not a union, all of its non-static data members and base
     classes are of non-volatile literal types.
 [*Note 3*: A literal type is one for which it might be possible to
 create an object within a constant expression. It is not a guarantee
 that it is possible to create such an object, nor is it a guarantee that
-any object of that type will usable in a constant
 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>
-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*]
 ### 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 (Clause
- [[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 (Clause
-  [[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. Each
-  distinct enumeration constitutes a different *enumerated type*,
   [[dcl.enum]];
-- *pointers to non-static class members*, [^28] which identify members
-  of a given type within objects of a given class,  [[dcl.mptr]].
 These methods of constructing types can be applied recursively;
-restrictions are mentioned in  [[dcl.ptr]], [[dcl.array]], [[dcl.fct]],
-and  [[dcl.ref]]. Constructing a type such that the number of bytes in
-its object representation exceeds the maximum value representable in the
-type `std::size_t` ([[support.types]]) is ill-formed.
 The type of a pointer to cv `void` or a pointer to an object type is
 called an *object pointer type*.
 [*Note 1*: A pointer to `void` does not have a pointer-to-object type,
 however, because `void` is not an object type. — *end note*]
 The type of a pointer that can designate a function is called a
-*function pointer type*. A pointer to objects of type `T` is referred to
-as a “pointer to `T`”.
 [*Example 1*: A pointer to an object of type `int` is referred to as
 “pointer to `int`” and a pointer to an object of class `X` is called a
 “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* ([[conv.ptr]]) 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 [^29] 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 that
 might be 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 element `x[n]`. 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 standard-layout 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
   non-static data member of that object, or, if the object has no
-  non-static data members, the first base class subobject of that
- object ([[class.mem]]), or
 - there exists an object *c* such that *a* and *c* are
   pointer-interconvertible, and *c* and *b* are
   pointer-interconvertible.
 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 pointer to cv-qualified ([[basic.type.qualifier]]) or cv-unqualified
-`void` can be used to point to objects of unknown type. Such a pointer
-shall be able to hold any object pointer. An object of type cv `void*`
-shall have the same representation and alignment requirements as
-cv `char*`.
 ### CV-qualifiers <a id="basic.type.qualifier">[[basic.type.qualifier]]</a>
 A type mentioned in  [[basic.fundamental]] and  [[basic.compound]] is a
 *cv-unqualified type*. Each type which is a cv-unqualified complete or
-incomplete object type or is `void` ([[basic.types]]) has three
 corresponding cv-qualified versions of its type: a *const-qualified*
 version, a *volatile-qualified* version, and a
-*const-volatile-qualified* version. The type of an object (
-[[intro.object]]) includes the *cv-qualifier*s specified in the
-*decl-specifier-seq* ([[dcl.spec]]), *declarator* (Clause
-[[dcl.decl]]), *type-id* ([[dcl.name]]), or *new-type-id* (
-[[expr.new]]) when the object is created.
 - A *const object* is an object of type `const T` or a non-mutable
-  subobject of such an object.
-- A *volatile object* is an object of type `volatile T`, a subobject of
- such an object, or a mutable subobject of a const volatile object.
 - A *const volatile object* is an object of type `const volatile T`, a
-  non-mutable subobject of such an object, a const subobject of a
-  volatile object, or a non-mutable volatile subobject of a const
   object.
 The cv-qualified or cv-unqualified versions of a type are distinct
 types; however, they shall have the same representation and alignment
-requirements ([[basic.align]]).[^30]
-A compound type ([[basic.compound]]) is not cv-qualified by the
-cv-qualifiers (if any) of the types from which it is compounded. Any
-cv-qualifiers applied to an array type affect the array element type (
-[[dcl.array]]).
-See  [[dcl.fct]] and  [[class.this]] regarding function types that have
-*cv-qualifier*s.
 There is a partial ordering on cv-qualifiers, so that a type can be said
-to be *more cv-qualified* than another. Table
-[[tab:relations.on.const.and.volatile]] shows the relations that
-constitute this ordering.
-**Table: Relations on `const` and `volatile`** <a id="tab:relations.on.const.and.volatile">[tab:relations.on.const.and.volatile]</a>
 |                 |     |                  |
 | --------------- | --- | ---------------- |
 | no cv-qualifier | <   | `const`          |
 | no cv-qualifier | <   | `volatile`       |
 | no cv-qualifier | <   | `const volatile` |
 | `const`         | <   | `const volatile` |
 | `volatile`      | <   | `const volatile` |
-In this International Standard, the notation cv (or *cv1*, *cv2*, etc.),
-used in the description of types, represents an arbitrary set of
-cv-qualifiers, i.e., one of {`const`}, {`volatile`}, {`const`,
-`volatile`}, or the empty set. For a type cv `T`, the *top-level
-cv-qualifiers* of that type are those denoted by cv.
-[*Example 1*: The type corresponding to the *type-id* `const int&` has
 no top-level cv-qualifiers. The type corresponding to the *type-id*
 `volatile int * const` has the top-level cv-qualifier `const`. For a
 class type `C`, the type corresponding to the *type-id*
 `void (C::* volatile)(int) const` has the top-level cv-qualifier
 `volatile`. — *end example*]
-Cv-qualifiers applied to an array type attach to the underlying element
-type, so the notation “cv `T`”, where `T` is an array type, refers to an
-array whose elements are so-qualified. An array type whose elements are
-cv-qualified is also considered to have the same cv-qualifications as
-its elements.
-[*Example 2*:
-``` cpp
-typedef char CA[5];
-typedef const char CC;
-CC arr1[5] = { 0 };
-const CA arr2 = { 0 };
-```
-The type of both `arr1` and `arr2` is “array of 5 `const char`”, and the
-array type is considered to be const-qualified.
-— *end example*]

 ## Types <a id="basic.types">[[basic.types]]</a>
 [*Note 1*:  [[basic.types]] and the subclauses thereof impose
 requirements on implementations regarding the representation of types.
 There are two kinds of types: fundamental types and compound types.
+Types describe objects [[intro.object]], references [[dcl.ref]], or
+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]]. [^18] If the content of that array is
+copied back into the object, the object shall subsequently hold its
+original value.
 [*Example 1*:
 ``` cpp
+constexpr std::size_t N = sizeof(T);
 char buf[N];
 T obj;                          // obj initialized to its original value
 std::memcpy(buf, &obj, N);      // between these two calls to std::memcpy, obj might be modified
 std::memcpy(&obj, buf, N);      // at this point, each subobject of obj of scalar type holds its original value
 ```
 — *end example*]
 For any trivially copyable type `T`, if two pointers to `T` point to
 distinct `T` objects `obj1` and `obj2`, where neither `obj1` nor `obj2`
+is a potentially-overlapping subobject, if the underlying bytes
+[[intro.memory]] making up `obj1` are copied into `obj2`,[^19] `obj2`
+shall subsequently hold the same value as `obj1`.
 [*Example 2*:
 ``` cpp
 T* t1p;
 — *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.[^20]
 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*. [^21]
+Incompletely-defined object types and cv `void` are *incomplete types*
+[[basic.fundamental]]. Objects shall not be defined to have an
 incomplete type.
 A class type (such as “`class X`”) might be incomplete at one point in a
 translation unit and complete later on; the type “`class X`” is the same
 type at both points. The declared type of an array object might be an
 typedef int UNKA[];             // UNKA is an incomplete type
 UNKA* arrp;                     // arrp is a pointer to an incomplete type
 UNKA** arrpp;
 void foo() {
+  xp++;                         // error: X is incomplete
+  arrp++;                       // error: incomplete type
   arrpp++;                      // OK: sizeof UNKA* is known
 }
 struct X { int i; };            // now X is a complete type
 int  arr[10];                   // now the type of arr is complete
 X x;
 void bar() {
   xp = &x;                      // OK; type is ``pointer to X''
+  arrp = &arr;                  // error: different types
   xp++;                         // OK:  X is complete
+  arrp++;                       // error: UNKA can't be completed
 }
 ```
 — *end example*]
 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]],
+  - it is either a closure type [[expr.prim.lambda.closure]], an
+    aggregate type [[dcl.init.aggr]], or has at least one constexpr
+    constructor or constructor template (possibly inherited
+    [[namespace.udecl]] from a base class) that is not a copy or move
     constructor,
   - if it is a union, at least one of its non-static data members is of
     non-volatile literal type, and
   - if it is not a union, all of its non-static data members and base
     classes are of non-volatile literal types.
 [*Note 3*: A literal type is one for which it might be possible to
 create an object within a constant expression. It is not a guarantee
 that it is possible to create such an object, nor is it a guarantee that
+any object of that type will be usable in a constant
 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*]
 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*]
 ### 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. Each
+  distinct enumeration constitutes a different *enumerated type*,
   [[dcl.enum]];
+- *pointers to non-static class members*, [^23] 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;
+restrictions are mentioned in  [[dcl.meaning]]. Constructing a type such
+that the number of bytes in its object representation exceeds the
+maximum value representable in the type `std::size_t` [[support.types]]
+is ill-formed.
 The type of a pointer to cv `void` or a pointer to an object type is
 called an *object pointer type*.
 [*Note 1*: A pointer to `void` does not have a pointer-to-object type,
 however, because `void` is not an object type. — *end note*]
 The type of a pointer that can designate a function is called a
+*function pointer type*. A pointer to an object of type `T` is referred
+to as a “pointer to `T`”.
 [*Example 1*: A pointer to an object of type `int` is referred to as
 “pointer to `int`” and a pointer to an object of class `X` is called a
 “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 [^24] 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 that
 might be 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
   non-static data member of that object, or, if the object has no
+  non-static data members, any base class subobject of that object
+  [[class.mem]], or
 - there exists an object *c* such that *a* and *c* are
   pointer-interconvertible, and *c* and *b* are
   pointer-interconvertible.
 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 pointer to cv `void` can be used to point to objects of unknown type.
+Such a pointer shall be able to hold any object pointer. An object of
+type cv `void*` shall have the same representation and alignment
+requirements as cv `char*`.
 ### CV-qualifiers <a id="basic.type.qualifier">[[basic.type.qualifier]]</a>
 A type mentioned in  [[basic.fundamental]] and  [[basic.compound]] is a
 *cv-unqualified type*. Each type which is a cv-unqualified complete or
+incomplete object type or is `void` [[basic.types]] has three
 corresponding cv-qualified versions of its type: a *const-qualified*
 version, a *volatile-qualified* version, and a
+*const-volatile-qualified* version. The type of an object
+[[intro.object]] includes the *cv-qualifier*s specified in the
+*decl-specifier-seq* [[dcl.spec]], *declarator* [[dcl.decl]], *type-id*
+[[dcl.name]], or *new-type-id* [[expr.new]] when the object is created.
 - A *const object* is an object of type `const T` or a non-mutable
+  subobject of a const object.
+- A *volatile object* is an object of type `volatile T` or a subobject
+  of a volatile object.
 - A *const volatile object* is an object of type `const volatile T`, a
+  non-mutable subobject of a const volatile object, a const subobject of
+ a volatile object, or a non-mutable volatile subobject of a const
   object.
 The cv-qualified or cv-unqualified versions of a type are distinct
 types; however, they shall have the same representation and alignment
+requirements [[basic.align]].[^25]
+Except for array types, a compound type [[basic.compound]] is not
+cv-qualified by the cv-qualifiers (if any) of the types from which it is
+compounded.
+An array type whose elements are cv-qualified is also considered to have
+the same cv-qualifications as its elements.
+[*Note 1*: Cv-qualifiers applied to an array type attach to the
+underlying element type, so the notation “cv `T`”, where `T` is an array
+type, refers to an array whose elements are so-qualified
+[[dcl.array]]. — *end note*]
+[*Example 1*:
+``` cpp
+typedef char CA[5];
+typedef const char CC;
+CC arr1[5] = { 0 };
+const CA arr2 = { 0 };
+```
+The type of both `arr1` and `arr2` is “array of 5 `const char`”, and the
+array type is considered to be const-qualified.
+— *end example*]
+[*Note 2*: See  [[dcl.fct]] and  [[class.this]] regarding function
+types that have *cv-qualifier*s. — *end note*]
 There is a partial ordering on cv-qualifiers, so that a type can be said
+to be *more cv-qualified* than another. [[basic.type.qualifier.rel]]
+shows the relations that constitute this ordering.
+**Table: Relations on `const` and `volatile`** <a id="basic.type.qualifier.rel">[basic.type.qualifier.rel]</a>
 |                 |     |                  |
 | --------------- | --- | ---------------- |
 | no cv-qualifier | <   | `const`          |
 | no cv-qualifier | <   | `volatile`       |
 | no cv-qualifier | <   | `const volatile` |
 | `const`         | <   | `const volatile` |
 | `volatile`      | <   | `const volatile` |
+In this document, the notation cv (or *cv1*, *cv2*, etc.), used in the
+description of types, represents an arbitrary set of cv-qualifiers,
+i.e., one of {`const`}, {`volatile`}, {`const`, `volatile`}, or the
+empty set. For a type cv `T`, the *top-level cv-qualifiers* of that type
+are those denoted by cv.
+[*Example 2*: The type corresponding to the *type-id* `const int&` has
 no top-level cv-qualifiers. The type corresponding to the *type-id*
 `volatile int * const` has the top-level cv-qualifier `const`. For a
 class type `C`, the type corresponding to the *type-id*
 `void (C::* volatile)(int) const` has the top-level cv-qualifier
 `volatile`. — *end example*]
+### Integer conversion rank <a id="conv.rank">[[conv.rank]]</a>
+Every integer type has an *integer conversion rank* defined as follows:
+- No two signed integer types other than `char` and `signed
+  char` (if `char` is signed) shall have the same rank, even if they
+  have the same representation.
+- The rank of a signed integer type shall be greater than the rank of
+  any signed integer type with a smaller width.
+- The rank of `long long int` shall be greater than the rank of
+  `long int`, which shall be greater than the rank of `int`, which shall
+  be greater than the rank of `short int`, which shall be greater than
+  the rank of `signed char`.
+- The rank of any unsigned integer type shall equal the rank of the
+  corresponding signed integer type.
+- The rank of any standard integer type shall be greater than the rank
+  of any extended integer type with the same width.
+- The rank of `char` shall equal the rank of `signed char` and
+  `unsigned char`.
+- The rank of `bool` shall be less than the rank of all other standard
+  integer types.
+- The ranks of `char8_t`, `char16_t`, `char32_t`, and `wchar_t` shall
+  equal the ranks of their underlying types [[basic.fundamental]].
+- The rank of any extended signed integer type relative to another
+  extended signed integer type with the same width is
+  *implementation-defined*, but still subject to the other rules for
+  determining the integer conversion rank.
+- For all integer types `T1`, `T2`, and `T3`, if `T1` has greater rank
+  than `T2` and `T2` has greater rank than `T3`, then `T1` shall have
+  greater rank than `T3`.
+[*Note 1*: The integer conversion rank is used in the definition of the
+integral promotions [[conv.prom]] and the usual arithmetic conversions
+[[expr.arith.conv]]. — *end note*]

Diff to HTML by rtfpessoa