Question about Object.destroy

[Lambert Duijst via Digitalmars-d-learn]

Hi all,

I have a question about the following piece of code that I wrote 
to experiment with explicit deletion of objects. I am interested 
in this because, even though D has a garbage collection, 
sometimes an object holds a non-memory resource, such as a file 
handle. In these cases explicit calls to a destructor are needed 
if you want deterministic release of resources.

The code I wrote is this :

import std.stdio;

class MyClass
{
   this(int a) {this.a = a;}
   ~this()
   {
     writeln("Destructor call");
   }

   void doSomething()
   {
     writeln("A is ", this.a);
   }
   int a;
};


void main(string args[])
{
   MyClass s = new MyClass(42);
   s.doSomething();
   s.destroy();
   s.doSomething();
}

The output of this program is:

A is 42
Destructor call

And then it segfaults.

This is obviously because of that last call to doSomething
Now the description of Object.destroy mentions that no GC memory 
is freed by Object.destroy. It does, however, put the object in 
an invalid state, but what does that mean and why does my program 
segfault.

Is it because:

  - The GC did decide to run and cleanup memory straight after the 
call to s.destroy()
  - An object being in an invalid state means the program 
segfaults when the object is used ?
  - Another reason..

And more importantly, can this way of programming with explicit 
destroy calls lead to memory corruption due to dangling pointers 
? or will D always let your program segfault whenever a deleted 
object is accessed ?

Please enlighten me, I am just a newbie :-)