How to delete dynamic array ?

Jakob Ovrum jakobovrum at gmail.com
Mon Dec 30 01:17:47 PST 2013


On Monday, 30 December 2013 at 06:52:20 UTC, Ilya Yaroshenko 
wrote:
> case 1:
>  delete ar;
> case 2:
>  ar.destroy();
> case 3:
>  GC.free(ar.ptr);
> case 4:
>  ar = null;// (assumed that ar is only one pointer to the same 
> array)
>
> What is the difference?
>
> How to free memory to the system immediately?

It depends on how it is allocated. The `delete` operator is 
deprecated, so it is never appropriate.

For GC memory (memory allocated with `new`, the concatenation 
operators or array literals) then you should just `null` any 
reference that is no longer used, leaving it to the GC to collect 
the memory when it sees fit. This guarantees memory safety, which 
is the primary purpose of a memory garbage collector.

If you really, really must free a chunk of GC memory *right now*, 
you can use GC.free, but you lose any guarantee of memory safety. 
If you can't think of a reason your code needs to do this, then 
your code probably doesn't need it.

If the array is allocated from a non-GC heap, such as the C heap, 
use the corresponding freeing function (C heap using `malloc` + 
`free`).

`destroy` is for running destructors on, and then invalidating, 
instances of user-defined types (UDTs). For generic code 
purposes, you can use it on non-UDTs, in which case it will just 
invalidate them. Values invalidated with `destroy` must not be 
used after invalidation - it is a logic error. What it means by 
invalidation is up to the implementation, but it guarantees that 
it won't free memory. Currently, it zero-blasts the value (which 
may be different from the value's default initializer).


More information about the Digitalmars-d-learn mailing list