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

Files changed (1) hide show

tmp/tmpxbbnchrt/{from.md → to.md} +84 -66

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

@@ -7,11 +7,11 @@ objects ([[intro.object]]), references ([[dcl.ref]]), or functions (
 [[dcl.fct]]).
 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` or `unsigned` `char`.[^16] If the content of the
 array of `char` or `unsigned` `char` is copied back into the object, the
 object shall subsequently hold its original value.
 ``` cpp
 #define N sizeof(T)
@@ -24,11 +24,11 @@ std::memcpy(&obj, buf, N);      // at this point, each subobject of obj of scala
 ```
 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`,[^17] `obj2` shall subsequently
 hold the same value as `obj1`.
 ``` cpp
 T* t1p;
 T* t2p;
@@ -42,28 +42,29 @@ 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.[^18]
-A class that has been declared but not defined, or an array of unknown
-size or of incomplete element type, is an incompletely-defined object
-type.[^19] Incompletely-defined object types and the void types 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
 array of incomplete class type and therefore incomplete; if the class
 type is completed later on in the translation unit, the array type
 becomes complete; the array type at those two points is the same type.
 The declared type of an array object might be an array of unknown size
 and therefore be incomplete at one point in a translation unit and
 complete later on; the array types at those two points (“array of
-unknown bound of `T`” and “array of N `T`”) are different types. The
 type of a pointer to array of unknown size, or of a type defined by a
 `typedef` declaration to be an array of unknown size, cannot be
 completed.
 ``` cpp
@@ -102,37 +103,35 @@ Arithmetic types ([[basic.fundamental]]), enumeration types, pointer
 types, pointer to member types ([[basic.compound]]), `std::nullptr_t`,
 and cv-qualified versions of these types ([[basic.type.qualifier]]) are
 collectively called *scalar types*. Scalar types, POD classes (Clause
 [[class]]), arrays of such types and *cv-qualified* versions of these
 types ([[basic.type.qualifier]]) are collectively called *POD types*.
-Scalar types, trivially copyable class types (Clause  [[class]]), arrays
-of such types, and cv-qualified versions of these types (
-[[basic.type.qualifier]]) are collectively called *trivially copyable
-types*. Scalar types, trivial class types (Clause  [[class]]), arrays of
-such types and cv-qualified versions of these types (
-[[basic.type.qualifier]]) are collectively called *trivial types*.
-Scalar types, standard-layout class types (Clause  [[class]]), arrays of
-such types and cv-qualified versions of these types (
 [[basic.type.qualifier]]) are collectively called *standard-layout
 types*.
 A type is a *literal type* if it is:
 - a scalar type; or
-- a reference type referring to a literal type; or
 - an array of literal type; or
 - a class type (Clause  [[class]]) that has all of the following
   properties:
   - it has a trivial destructor,
-  - every constructor call and full-expression in the
-    *brace-or-equal-initializer*s for non-static data members (if any)
-    is a constant expression ([[expr.const]]),
   - it is an aggregate type ([[dcl.init.aggr]]) or has at least one
     `constexpr` constructor or constructor template that is not a copy
     or move constructor, and
-  - all of its non-static data members and base classes are of literal
-    types.
 If two types `T1` and `T2` are the same type, then `T1` and `T2` are
 *layout-compatible* types. Layout-compatible enumerations are described
 in  [[dcl.enum]]. Layout-compatible standard-layout structs and
 standard-layout unions are described in  [[class.mem]].
@@ -144,38 +143,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
@@ -183,34 +187,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
@@ -230,13 +236,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*)`.
@@ -265,16 +271,18 @@ Compound types can be constructed in the following ways:
 - *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* [^26] *class members*, 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]].
 The type of a pointer to `void` or a pointer to an object type is called
 an *object pointer type*. A pointer to `void` does not have a
 pointer-to-object type, however, because `void` is not an object type.
 The type of a pointer that can designate a function is called a
@@ -318,32 +326,33 @@ 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 term *object type* (
-[[intro.object]]) includes the cv-qualifiers specified when the object
-is created. The presence of a `const` specifier in a
-*decl-specifier-seq* declares an object of *const-qualified object
-type*; such object is called a *const object*. The presence of a
-`volatile` specifier in a *decl-specifier-seq* declares an object of
-*volatile-qualified* *object type*; such object is called a *volatile
-object*. The presence of both *cv-qualifiers* in a *decl-specifier-seq*
-declares an object of *const-volatile-qualified object type*; such
-object is called a *const volatile 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.types]]).[^27]
 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,
 not the array type ([[dcl.array]]).
-Each non-static, non-mutable, non-reference data member of a
-const-qualified class object is const-qualified, each non-static,
-non-reference data member of a volatile-qualified class object is
-volatile-qualified and similarly for members of a const-volatile class.
 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
@@ -365,9 +374,18 @@ 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. 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. Such array types can be said to be more (or less)
-cv-qualified than other types based on the cv-qualification of the
-underlying element types.

 [[dcl.fct]]).
 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` or `unsigned` `char`.[^18] If the content of the
 array of `char` or `unsigned` `char` is copied back into the object, the
 object shall subsequently hold its original value.
 ``` cpp
 #define N sizeof(T)
 ```
 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`.
 ``` cpp
 T* t1p;
 T* t2p;
 *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 size or of
+incomplete element type, is an *incompletely-defined object type*.[^21]
+Incompletely-defined object types and the void types 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
 array of incomplete class type and therefore incomplete; if the class
 type is completed later on in the translation unit, the array type
 becomes complete; the array type at those two points is the same type.
 The declared type of an array object might be an array of unknown size
 and therefore be incomplete at one point in a translation unit and
 complete later on; the array types at those two points (“array of
+unknown bound of `T`” and “array of `N` `T`”) are different types. The
 type of a pointer to array of unknown size, or of a type defined by a
 `typedef` declaration to be an array of unknown size, cannot be
 completed.
 ``` cpp
 types, pointer to member types ([[basic.compound]]), `std::nullptr_t`,
 and cv-qualified versions of these types ([[basic.type.qualifier]]) are
 collectively called *scalar types*. Scalar types, POD classes (Clause
 [[class]]), arrays of such types and *cv-qualified* versions of these
 types ([[basic.type.qualifier]]) are collectively called *POD types*.
+Cv-unqualified scalar types, trivially copyable class types (Clause
+[[class]]), arrays of such types, and non-volatile const-qualified
+versions of these types ([[basic.type.qualifier]]) are collectively
+called *trivially copyable types*. Scalar types, trivial class types
+(Clause  [[class]]), arrays of such types and cv-qualified versions of
+these types ([[basic.type.qualifier]]) are collectively called *trivial
+types*. Scalar types, standard-layout class types (Clause  [[class]]),
+arrays of such types and cv-qualified versions of these types (
 [[basic.type.qualifier]]) are collectively called *standard-layout
 types*.
 A type is a *literal type* if it is:
+- `void`; or
 - a scalar type; or
+- a reference type; or
 - an array of literal type; or
 - a class type (Clause  [[class]]) that has all of the following
   properties:
   - it has a trivial destructor,
   - it is an aggregate type ([[dcl.init.aggr]]) or has at least one
     `constexpr` constructor or constructor template that is not a copy
     or move constructor, and
+  - all of its non-static data members and base classes are of
+ non-volatile literal types.
 If two types `T1` and `T2` are the same type, then `T1` and `T2` are
 *layout-compatible* types. Layout-compatible enumerations are described
 in  [[dcl.enum]]. Layout-compatible standard-layout structs and
 standard-layout unions are described in  [[class.mem]].
 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*)`.
 - *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* [^28] *class members*, 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 `void` or a pointer to an object type is called
 an *object pointer type*. A pointer to `void` does not have a
 pointer-to-object type, however, because `void` is not an object type.
 The type of a pointer that can designate a function is called 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 term *object type* (
+[[intro.object]]) includes the cv-qualifiers 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]]).[^29]
 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,
 not the array 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
 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. 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.
+``` 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.

Diff to HTML by rtfpessoa