I have the following types (simplified version of my code):

struct A
{
    int[] i;
}
struct B
{
    A[] a = [A.init];
}

This code:

    auto b1 = B.init;
    b1.a[0].i ~= 1;
    b1.a ~= A.init;
    b1.a[0].i ~= 11;
    b1.a[1].i ~= 12;
    b1.writeln;

    auto b2 = B();
    b2.writeln;

prints this as expected:

B([A([1, 11]), A([12])])
B([A([])])

But this code:

    B b1;      // auto b1 = B.init;
    b1.a[0].i ~= 1;
    b1.a ~= A.init;
    b1.a[0].i ~= 11;
    b1.a[1].i ~= 12;
    b1.writeln;

    B b2;     // auto b2 = B();
    b2.writeln;

prints this which is not expected:

B([A([1, 11]), A([12])])
B([A([1])])

Does the second piece of code shows a bug or my expectation is not correct (and why if so)?

There's a bug that an array field initializer is stored in the data section and thus is implicitly shared. Maybe the constructor form allocates in on spot?

On Tuesday, 25 October 2022 at 14:53:50 UTC, Adam D Ruppe wrote:

I'd like to tune default ctor but structs can't have custom one.
Adding a ctor with parameter seems a hack to me - and compiler still allows default construction even when default ctor is disabled:

struct A
{
    int[] i;
}
struct B
{
    A[] a;
    @disable this();
    this(bool)
    {
	    A[] a = [A.init];
    }
}
void main()
{
    auto b1 = B.init;
    b1.a[0].i ~= 1;
    b1.a ~= A.init;
    b1.a[0].i ~= 11;
    b1.a[1].i ~= 12;
    b1.writeln;

    auto b2 = B.init;
    b2.writeln;
}

This fails in run time, not compile time:

core.exception.ArrayIndexError@onlineapp.d(19): index [0] is out of bounds for array of length 0
----------------
??:? _d_arraybounds_indexp [0x55b558b8ec55]
./onlineapp.d:19 _Dmain [0x55b558b6bd5f]

Actually auto b = B.init; behaves the same way as auto b = B(); but they don't do the same as B b;

On Tuesday, 25 October 2022 at 14:53:50 UTC, Adam D Ruppe wrote:

A[] a = [A.init];

Is it a bad idea to trigger copy on write before modification of B.a so it behaves as below?

    B b1;
    b1.a = b1.a.dup;   // copy on write
    b1.a[0].i ~= '1';
    b1.a ~= A.init;
    b1.a[0].i ~= '2';
    b1.a[1].i ~= '3';
    b1.writeln;        // B([A("12"), A("3")])

    B b2;
    b2.writeln;        // B([A("")])

On Tuesday, 25 October 2022 at 13:51:30 UTC, Andrey Zherikov wrote:

This is a bug:

void main()
{
  struct B
  {
    struct A
    {
      int i = 10;
    }
    A[] a = [A.init];
  }

  B[2] b;
  assert(b[0].a[0].i == 10);
  assert(b[1].a[0].i == 10);

  b[0].a[0].i = 1;
  assert(b[0].a[0].i == 1); // ok...
  assert(b[1].a[0].i == 1); // must be 10 !!!
}

SDB@79

On Tuesday, 25 October 2022 at 16:52:48 UTC, Salih Dincer wrote:

void main()
{
  struct B
  {
    struct A
    {
      int i = 10;
    }
    A[] a = [A.init];
  }

  B[2] b;
  assert(b[0].a[0].i == 10);
  assert(b[1].a[0].i == 10);

  b[0].a[0].i = 1;
  assert(b[0].a[0].i == 1); // ok...
  assert(b[1].a[0].i == 1); // must be 10 !!!
}

It's not a bug. They're pointing to the exact same instance of A in memory:

void main()
{
  struct B
  {
    struct A
    {
      int i = 10;
    }
    A[] a = [A.init];
  }

  B[2] b;
  assert(b[0].a.ptr is b[1].a.ptr);
}

As explained in Adam's reply, what happens here is that there is a single, global A[] allocated at compile time, which is shared between all instances of B.init. It's the same as if you'd written

struct B
{
    struct A
    {
        int i = 10;
    }
    static A[] globalArray = [A.init];
    A[] a = globalArray;
}

On Tuesday, 25 October 2022 at 17:18:35 UTC, Paul Backus wrote:

I don't understand? So I don't understand why it causes problems with dynamic arrays! So why is there nothing wrong with the static array in the example below?

import std.stdio, std.format;
void main()
{
  struct B
  {
    struct A {
      int i = 10;
    }
    //A[] a = [A.init];/*
    A[1] a = [A.init];//*/

    string toString() {
      return a[0].i.format!"%s";
    }
  }

  B[2] b;
  b.writeln;  // [10, 10]

  b[0].a[0].i = 0;
  b.writeln;  // [0, 10]

  b[1].a[0].i = 1;
  b.writeln;  // [0, 1]
}