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
