struct dynamic allocation error

[Steven Schveighoffer via Digitalmars-d]

On 9/15/16 4:38 PM, Dechcaudron wrote:
> I believe there is some kind of weird issue that won't allow for struct
> instances to be dynamically allocated in a proper way via the 'new'
> keyword. It does actually allocate them and return a valid pointer to
> operate the instances, but whenever the program is exited I get the
> following exception:
>
> core.exception.InvalidMemoryOperationError at src/core/exception.d(693):
> Invalid memory operation

This is because you are allocating in the destructor.

>
> Calling 'destroy' on the returned pointer only seems to set it to null,
> but it definitely doesn't call the destructor, neither does it prevent
> said exception from being raised. Code to reproduce:
>
> ```
> import std.conv;
> import std.stdio;
>
> struct Foo
> {
>     int a;
>
>     this(int a)
>     {
>         this.a = a;
>     }
>
>     ~this()
>     {
>         writeln("a is " ~ to!string(a));
>     }
> }
>
> void main()
> {
>     Foo a = Foo(5);
>     Foo* b = new Foo(10);
>     writeln("Allocation complete");
>     destroy(b); //Does nothing
>     //Destructor for a is called
> }
> ```

You need to destroy structs by passing them by reference. Passing a 
pointer just destroys the pointer.

In this example, you can destroy what b points at (and call its 
destructor) via:

destroy(*b);

However, this will not fix the issue. This is because the memory block 
is not marked as being destroyed already (so it will run the dtor 
again). Class instances have a feature whereby when you call destroy it 
marks the memory block as already having the destructor run. Structs do 
not have this feature. Classes can afford to store extra metadata, 
structs cannot.

So the true fix here is to avoid allocating in the destructor (which is 
a no-no for heap-allocated items). This may work, it may not:

writefln("a is %s", a);

I'm not sure if any memory allocation happens there, but if not, you 
should be OK.

-Steve