Question about arrays

[jerro]

On Sunday, 22 April 2012 at 23:01:26 UTC, jerro wrote:
> On Sunday, 22 April 2012 at 22:17:11 UTC, Stephen Jones wrote:
>> Thanks for the replies. I am still uncertain about something. 
>> The documentation distinguishes between dynamic slices (int[5] 
>> a = new int[5]) which are managed by the runtime, and stack 
>> allocated arrays (int[5] b). The problem I have is this. I 
>> want to be loading vertex positions and tex-coords of data 
>> exported from Blender into openGL vertex buffers. Basically 
>> the float data needs to be extracted from a file and passed up 
>> to the graphic card's memory but to do so it needs to transit 
>> through the CPU memory. Ideally I want to:
>>    a) load the data from the file into an array built upon the 
>> stack and owned by a function
>>    b) generate the vbo id and send the data off to the 
>> graphics card
>>    c) pass the id back into a class held in managed memory
>>    d) quit the function thus releasing the array on the stack
>>
>> My confusion is, if the syntax for both stack based and 
>> managed memory arrays is the same (&v[0] or &v.ptr) then both 
>> must be objects. I guess the difference is that stack based 
>> are of constant length, whereas slices are dynamic because 
>> they are managed by the runtime.
>
> Dynamic arrays in D are represented with a struct containing
> a pointer to the start of data and a length. Static arrays are
> represented in the same way as they are in C - just the data is
> saved, the length is known at compile time and the pointer to 
> data
> is computed from the stack frame pointer (or a pointer to
> struct if the static array is contained within a struct) and the
> offset which is also know at compile time, the same way the 
> pointers
> to primitive types are computed.  For example the following D 
> program:
>
> import std.stdio;
>
> auto vp(T)(T* a){ return cast(void*) a; }
>
> struct S
> {
>         int[8] a;
>         int[8] b;
>         int[]  c;
>         int[8] d;
> }
>
> void main()
> {
>         S s;
>         writeln( vp(&s.a) - vp(&s.a[0]));
>         writeln(vp(&s.b) - vp(&s.a));
>         writeln(vp(&s.c) - vp(&s.b));
>         writeln(vp(&s.d) - vp(&s.c));
> }
>
> and the following C program:
>
> #include <stdio.h>
>
> #define vp(a) (void*)(a)
>
> typedef struct
> {
>         int* ptr;
>         size_t length;
> } IntArray;
>
> typedef struct
> {
>         int a[8];
>         int b[8];
>         IntArray  c;
>         int d[8];
> } S;
>
> int main()
> {
>         S s;
>         printf("%d\n", vp(&s.a) - vp(&s.a[0]));
>         printf("%d\n", vp(&s.b) - vp(&s.a));
>         printf("%d\n", vp(&s.c) - vp(&s.b));
>         printf("%d\n", vp(&s.d) - vp(&s.c));
>         return 0;
> }
>
> both print
>
> 0
> 32
> 32
> 16

Just to clarify, .ptr and .length aren't really fields, they
are properties. Dynamic arrays are actually represented as
structs containing a pointer and a length, but static arrays
are not. The fact that they have .ptr and .length properties
does not imply they are represented as structs with .ptr and
.length fields.