On Monday, 17 August 2015 at 13:27:19 UTC, Brandon Ragland wrote:
If that is true, than passing it as _char[] file_ makes the
most sense to me. A pointer copy doesn't hurt as bad as an
array copy, of say, 100Kibibytes...
Right.
Knowing this helps to explain a lot btw:
char[] foo;
void func(char[] arg) {
}
func(foo);
In that scenario, foo's data is not copied, just a pointer to it
is. Very fast operation.
arg[0] = 'a';
Since it is a pointer, writing to the arg will also write to foo.
BUT:
arg = "a new thing";
This will NOT be seen outside. It wrote a new pointer to the
local variable arg's pointer, so now arg and foo point to
different data.
Similarly:
arg ~= 'a';
will not be seen outside. The pointer might change which is not
seen outside, and the length will change, which is also not seen.
So char[] arg in D is similar to char* arg_ptr, size_t length_ptr
in C - changing them inside the function just modifies local
variables, not the outer variable. Writing *through the pointer
will be seen outside though since they talk to the same data.
Similarly, slicing in D is just a pointer assignment:
char[] a = b[3 .. 4];
That's like in C:
a.ptr = b.ptr + 3;
a.length = 4-3;
Just basic arithmetic and assignment, no data copy going on.
This is all talking about T[] slices. Static arrays, in the form
of T[constant], are different:
ubyte[4] static_data;
void slice_test(ubyte[] slice) {}
void static_test(ubyte[4] copy) {}
slice_test(static_data[]); // passes a pointer to the data
static_test(static_data); // passes a copy.
So T[] is always talking about pointer+length, but T[n] is always
talking about a block of memory which is copied around to other
T[n].
Putting the [] at the end of it, like I did with slice_test,
fetches a pointer instead of copying. It is how you convert a
static memory chunk to a pointer.
There's a few more things but you should understand it now, apply
the low level principles to it and it all should make sense.
More reading:
http://dlang.org/d-array-article.html
http://dlang.org/arrays.html
