I don't use malloc

import std.stdio: writeln;
   2   │
   3   │ class C{
   4   │     int[] i=null;
   5   │     this(){
   6   │         writeln("Allocate heap");
   7   │         i=new int[10000];
   8   │         writeln(typeid(typeof(i)));
   9   │         writeln(typeid(typeof(i.ptr)));
  10   │         i[9000]=5;
  11   │     }
  12   │     ~this(){
  13   │         writeln("Free heap");
  14   │         import object: destroy;
  15   │         import core.memory: GC;
  16   │         i=null; // But How to force GC free ? -------------?
  17   │     };
  18   │ }

On 7/16/23 2:41 PM, Alain De Vos wrote:

void main(){
     int[] i=new int[10000];
     import object: destroy;
     destroy(i);
     import core.memory: GC;
     GC.free(GC.addrOf(cast(void *)(i.ptr)));
}

No, that won't work. Check out i value after you call destroy on it:

destroy(i); // basically sets i = null
assert(i.ptr is null); // yep
GC.free(i.ptr); // basically free(null) which is a no-op

Also note that destroy is shallow. It does not dig into pointers or arrays. So even if your array was of elements with a destructor, destroying the array doesn't destroy the elements.

In this case, all you need to do is:

GC.free(GC.addrOf(i.ptr));

You don't need the cast here. You shouldn't need the addrOf, but this is still open: https://issues.dlang.org/show_bug.cgi?id=13558

-Steve

The following program prints two different addresses.
Meaning the new allocates memory until the program dies.
So the means memory leak by default ?

import std.stdio:writefln;
import object: destroy;
import core.memory: GC;

void dofun(){
    auto a=new int[1000];
    writefln("%12x",&a);
    destroy(a);
    GC.free(a.ptr);
}

int main(){
    dofun();
    auto b=new int[1000];
    writefln("%12x",&b);
    return 0;
}

Maybe code above works when you enforce an Garbage-collection-run ?

Code below works fine. So you cannot use "new" but must use malloc?

import std.stdio:writefln;
import object: destroy;
import core.memory: GC;
import core.stdc.stdlib: malloc,free;


void dofun(){
   auto pa=cast(int *)malloc(1000*int.sizeof);
   writefln("%12x",pa);
   auto a=pa[0..1000];
   free(a.ptr);
}

int main(){
    dofun();
   auto pb=cast(int *)malloc(1000*int.sizeof);
   writefln("%12x",pb);
   auto b=pb[0..1000];
   free(b.ptr);
   return 0;

}