How to pass in reference a fixed array in parameter

[Eric P626]

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 (^_^).