On Friday, 5 June 2015 at 19:18:39 UTC, anonymous wrote:
On Friday, 5 June 2015 at 17:27:18 UTC, Kyoji Klyden wrote:
On Thursday, 4 June 2015 at 22:28:50 UTC, anonymous wrote:
[...]
By the way, there are subtly different meanings of "array"
and "string" which I hope you're aware of, but just to be
sure:
"array" can refer to D array types, i.e. a pointer-length
pair, e.g. char[]. Or it can refer to the general concept of
a contiguous sequence of elements in memory.
And as a special case, "string" can refer to D's `string`
type, which is an alias for `immutable(char)[]`. Or it can
refer to a contiguous sequence of characters in memory.
And when ketmar writes: "it's a pointer to array of pointers
to first chars of strings", then "array" and "string" are
meant in the generic way, not in the D-specific way.
[...]
So how does D store arrays in memory then?
I know you already explained this part, but..
Does the slice's pointer point to the slice's position in
memory? Then if an array isn't sequential, is it atleast a
sequence of pointers to the slice structs (& those are just in
whatever spot in memory they could get?)
There's a slice for each array index..right? Or is it only for
the first element?
Oh boy, I think I might have put more confusion on top than
taking away from it.
I didn't mean to say that D's arrays are not sequential. They
are. Or more specifically, the elements are. "Array" is often
meant to mean just that: a contiguous sequence of elements in
memory. This is the same in C and in D.
If you have a pointer to such a sequence, and you know the
number of elements (or what element is last), then you can
access them all.
In C, the pointer and the length are usually passed separately.
But D groups them together and calls it a "dynamic array" or
"slice": `ElementType[]`. And they're often simply called
"arrays". This is done to confuse newbies, of course.
There's an article on slices (dynamic arrays):
http://dlang.org/d-array-article.html
C doesn't know about D's slice structure, of course. So when
talking to C, it's often necessary to shuffle things around.
For example, where a D function has a parameter `char[] arr`, a
C version may have two parameters: `size_t length, char*
pointer_to_first`. And if you want to call that C version with
a D slice, you'd do `cfun(dslice.length, dslice.ptr)`.
It gets interesting with arrays of arrays. In D that would be
`char[][] arr`. And in C it could be `size_t length, char**
pointers_to_firsts, size_t* lengths`.
Now what to do? A `char[][]` refers to a sequence of D slices,
but the C function expects two sequences: one of pointers, and
one of lengths. The memory layout is incompatible. You'd have
to split the `char[][]` up into two arrays: a `char*[] ptrs`
and a `size_t[] lengths`, and then call the function as
`cfun(ptrs.length, ptrs.ptr, lengths.ptr)`
(Hope I'm not makings things worse with this.)
Okay, so it's primarily an interfacing with C problem that
started all this? (My brain is just completely scrambled at this
point xP )
So pretty much the slice gives you the pointer to the start of
the array in memory and also how many elements are in the array.
Then depending on the array type it'll jump that many bytes for
each element. (So 5 indexes in an int array, would start at
address 0xblahblah00 , then go to 0xblahblah04, until it reaches
0xblahblah16(?) or something like that)
If I FINALLY have it right, then that makes alot of sense
actually.
