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.
