On 25/06/2024 2:16 PM, mw wrote:
> struct shared_AA {
>    shared_AA_class saa = new shared_AA_class();  // by this syntax `saa` is still instance variable?
>    alias saa this;
> }

When you specify an initializer like this, that instance of ``shared_AA_class`` gets put into the .init of ``shared_AA``.

It is shared between instances, even if its a field.

```d
import std.stdio;

struct Foo {
    ubyte value = 2;
}

void main() {
    writeln(cast(ubyte[])__traits(initSymbol, Foo)); // [2]
}
```

On Tuesday, 25 June 2024 at 02:25:14 UTC, Richard (Rikki) Andrew Cattermole wrote:
> On 25/06/2024 2:16 PM, mw wrote:
>> struct shared_AA {
>>    shared_AA_class saa = new shared_AA_class();  // by this syntax `saa` is still instance variable?
>>    alias saa this;
>> }
>
> When you specify an initializer like this, that instance of ``shared_AA_class`` gets put into the .init of ``shared_AA``.
>

This is confusing -- well, let's try something similar in C++ and Java:

```
$ cat shared_aa.cpp
#include <stdio.h>

class shared_AA_class {
public:
  int aa;
  shared_AA_class() {
	  printf("new shared_AA_class\n");
  }

  void print() {
	  printf("%d\n", aa);
  }
};

struct shared_AA {
  shared_AA_class* saa = new shared_AA_class();  // by this syntax `saa` is still instance variable
};

class Foo {
public:
 shared_AA x;
 shared_AA y;

 Foo() {
    x.saa->aa = 1;  // only modified `x`, not `y`
 }

};

int main() {

	Foo foo;

	foo.x.saa->print();
	foo.y.saa->print();

	printf("%d\n", foo.x.saa->aa);
	printf("%d\n", foo.y.saa->aa);
}

$ g++ shared_aa.cpp
$ ./a.out
new shared_AA_class
new shared_AA_class
1
0
1
0
```

The `shared_AA_class` ctor is called twice, and `foo.x.saa` and `foo.y.saa` are different object.


```
$ cat Foo.java
class shared_AA_class {
 public
  int aa;
  shared_AA_class() {
	  System.out.println("new shared_AA_class");
  }

  void print() {
	  System.out.println(aa);
  }
}

class shared_AA {
  shared_AA_class saa = new shared_AA_class();  // by this syntax `saa` is still instance variable
}

class Foo {
	 shared_AA x;
	 shared_AA y;

	Foo() {
    x = new shared_AA();
    y = new shared_AA();
		x.saa.aa = 1;  // only modified `x`, not `y`
	}

public static void main(String[] args) {

	Foo foo = new Foo();

	foo.x.saa.print();
	foo.y.saa.print();

	System.out.println(foo.x.saa.aa);
	System.out.println(foo.y.saa.aa);
}

}

$ javac Foo.java
$ java Foo
new shared_AA_class
new shared_AA_class
1
0
1
0


```

The `shared_AA_class` ctor is called twice, and `foo.x.saa` and `foo.y.saa` are different object.


Why D choose to be different here? i.e. `shared_AA_class saa = new shared_AA_class()` only evaluate only once, and even force it must be evaluate-able at compile time?

It's a bug.

On 25/06/2024 3:38 PM, mw wrote:
> Why D choose to be different here? i.e. |shared_AA_class saa = new shared_AA_class()| only evaluate only once, and even force it must be evaluate-able at compile time?

That has nothing to do with it.

Every type in D has an initialized value, that everything starts off as, byte for byte.

When you have a field with an initializer it gets put into that initialized value.

The constructor does not perform the initializer.