Re: How to free memory ater use of "new" to allocate it.
On Monday, 17 July 2023 at 16:52:00 UTC, Alain De Vos wrote:
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",);
}
int main(){
dofun();
dofun();
return 0;
}
```
Remember to use free, this is not managed by the GC
Re: How to free memory ater use of "new" to allocate it.
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",);
}
int main(){
dofun();
dofun();
return 0;
}
```
Re: How to free memory ater use of "new" to allocate it.
On Sunday, 16 July 2023 at 18:18:08 UTC, Alain De Vos wrote:
12 │ ~this(){
13 │ writeln("Free heap");
14 │ import object: destroy;
15 │ import core.memory: GC;
16 │ i=null; // But How to force GC free ?
Firstly, be careful with class destructors and GC managed
objects. The memory referenced by `i` may already have been freed
by the GC when the class destructor is called - see:
https://dlang.org/spec/class.html#destructors
If you want to free GC memory when you know the allocation is
still live, you can call __delete:
https://dlang.org/phobos/core_memory.html#.__delete
import std.stdio: writeln;
```d
void main()
{
int[] i=null;
writeln("Allocate heap");
i=new int[1];
i[9000]=5;
import core.memory;
const p = i.ptr;
assert(GC.addrOf(p) !is null);
writeln("Free heap");
__delete(i);
assert(GC.addrOf(p) is null);
}
```
Re: How to free memory ater use of "new" to allocate it.
On 7/16/23 11:58 PM, Alain De Vos wrote:
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;
}
```
Notice how you didn't call `destroy(a)` there. If you did, then
`free(a)` would be equivalent to `free(null)`, which would do nothing.
-Steve
Re: How to free memory ater use of "new" to allocate it.
On 7/16/23 11:41 PM, Alain De Vos wrote:
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",);
destroy(a);
GC.free(a.ptr);
}
int main(){
dofun();
auto b=new int[1000];
writefln("%12x",);
return 0;
}
```
No, what I am trying to explain is that `destroy(a)` is literally
equivalent to `a = null`.
If you then `free(a)` do you think it does anything?
-Steve
Re: How to free memory ater use of "new" to allocate it.
Here is i use new,
```
import std.stdio:writefln;
import object: destroy;
import core.memory: GC;
import core.stdc.stdlib: malloc,free;
import std.typecons;
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",);
}
int main(){
dofun();
dofun();
return 0;
}
```
Re: How to free memory ater use of "new" to allocate it.
17.07.2023 15:45, Alain De Vos пишет: This works also: [snipped] Despite this time you use new you still allocate your class on stack using scope and its scope still is `dofun`. But I just want to inform you. Your solutions work. Don't get me wrong. N.B. I would say if you do not have THE reason to manually free memory - do not do this. At all. Just let GC does its work.
Re: How to free memory ater use of "new" to allocate it.
This works also:
```
import std.stdio:writefln;
import object: destroy;
import core.memory: GC;
import core.stdc.stdlib: malloc,free;
import std.typecons;
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",);
}
int main(){
dofun();
dofun();
return 0;
}
```
Re: How to free memory ater use of "new" to allocate it.
17.07.2023 13:17, Alain De Vos пишет:
The following code works:
```
import std.stdio:writefln;
import object: destroy;
import core.memory: GC;
import core.stdc.stdlib: malloc,free;
import std.typecons;
class C {
int * pa;
int [] a;
// Constructor
this() {writefln("Called constructor");
pa=cast(int *)malloc(1000*int.sizeof);
a=pa[0..1000];
}
~this(){
writefln("Called Destructor");
free(a.ptr);}
}
void dofun()
{
auto x=scoped!(C);
x.a[3]=5;
writefln("%12x",);
}
int main(){
dofun();
dofun();
return 0;
}
```
Note that you do not use new anymore. You allocate your class instances
on stack and their scope is `dofun()` only
Re: How to free memory ater use of "new" to allocate it.
The following code works:
```
import std.stdio:writefln;
import object: destroy;
import core.memory: GC;
import core.stdc.stdlib: malloc,free;
import std.typecons;
class C {
int * pa;
int [] a;
// Constructor
this() {writefln("Called constructor");
pa=cast(int *)malloc(1000*int.sizeof);
a=pa[0..1000];
}
~this(){
writefln("Called Destructor");
free(a.ptr);}
}
void dofun()
{
auto x=scoped!(C);
x.a[3]=5;
writefln("%12x",);
}
int main(){
dofun();
dofun();
return 0;
}
```
