Why are 2-D arrays reversed?

Mike Parker aldacron at gmail.com
Wed Oct 10 13:38:53 UTC 2018


On Wednesday, 10 October 2018 at 13:22:41 UTC, Chris Katko wrote:
> int[][] data =
> 	[
> 		[1, 0, 1, 0, 0],
> 		[1, 0, 1, 0, 0],
> 		[1, 0, 1, 1, 1],
> 		[1, 0, 0, 1, 0],
> 		[5, 1, 1, 1, 0]
> 	];
>
> when drawn with data[i][j], prints the transpose of "data":
>
> [1, 1, 1, 1, 5]
> [0, 0, 0, 0, 1]
> [1, 1, 1, 0, 1]
> [0, 0, 1, 1, 1]
> [0, 0, 1, 0, 0]
>
> So, if I flip [i][j] and print a row of "j's", it'll be 
> correct. It's very confusing and counter-intuitive to have to 
> remember to swap i and j every time I use an array.
>
> I guess when I load data from files, the i/j are already 
> swapped and stay consistent, but when using an array in source 
> code, they have to be flipped.

What you actually have there is an array of arrays, or a jagged 
array, and not a 2D, or multidimensional, array. If you dig into 
it, it's consistent with how array syntax works with all types. 
Consider the basics:

int i;
int[] intArray;

The type of `i` is `int`. If I want an array of ints, I put the 
brackets next to the type.

The type of `intArray` is `int[]`, but it contains elements of 
type `int`. We can visualize it with parens:

(int)[];

This indicates that `int` is the element type. We can apply the 
same rules to int[][]:

int[] singleArr;    // type is int[], element type int
int[][] doubleArr;  // type is int[][], element type ?

Again, using parens we cans the element type of `doubleArr`:

(int[])[];

So singleArr[0] returns the first `int`, and doubleArr[][0] 
returns the first int[]. Consistent.

So the syntax you are used to in C or C++ is /backwards/ in D.








More information about the Digitalmars-d-learn mailing list