Proper desctructor for an class containing dynamic array of objects

[Marco de Wild]

On Thursday, 13 June 2019 at 16:08:52 UTC, Mike wrote:
> Hi,
>
> my name is Mike and I'm new to D (coming from a Javabackground) 
> and for fun I'm trying to learn D now.
> I created a simple class
>
> class Block {
>
>     int a, b;
>     this() {}
>
> }
>
> And now I have a dynamic array of objects of this class in 
> another class:
>
> class Foo {
>
>      Block[] array  = new Block[](10);
>
>      this() {
>        for (int i = 0; i < array.length; i++) {
>           array[i] = new Block();
>        }
>      }
> }
>
> How would a proper destructor of class Foo look like?
> Is it enough to set "array" to null? Or do I have to set every 
> element of the array to null and then the array, or nothing of 
> that at all because the garbage collecter collects it, if the 
> reference to Foo is set to null?

Opposed to Java, D's member variables are static initialised. 
There is one default value for "array" that is shared between all 
instances of Foo. This allows for compiler optimisations of 
primitives (baking in a int value of 5 into the class definition, 
but gives unexpected behaviour for reference types.

https://run.dlang.io/is/UNp5Al

In this example, two instances of Foo are created. The 
constructor is run both times. However, they act on the same 
array object. So initialisation of the second Foo will modify 
references data of the first Foo. As a check, the first object of 
both Foos are compared by reference.

Java allows you to define a block of code in your class that is 
run on construction, e.g.
public class JavaClass {
     {
         doStuff();
     }
     int x = initializeX();
}
It makes for fun questions on things like OCA certificates. 
However, D doesn't allow that. All initialisation code is placed 
in the constructor, e.g.

this() {
     array = new Block[](10);
     // ...
}

(Of course you can call other methods from there. In fact, 
constructor rules are slightly relaxed compared to Java.)