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;

}

12 │ ~this(){
13 │ writeln("Free heap");
14 │ import object: destroy;
15 │ import core.memory: GC;
16 │ i=null; // But How to force GC free ?

This works also,

class C {
     int * pa;
     int [] a;
        // Constructor
        this() {writefln("Called constructor");
           pa=cast(int *)malloc(1000*int.sizeof);
           a=pa[0..1000];
          }

}

void dofun()
{
   scope x=new C;
   x.a[3]=5;
   writefln("%12x",&x);

}
int main(){
   dofun();
   dofun();
   return 0;

}