On Tue, 26 Apr 2011 10:08:21 -0400, Alexander <[email protected]> wrote:
On 26.04.2011 15:21, Daniel Gibson wrote:
No, in D arrays are not just pointers. It's indeed a struct that
contains the length (arr.length) and the pointer (arr.ptr).
If this is a struct, then there is no "special compiler handling"
needed to cast a struct to a pointer using opCast() (except for static
arrays).
But, from programmer point of view, array is not a struct, just a type
with some properties, "struct" is hidden somewhere internally.
A "struct" is simply a group of members used as data, and a group of
functions that accept that member as the first parameter. The same is
true for arrays, although it's not defined anywhere as a "struct."
Arrays are special types to the compiler, they are not ordinary
structures. However, more and more they are being extended in the
library. In reality, they could just be treated as normal types with the
library defining the properties, thanks to the ability to add array
properties. Already associative arrays are done that way. The way it is
implemented is a mix between newer style functions defined in the library
and original functions that were done way back when D did not have the
ability to add array properties.
This makes arrays in D a lot safer and also easier to use than in C.
I see no danger in using cast(void *)Array instead of Array.ptr, if
semantic is known in advance (and it is).
Casting overrides the type system. It's always a red flag.
Example:
void foo()
{
char[] buffer = new char[12];
...
auto charptr = cast(char *)buffer;
sometime down the road, you decide buffer should be a const input
parameter:
void foo(const(char)[] buffer)
{
...
auto charptr = cast(char *)buffer; // oops! there goes const!
or if you decide later to use wchar[], or whatever. casting says "I know
what I'm doing" and should be only used very sparingly. It should not be
a tool of first resort.
compare that to:
char *charptr = buffer.ptr; // throws an error if buffer is not a char[]
or even more robust:
auto charptr = buffer.ptr; // now all your code is upgraded to use the
newest type you decide on.
In other words, casting an array to a pointer is first of all a hack, and
second of all 100% unnecessary. It's just wasting compiler code space.
-Steve
