d中数组与切片

数组是(针,长度)对.

struct Y { double q; }
struct X { Y[] a; }

X x;

auto r = x.a;//r复制了x.a的(针,长度)对

 #! /usr/bin/env rdmd
  import std.stdio;

  struct X { int[] a; }

  void main() {
      auto test = X([0]);
      test.a.reserve(10); // for later
      auto r = test.a;
      writeln(test.a.ptr == r.ptr); // true
      writeln(test.a.length == r.length); // true
  }
//修改后:
     r ~= [1];//复制后的,这基本上是另一个数组了
      writeln(test.a.ptr == r.ptr); //true(不一定)
      writeln(test.a.length == r.length); // false

//考虑如下:
  #! /usr/bin/env rdmd
  import std.stdio;
  struct X { int[] a; }
  void main() {
      X test;
      test.a.reserve(3);
      auto a = test.a;
      a ~= [1, 2, 3];//操作的是指针的内容,而不是长度
    
    //这里的test.a,3个之内,是已存在的量.更新已存在量,是会反映到另一个的
      auto r = test.a.ptr[0..3];//必须切片,敏感,数组操作,新数组了
      writeln(r); // output: [1, 2, 3]
  }
//如下:
 #! /usr/bin/env rdmd
  import std.stdio;

  struct X { int[] a; }

  void main() {
      X test;
      test.a.reserve(3);
      auto a = test.a;
      a ~= [1, 2, 3];
      test.a.length = 3;//直接赋值长度,重新改变了
      writeln(test.a); // [0,0,0]
      writeln(a); // [1,2,3]
      writeln(typeid(a)); // output: int[]*
        //说明,a为数组指针.
  }//操作,然后赋值回

r为指针,d没有引用类型,r的真正类型为整[]*,
//对每个(针,数组)的改变,都不变影响另一个.但对针的改变会相互影响.因为开始时两个针指向相同地址.
可以这样:*r ~= Y(10.0); * 为解引用

int[] a = [0, 1, 2];
int[] b = a;//b==a,但b与a互相不是另一个的引用
//更新`已存在的量`会反射到另外一个.
a ~= 10;
assert(a.length == 4);
assert(b.length == 3);

writeln(a); // prints [0, 3, 2, 10];
writeln(b); // prints [0, 3, 2];
//对(针,数组)的改变,则不会,根据是否分配内存,针指向同一地址.其实应该就是在还未分配前的一段空的空间里面,应该是针与针还是一样的

假定安全附加告诉运行时,你想重用数组背后的已存在内存块.附加时,没必要重新分配内存.
你能直接按引用调整数组吗?

void myAlgo(ref Y[] arr) {
    arr ~= Y(10.2);
}

按引用或指针,并直接操作数组?:

void myAlgo(ref X x) {
    x.a ~= Y(10.2);
}