runtime static arrays

[Ali Çehreli]

On 11/20/2012 06:25 AM, Namespace wrote:
> Is there any need for 'smart' or 'compressed' arrays?
>
> In my last projects I had some situations where I need an array, but
> only for one scope. But I could not use static arrays, because I didn't
> know the size at compile time. So I used 'alloca'. But 'alloca' has a
> terrible interface and in some few cases I had to append x elements. So
> I used a dynamic array. But dynamic arrays live longer as the lifetime
> of the scope. Furthermore dynamic arrays costs more memory as I needed,
> because the capacity of them is n * 2 + 1, but in my cases I need only n.
> So what I need was an array, which lives only for one scope (freed
> memory after leaving scope) and which hasn't more elements/capacity as I
> need.
>
> Am I wrong and dynamic arrays are the solution? Or is there need for
> such 'compressed' arrays?
> Another solution would be to improve the interface of alloca, but it
> would be still not resizable.

The following program makes a slice from GC-allocated memory (or a 
fixed-size array as in the comment). The important part is 'buffer[0..10]'.

import std.stdio;
import core.memory;

void bar(int[] a)  // Also try: int[10] a
{
     writeln("param : ", a.ptr);
}

void foo()
{
     int *buffer = cast(int*)GC.calloc(int.sizeof * 10);
     scope (exit) GC.free(buffer);

     writeln("buffer: ", buffer);

     int[] a = buffer[0..10];  // Also try: int[10] a =

     writeln("a     : ", a.ptr);

     foreach (i; a) {
         i = 42 + i;
     }

     bar(a);
}

void main()
{
     foo();
}

Ali