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@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
