How to pass in reference a fixed array in parameter

[Eric P626]

On Tuesday, 4 June 2024 at 16:19:39 UTC, Andy Valencia wrote:
> On Tuesday, 4 June 2024 at 12:22:23 UTC, Eric P626 wrote:
>
>> I tried to find a solution on the internet, but could not find 
>> anything, I stumble a lot on threads about Go or Rust language 
>> even if I specify "d language" in my search.
>
> Aside from the excellent answer already present, I wanted to 
> mention that searching with "dlang" has helped target my 
> searches.
>
> Welcome to D!  (From another newbie.)
> Andy

Thanks for the comments. So far, I only managed to make it work 
by creating a dynamic array and keeping the same signature:

~~~
     void main()
     {  s_cell [][] maze = new s_cell[][](5,5);
        print_maze (maze);
     }

void print_maze ( s_cell [][] maze )
{
}
~~~

Now according to the book, it's possible to assign a slice from a 
fixed array. This code will compile:

~~~
int[12] monthDays = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 
31 ];
int[] a_slice = monthDays;
~~~

How come the assignment does not work when passing a parameter. I 
tried the following and it failed:

~~~
s_cell [5][5] maze;
s_cell [][] sliced_maze = maze;
~~~

with this message:

~~~
Error: cannot implicitly convert expression `maze` of type 
`s_cell[5][5]` to `s_cell[][]`
~~~

Is it because it's a 2D array (slice of slice)? I need to 
manually copy each slice manually, or use a utility function to 
do the copy? This is why it cannot auto-magically do it with just 
when passing a parameter.

I tried the following signatures with the ref keyword and it did 
not change anything:

~~~
void print_maze ( ref s_cell maze )
void print_maze ( ref s_cell [][] maze )
~~~

 From what I found, arrays passed in parameters are always passed 
by reference. So the ref keyword seems pointless.

-------------------------------------------------------

The only solution left is to use pointers. But even this does not 
seems to work as in C. I created a function with different 
pointer signature and they all fails.

Normally in C, this would have worked:

~~~
s_cell [5][5] maze;
create_maze(&maze);

void create_maze ( s_cell *maze)
{
}
~~~

I get the following error

~~~
Error: function `mprmaze.create_maze(s_cell* maze)` is not 
callable using argument types `(s_cell[5][5]*)`
cannot pass argument `& maze` of type `s_cell[5][5]*` to 
parameter `s_cell* maze`
~~~

But I get the idea of ambiguity, is the pointer pointing on a 
single cell, or an array of cells, so there might need a way to 
specify that it's not just an elements. I tried this:

~~~
s_cell [5][5] maze;
create_maze(&maze);

     void create_maze ( s_cell [][]*maze)
     {
     }
~~~

and get this error

~~~
Error: function `mprmaze.create_maze(s_cell[][]* maze)` is not 
callable using argument types `(s_cell[5][5]*)`
cannot pass argument `& maze` of type `s_cell[5][5]*` to 
parameter `s_cell[][]* maze`
~~~

Now I think it expect a 2D array of pointers instead of a pointer 
on a 2D array.

It's also not clear if there is a difference between those 2 
notations:

~~~
&maze
maze.ptr
~~~

Do you have a code sample on how to pass a 2D array by pointer?

So far, the pointer solution seems like the only method that 
should be compatible with both fixed and dynamic arrays unless I 
am mistaken.