[dcl.array] Consolidate redundant, repetitive, and somewhat incorrect

examples and notes on multidimensional arrays.

Fixes #1645

Author: zygoloid

source/declarators.tex

@@ -1058,8 +1058,10 @@
 or from another array.
 
 \pnum
-When several ``array of'' specifications are adjacent, a multidimensional
-array type is created;
+\indextext{declarator!multidimensional 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.
@@ -1088,7 +1090,6 @@
 
 \pnum
 \begin{example}
-\indextext{example!subscripting}%
 \indextext{example!array}%
 \begin{codeblock}
 float fa[17], *afp[17];
@@ -1100,27 +1101,73 @@
 pointers to
 \tcode{float}
 numbers.
-\indextext{declarator!multidimensional array}%
-For another example,
+\end{example}
 
+\pnum
+\begin{example}
 \begin{codeblock}
-static int x3d[3][5][7];
+int x3d[3][5][7];
 \end{codeblock}
 
-declares a static three-dimensional array of integers,
+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 \times 5 \times 7$.
-In complete detail,
-\tcode{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
 \tcode{x3d},
 \tcode{x3d[i]},
 \tcode{x3d[i][j]},
 \tcode{x3d[i][j][k]}
-can reasonably appear in an expression. Finally,
+can reasonably appear in an expression.
+\indextext{example!subscripting}%
+The expression
+\tcode{x3d[i]}
+is equivalent to
+\tcode{*(x3d + i)};
+in that expression,
+\tcode{x3d} 
+is subject to the array-to-pointer conversion\iref{conv.array}
+and is first converted to
+a pointer to a 2-dimensional
+array with rank
+$5 \times 7$
+that points to the first element of \tcode{x3d}.
+Then \tcode{i} is added,
+which on typical implementations involves multiplying
+\tcode{i} by the
+length of the object to which the pointer points,
+which is \tcode{sizeof(int)}$ \times 5 \times 7$.
+The result of the addition and indirection is
+an lvalue denoting
+the \tcode{i}\textsuperscript{th} array element of
+\tcode{x3d}
+(an array of five arrays of seven integers).
+If there is another subscript,
+the same argument applies again, so
+\tcode{x3d[i][j]} is
+an lvalue denoting
+the \tcode{j}\textsuperscript{th} array element of
+the \tcode{i}\textsuperscript{th} array element of
+\tcode{x3d}
+(an array of seven integers), and
+\tcode{x3d[i][j][k]} is
+an lvalue denoting
+the \tcode{k}\textsuperscript{th} array element of
+the \tcode{j}\textsuperscript{th} array element of
+the \tcode{i}\textsuperscript{th} array element of
+\tcode{x3d}
+(an integer).
+\end{example}
+\begin{note}
+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}
+
+\pnum
+\begin{example}
 \begin{codeblock}
 extern int x[10];
 struct S {
@@ -1172,80 +1219,6 @@
 appearance, subscripting is a commutative operation.
 \end{note}
 
-\pnum
-\begin{note}
-A consistent rule is followed for
-\indextext{array!multidimensional}%
-multidimensional arrays.
-If
-\tcode{E}
-is an
-\textit{n}-dimensional
-array
-of rank
-$i \times j \times \dotsb \times k$,
-then
-\tcode{E}
-appearing in an expression
-that is subject to the array-to-pointer conversion\iref{conv.array}
-is converted to
-a pointer to an $(n-1)$-dimensional
-array with rank
-$j \times \dotsb \times k$.
-If the
-\tcode{*}
-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.
-\begin{example}
-Consider
-
-\begin{codeblock}
-int x[3][5];
-\end{codeblock}
-
-Here
-\tcode{x}
-is a $3 \times 5$ array of integers.
-When
-\tcode{x}
-appears in an expression, it is converted
-to a pointer to (the first of three) five-membered arrays of integers.
-In the expression
-\tcode{x[i]}
-which is equivalent to
-\tcode{*(x+i)},
-\tcode{x}
-is first converted to a pointer as described;
-then
-\tcode{x+i}
-is converted to the type of
-\tcode{x},
-which involves multiplying
-\tcode{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}
-
-\pnum
-\begin{note}
-It follows from all this that arrays in \Cpp are stored
-row-wise (last subscript varies fastest)
-\indextext{array!storage of}%
-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}
-
 \rSec2[dcl.fct]{Functions}%
 \indextext{declarator!function|(}