Unitialized allocation

[Koroskin Denis]

On Fri, 27 Jun 2008 21:22:50 +0400, Jarrett Billingsley  
<kb3ctd2 at yahoo.com> wrote:

> "Koroskin Denis" <2korden at gmail.com> wrote in message
> news:op.udevrrqpenyajd at proton.creatstudio.intranet...
>>
>> This surely should be available at a language level.
>
> It would be nice, but I'm not sure how it'd fit into the syntax.
>
> new(void) char[512] ?
> new void char[512] ?
>
>

Think different!

Let's suppose we have the following:
T[] t = new T[512]; // initialized to T.init

Now how do I resize `t` so that it would now contain 1024 elements (and  
first 512 of them remain the same)?
t.length = 1024;	// nope. initializes the rest of data

There is a solution of my preference - introduce a resize method (yes,  
that's a proposal):

import std.gc;

T[] resize(T)(ref T[] array, uint newLength, bool doInit = true) {
     if (doInit) {
         array.length = newLength;
         return array;
     }

     return array.resizeUninited(newLength);
}

T[] resizeUninited(T)(ref T[] array, uint newLength) {
     return array = cast(T[])realloc(array.ptr, newLength * T.sizeof);
}

t.resize(1024, true);	// initializes the data
t.resize(1024);		// a shortcut, same as above

t.resize(1024, false);	// here it is - that's what we need!
t.resizeUninited(1024);	// a shortcut

So, back to the original question: "[how to] allocate unitialized data on  
the heap ?"

My solution is to break it into two steps:
T[] t;
t.resize(1024, false); // or t.resizeUninited(1024, false);

What do you think?