[dcl.array] - C++17 → C++20

Files changed (1) hide show

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

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

@@ -1,88 +1,93 @@
-### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-'D1 [' constant-expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
 ```
-and the type of the identifier in the declaration `T` `D1` is
-“*derived-declarator-type-list* `T`”, then the type of the identifier of
-`D` is an array type; if the type of the identifier of `D` contains the
-`auto` *type-specifier*, the program is ill-formed. `T` is called the
-array *element type*; this type shall not be a reference type,
-cv `void`, a function type or an abstract class type. If the
-*constant-expression* ([[expr.const]]) is present, it shall be a
-converted constant expression of type `std::size_t` and its value shall
-be greater than zero. The constant expression specifies the *bound* of
-(number of elements in) the array. If the value of the constant
-expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
-the type of the identifier of `D` is “*derived-declarator-type-list*
-array of `N` `T`”. An object of array type contains a contiguously
-allocated non-empty set of `N` subobjects of type `T`. Except as noted
-below, if the constant expression is omitted, the type of the identifier
-of `D` is “*derived-declarator-type-list* array of unknown bound of
-`T`”, an incomplete object type. The type
-“*derived-declarator-type-list* array of `N` `T`” is a different type
-from the type “*derived-declarator-type-list* array of unknown bound of
-`T`”, see  [[basic.types]]. Any type of the form “*cv-qualifier-seq*
-array of `N` `T`” is adjusted to “array of `N` *cv-qualifier-seq* `T`”,
-and similarly for “array of unknown bound of `T`”. The optional
-*attribute-specifier-seq* appertains to the array.
 [*Example 1*:
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
 — *end example*]
-[*Note 1*: An “array of `N` *cv-qualifier-seq* `T`” has cv-qualified
 type; see  [[basic.type.qualifier]]. — *end note*]
-An array can be constructed from one of the fundamental types (except
-`void`), from a pointer, from a pointer to member, from a class, from an
-enumeration type, or from another array.
-When several “array of” specifications are adjacent, a multidimensional
-array type is created; only the first of the constant expressions that
-specify the bounds of the arrays may be omitted. In addition to
-declarations in which an incomplete object type is allowed, an array
-bound may be omitted in some cases in the declaration of a function
-parameter ([[dcl.fct]]). An array bound may also be omitted when the
-declarator is followed by an *initializer* ([[dcl.init]]) or when a
-declarator for a static data member is followed by a
-*brace-or-equal-initializer* ([[class.mem]]). In both cases the bound
-is calculated from the number of initial elements (say, `N`) supplied (
-[[dcl.init.aggr]]), and the type of the identifier of `D` is “array of
-`N` `T`”. Furthermore, if there is a preceding declaration of the entity
-in the same scope in which the bound was specified, an omitted array
-bound is taken to be the same as in that earlier declaration, and
-similarly for the definition of a static data member of a class.
-[*Example 2*:
-``` cpp
-float fa[17], *afp[17];
-```
-declares an array of `float` numbers and an array of pointers to `float`
-numbers. For another example,
-``` cpp
-static int x3d[3][5][7];
-```
-declares a static three-dimensional array of integers, with rank
-3 × 5 × 7. In complete detail, `x3d` is an array of three items; each
-item is an array of five arrays; each of the latter arrays is an array
-of seven integers. Any of the expressions `x3d`, `x3d[i]`, `x3d[i][j]`,
-`x3d[i][j][k]` can reasonably appear in an expression. Finally,
 ``` cpp
 extern int x[10];
 struct S {
   static int y[10];
@@ -97,56 +102,51 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 2*: Conversions affecting expressions of array type are
-described in  [[conv.array]]. Objects of array types cannot be modified,
-see  [[basic.lval]]. — *end note*]
-[*Note 3*: Except where it has been declared for a class (
-[[over.sub]]), the subscript operator `[]` is interpreted in such a way
-that `E1[E2]` is identical to `*((E1)+(E2))` ([[expr.sub]]). Because of
-the conversion rules that apply to `+`, if `E1` is an array and `E2` an
-integer, then `E1[E2]` refers to the `E2`-th member of `E1`. Therefore,
-despite its asymmetric appearance, subscripting is a commutative
-operation. — *end note*]
-[*Note 4*:
-A consistent rule is followed for multidimensional arrays. If `E` is an
-*n*-dimensional array of rank i × j × … × k, then `E` appearing in an
-expression that is subject to the array-to-pointer conversion (
-[[conv.array]]) is converted to a pointer to an (n-1)-dimensional array
-with rank j × … × k. If the `*` operator, either explicitly or
-implicitly as a result of subscripting, is applied to this pointer, the
-result is the pointed-to (n-1)-dimensional array, which itself is
-immediately converted into a pointer.
-[*Example 3*:
-Consider
 ``` cpp
-int x[3][5];
 ```
-Here `x` is a 3 × 5 array of integers. When `x` appears in an
-expression, it is converted to a pointer to (the first of three)
-five-membered arrays of integers. In the expression `x[i]` which is
-equivalent to `*(x+i)`, `x` is first converted to a pointer as
-described; then `x+i` is converted to the type of `x`, which involves
-multiplying `i` by the length of the object to which the pointer points,
-namely five integer objects. The results are added and indirection
-applied to yield an array (of five integers), which in turn is converted
-to a pointer to the first of the integers. If there is another subscript
-the same argument applies again; this time the result is an integer.
 — *end example*]
 — *end note*]
-[*Note 5*: It follows from all this that arrays in C++are stored
-row-wise (last subscript varies fastest) and that the first subscript in
-the declaration helps determine the amount of storage consumed by an
-array but plays no other part in subscript calculations. — *end note*]

+#### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+'D1' '[' constant-expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
 ```
+and the type of the contained *declarator-id* in the declaration `T`
+`D1` is “*derived-declarator-type-list* `T`”, the type of the
+*declarator-id* in `D` is “*derived-declarator-type-list* array of `N`
+`T`”. The *constant-expression* shall be a converted constant expression
+of type `std::size_t` [[expr.const]]. Its value `N` specifies the *array
+bound*, i.e., the number of elements in the array; `N` shall be greater
+than zero.
+In a declaration `T` `D` where `D` has the form
+``` bnf
+'D1 [ ]' attribute-specifier-seqₒₚₜ
+```
+and the type of the contained *declarator-id* in the declaration `T`
+`D1` is “*derived-declarator-type-list* `T`”, the type of the
+*declarator-id* in `D` is “*derived-declarator-type-list* array of
+unknown bound of `T`”, except as specified below.
+A type of the form “array of `N` `U`” or “array of unknown bound of `U`”
+is an *array type*. The optional *attribute-specifier-seq* appertains to
+the array type.
+`U` is called the array *element type*; this type shall not be a
+placeholder type [[dcl.spec.auto]], a reference type, a function type,
+an array of unknown bound, or cv `void`.
+[*Note 1*: An array can be constructed from one of the fundamental
+types (except `void`), from a pointer, from a pointer to member, from a
+class, from an enumeration type, or from an array of known
+bound. — *end note*]
 [*Example 1*:
+``` cpp
+float fa[17], *afp[17];
+```
+declares an array of `float` numbers and an array of pointers to `float`
+numbers.
+— *end example*]
+Any type of the form “*cv-qualifier-seq* array of `N` `U`” is adjusted
+to “array of `N` *cv-qualifier-seq* `U`”, and similarly for “array of
+unknown bound of `U`”.
+[*Example 2*:
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
 — *end example*]
+[*Note 2*: An “array of `N` *cv-qualifier-seq* `U`” has cv-qualified
 type; see  [[basic.type.qualifier]]. — *end note*]
+An object of type “array of `N` `U`” contains a contiguously allocated
+non-empty set of `N` subobjects of type `U`, known as the *elements* of
+the array, and numbered `0` to `N-1`.
+In addition to declarations in which an incomplete object type is
+allowed, an array bound may be omitted in some cases in the declaration
+of a function parameter [[dcl.fct]]. An array bound may also be omitted
+when an object (but not a non-static data member) of array type is
+initialized and the declarator is followed by an initializer (
+[[dcl.init]], [[class.mem]], [[expr.type.conv]], [[expr.new]]). In these
+cases, the array bound is calculated from the number of initial elements
+(say, `N`) supplied [[dcl.init.aggr]], and the type of the array is
+“array of `N` `U`”.
+Furthermore, if there is a preceding declaration of the entity in the
+same scope in which the bound was specified, an omitted array bound is
+taken to be the same as in that earlier declaration, and similarly for
+the definition of a static data member of a class.
+[*Example 3*:
 ``` cpp
 extern int x[10];
 struct S {
   static int y[10];
 }
 ```
 — *end example*]
+[*Note 3*:
+When several “array of” specifications are adjacent, a multidimensional
+array type is created; only the first of the constant expressions that
+specify the bounds of the arrays may be omitted.
+[*Example 4*:
 ``` cpp
+int x3d[3][5][7];
 ```
+declares an array of three elements, each of which is an array of five
+elements, each of which is an array of seven integers. The overall array
+can be viewed as a three-dimensional array of integers, with rank
+3 × 5 × 7. Any of the expressions `x3d`, `x3d[i]`, `x3d[i][j]`,
+`x3d[i][j][k]` can reasonably appear in an expression. The expression
+`x3d[i]` is equivalent to `*(x3d + i)`; in that expression, `x3d` is
+subject to the array-to-pointer conversion [[conv.array]] and is first
+converted to a pointer to a 2-dimensional array with rank 5 × 7 that
+points to the first element of `x3d`. Then `i` is added, which on
+typical implementations involves multiplying `i` by the length of the
+object to which the pointer points, which is `sizeof(int)`× 5 × 7. The
+result of the addition and indirection is an lvalue denoting the `i`ᵗʰ
+array element of `x3d` (an array of five arrays of seven integers). If
+there is another subscript, the same argument applies again, so
+`x3d[i][j]` is an lvalue denoting the `j`ᵗʰ array element of the `i`ᵗʰ
+array element of `x3d` (an array of seven integers), and `x3d[i][j][k]`
+is an lvalue denoting the `k`ᵗʰ array element of the `j`ᵗʰ array element
+of the `i`ᵗʰ array element of `x3d` (an integer).
 — *end example*]
+The first subscript in the declaration helps determine the amount of
+storage consumed by an array but plays no other part in subscript
+calculations.
 — *end note*]
+[*Note 4*: Conversions affecting expressions of array type are
+described in  [[conv.array]]. — *end note*]
+[*Note 5*: The subscript operator can be overloaded for a class
+[[over.sub]]. For the operator’s built-in meaning, see
+[[expr.sub]]. — *end note*]

Diff to HTML by rtfpessoa