free causes exception

[ZombineDev via Digitalmars-d-learn]

On Tuesday, 26 January 2016 at 21:23:28 UTC, Igor wrote:
> On Tuesday, 26 January 2016 at 20:17:20 UTC, Steven 
> Schveighoffer wrote:
>> On 1/26/16 9:20 AM, Igor wrote:
>>> I have successfully malloc'ed an object but when I go to free 
>>> it in the
>>> destructor I get an exception. The destructor simply has
>>>
>>> ~this() // destructor for Foo
>>> {
>>>      core.stdc.stdlib.free(&this);
>>> }
>>>
>>>
>>> auto buffer = 
>>> core.stdc.stdlib.malloc(__traits(classInstanceSize,
>>> App))[0..__traits(classInstanceSize, App)];
>>> auto app = cast(App)emplace!App(buffer[]);
>>>
>>> I tried to retain a ptr to buffer and free that but still no 
>>> good. I
>>> also get a depreciation warning that &this is not an lvalue. 
>>> Hopefully I
>>> don't have to keep a ptr around to this simply to free it and 
>>> avoid
>>> future issues?
>>>
>>> So how am I suppose to free an object?
>>
>> Don't do it in the destructor.
>>
>> I can only imagine that you are triggering the destructor with 
>> destroy? In this case, destroy is calling the destructor, but 
>> then tries to zero the memory (which has already been freed).
>>
>> There is a mechanism D supports (but I believe is deprecated) 
>> by overriding new and delete. You may want to try that. It's 
>> deprecated, but has been for years and years, and I doubt it's 
>> going away any time soon.
>>
>> A class shouldn't care how it's allocated or destroyed. That 
>> is for the memory manager to worry about.
>
> um? Memory manager? I am doing it manually C++ style so I don't 
> have to worry about the god forsaken memory manager. Why is it 
> so difficult? I create the object and release it when I need to.
>
> I can replace the destroy(f) with free(inline the code) but I 
> don't see why that should matter. The whole point of 
> destructors is to do this sort of stuff. That's why they were 
> invented in the first place!?!

Why not simply:
class Foo { this(Arg1, Arg2) { ... } ... }

// Option A:
import std.typecons : scoped;
auto foo = scoped!Foo(arg1, arg2);

// Option B:
import std.experimental.allocator : make, dispose;
import std.experimental.allocator.mallocator;
auto foo = Mallocator.instance.make!Foo(arg1, arg2);
scope(exit) Mallocator.instance.dispose(foo);

http://dlang.org/phobos/std_typecons#.scoped
http://dlang.org/phobos/std_experimental_allocator