On Tuesday, 15 November 2022 at 02:26:41 UTC, Elfstone wrote:
I failed to find any documentation, except dynamic array slices
will be taken care of by GC, but I assume it's not the case
with static arrays.
A slice is a view on the existing memory owned by the original
array. No allocations are made for the slice. The GC will track
all references to the memory allocated for a dynamic array, so as
long as any slices remain alive, so will the original memory.
Static arrays are allocated on the stack and become invalid when
they leave a function scope. In turn, so would any slices or
other pointers that reference that stack memory.
But the code bellow doesn't behave as I expected.
int[] foo()
{
int[1024] static_array;
// return static_array[]; // Error: returning
`static_array[]` escapes a reference to local variable
`static_array`
return null;
}
class A
{
this(int[] inData)
{
data = inData;
}
int[] data;
}
void main()
{
int[] arr;
A a;
{
int[1024] static_array;
arr = aSlice; // OK
a = new A(aSlice); // OK
arr = foo();
//arr = foo();
}
}
By assigning aSlice to arr or a, it seemingly escapes the
scope, I thought there'd be errors, but the code compiles just
fine.
Is it really safe though?
It's not the scope that matters here. It's the stack. Memory
allocated in the inner scope uses the function stack, so it's all
valid until the function exits.
