On Monday, 17 August 2015 at 03:07:26 UTC, Adam D. Ruppe wrote:
On Monday, 17 August 2015 at 02:45:22 UTC, Brandon Ragland
wrote:
[...]
Short answer: pointers to slices are usually a mistake, you
probably don't actually want it, but rather should be using a
regular slice instead.
[...]
Here, for example, you've accidentally escaped slice land and
are unto unchecked pointer arithmetic.
Since file is declared char[]* instead of char[], indexing it
works C style: it at the index as an offset from the base
char[].
In other words, it works more as if you wrote `char** file` in
C. (still not identically, a D slice is different than a C
char*, but same idea).
The above will only really work fine for index 0. Anything else
would be a wild pointer. If this didn't crash on you, you just
got kinda lucky with the index.
The append compiles because dereferencing a `char[]*` yields a
`char[]`, which D can append normally.
[...]
This errors for the same reason the top one succeeded: what's
pointed to by a char[]* is char[], not char. So you are trying
to compare a string on the left hand side to an individual
character on the right hand side.
In other words, what your error message told :)
[...]
char[] in D is like:
struct char_array {
size_t length;
char* ptr;
}
in C. Since there's already a pointer in there, you typically
don't want the address of this struct, you just want to pass it
right down by value and let the pointer be copied (it still
points to the same actual data).
BTW you can access those .length and .ptr values in D:
char[] slice;
char* a = slice.ptr; // works
The only time you'd actually want a char[]* in D is if you need
to write back to the original *variable* once you append or
shrink it. (The contents are fine, they can be modified through
the slice with no special effort.)
Bottom line again is char[] in D is like char* in C. So char[]*
in D is more like char** in C.
Thanks Adam.
I keep getting myself confused with D, when I'm thinking in C
land. Breaking it down like that is extremely helpful.
Going off what you're saying, this signature:
method(char[] file)
Would only copy the _pointer_, as this is similar to the C style
struct you mentioned:
struct char_array {
size_t len;
char* index;
}
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...
-Brandon
