Re: Delay allocating class instance in stack.

[Ali Çehreli via Digitalmars-d-learn]

On 03/21/2017 09:57 PM, ANtlord wrote:
> On Tuesday, 21 March 2017 at 08:46:43 UTC, Ali Çehreli wrote:
>> Another option is std.conv.emplace:
>>
>> import std.conv : emplace;
>>
>> class MyClass {
>>     this(int) @nogc {
>>     }
>>
>>     ~this() @nogc {
>>     }
>> }
>>
>> void method(bool flag) @nogc
>> {
>>     void[__traits(classInstanceSize, MyClass)] buffer = void;
>>     MyClass obj;
>>
>>     if(flag) {
>>         obj = emplace!MyClass(buffer, 1);
>>     } else {
>>         obj = emplace!MyClass(buffer, 2);
>>     }
>>
>>     // Unfortunately, destroy() is not @nogc
>>     // scope(exit) destroy(obj);
>
> Thank you for clarification. But I have one more question. Do I have to
> use destroy for deallocating object from stack?
Yes because what is going out of scope are two things:

- A buffer
- A MyClass reference

Neither of those have destructors. (emplace is just a library function 
that does something with that buffer but the compiler cannot know that 
there is an object that we want destructed.)

Here is a hack that defines a destroyNoGC() that allows one to call the 
destructor is a @nogc context:

import std.stdio;
import std.conv : emplace;

class MyClass {
    this(int) @nogc {
    }

    ~this() @nogc {
        printf("~this\n");
    }
}

// Adapted from std.traits.SetFunctionAttributes documentation
import std.traits;
auto assumeNoGC(T)(T t)
    if (isFunctionPointer!T || isDelegate!T)
{
    enum attrs = functionAttributes!T | FunctionAttribute.nogc;
    return cast(SetFunctionAttributes!(T, functionLinkage!T, attrs)) t;
}

@nogc void function(Object) destroyNoGC;
static this() {
    destroyNoGC = assumeNoGC((Object obj) {
        destroy(obj);
    });
}

void method(bool flag) @nogc
{
    void[__traits(classInstanceSize, MyClass)] buffer = void;
    MyClass obj;

    if(flag) {
        obj = emplace!MyClass(buffer, 1);
    } else {
        obj = emplace!MyClass(buffer, 2);
    }

    scope(exit) {
        destroyNoGC(obj);
    }
}

void main() {
    method(false);
    method(true);
}

Gotta love D for allowing such code but it comes with surprises. Why do 
we suddenly get two destructor calls?

~this
~this

Ali