On Wednesday, 5 June 2024 at 10:36:50 UTC, Nick Treleaven wrote:
```d
import std.stdio;
alias s_cell = int;
void main()
{ writeln("Maze generation demo");
s_cell [5][5] maze;
int n;
foreach (i, row; maze)
foreach (j, col; row)
maze[i][j] = n++;
s_cell[][5] slices;
foreach (i, _; maze)
slices[i] = maze[i];
print_maze (slices);
}
void print_maze ( s_cell [][] maze )
{
foreach (a; maze)
a.writeln();
}
```
Thanks for the feedback
Almost all my projects works intensively with multiple dimensions
arrays. So I want to know the best way to manage multi
dimensional arrays. I guess the best solution so far are:
1) Only use dynamic arrays.
2) Use a single dimension array, and compute the index value from
x,y,z coordinates (Makes dynamic allocation easier). This
solution could work well with pointers too.
3) Make my own data structure or class containing the array.
Allowing to pass the structure/class by reference. Could allow
encapsulating single or multi dimensional arrays.
About .ptr, the documentation page state that:
~~~
The .ptr property for static and dynamic arrays will give the
address of the first element in the array:
~~~
So I assumed that the following expressions where equivalent, but
I guess the multiple dimensions do complicate things:
~~~
array.ptr == &array == &array[0]
~~~
So ommitting the "ref" keyword it's like if the data was read
only even if the variable is not passed by value. That means that
this signature cannot modify the content of the 2D array:
~~~
void print_maze ( s_cell [][] maze )
~~~
For the create_maze() function, I would need to use the follwing
signature since it changes the content of the array.
~~~
void print_maze ( ref s_cell [][] maze )
~~~
I imagine `a.writeln();` is the same as `writeln(a);` ?
Your foreach loops look better than mine. Here is the code I have
been using to print the maze.
~~~
void print_maze ( s_cell [][] maze )
{
//print top row, assume full
foreach ( cell; maze[0] ) write("+---");
writeln("+");
for ( int y = 0; y < maze.length; y++)
{ //print content
write("|"); //assume edge is always full
for ( int x = 0; x < maze[y].length; x++)
{ write(" ");
write( maze[y][x].east ? "|": " ");
}
writeln();
foreach ( cell; maze[y] ) write( cell.south ? "+---" : "
" );
writeln("+");
}
}
~~~
your iteration version is more neat:
~~~
foreach (i, row; maze)
foreach (j, col; row)
maze[i][j] = n++;
~~~
I like that using 2 variables (i,row) or (j,col) allow to access
the variable later as a element in a collection or as an index.
It's more flexible. I'll guess I'll need to read more code to
avoid programming too much old school (^_^).
