import std.stdio;

struct S(T)
{
  T[] dinamikDizi;
  alias dinamikDizi this;

  /// Bunlar >>
  alias potentialSize = limit;
  size_t limit() { return dinamikDizi.capacity; }

  alias dataSize = size;
  size_t size() { return dinamikDizi.length; }
  /// gereksiz  ---^

  ref T opIndex(size_t index)
  {
    if(index >= dinamikDizi.length)
    {
      dinamikDizi.length = index + 1;
    }
    return dinamikDizi[index];
  }
}

///   **** 1. BÖLÜM ****
// Literal String(cümle)'den
// Static Array(verim)'e...
// verim'den dilim'e (10 karakterlik)
// dilüm'den ekrana ama sonraki bölüm fena :)

///   **** 2. BÖLÜM ****
// Stack Structure(stack) sayesinde
// Dynamic Array(dinamikDizi) ve doğrudan
// verim dizisi değiştirilerek eşit olmadığı
// kanıtı (assert(!))

///   **** 3. BÖLÜM ****
// Index Operator Overloading(opIndex) ile
// kapasitesi büyüyebilen(*) yapı dinamik dizi
// anlayışını bir üst seviyeye çıkarma

// alias dinamikDizi this; ile dilimleme ve
// birçok dizi olanağı aşırı yüklemesiz kullanabilme
// foreach() ve copy() ile aralık erişimi aynı şekilde
///

enum cümle = "C Language Foundation";
void main()
{
  char[cümle.length] verim;
  char[] dilim = verim[0..10];
  foreach(i, chr; cümle) verim[i] = chr;

  ///

  S!char stack;
  foreach(i, chr; dilim)
  {
    stack[i] = chr;
    chr.writeln(": ", stack.potentialSize);
  }
  verim[0] = 'D';

  stack.writeln(": ", stack.length);
  dilim.writeln(": ", dilim.length);

  import std.algorithm : equal;
  assert(!dilim.equal(stack));

  ///

  const next = stack.length;
  foreach(i, chr; cümle[next..$])
  {
    stack[i + next] = chr;
    chr.writeln(": ", stack.potentialSize);
  }
  dilim = stack.dinamikDizi[0..10];

  stack.writeln(": ", stack.length);
  dilim.writeln(": ", dilim.length);

  ///

  import std.algorithm.mutation : copy;
  auto test = new char[cümle.length];

  stack.copy(test);
  test.length.writeln; // 21
  test.capacity.writeln; // 31
  test.writeln; // C Language Foundation
}

Merak eden olursa, ekstra açıklama sonra...

On Saturday, 22 July 2023 at 05:09:13 UTC, Salih Dincer wrote:

Forum cortladığından beri paylaşmak için fırsat kolluyordum, kodu dinamikDizi.capacity'i kullanacak şekilde değiştirdim. Amacım, RangeError hatası almadan diziyi otomatik genişletmek ve taşımaya rağmen dilimin diziyi takip etmesiydi. Tüm testleri ile birlikte işte çalışan kod:

import std.array, std.range : iota;
import std.stdio, std.format;

void main()
{
  //with( new Outter(1.iota(9).array) )/*
  auto arr = new int[8];

  arr.length.writeln(" @", arr.ptr);
  with( new Outter(arr) )//*/
  {
    toString.writeln;

    array[0] = 10;
    fm[1] = 11;
    fm.writeln("<- slice");

    array[6] = 77;
    fm[7] = 88;
    array.writeln("<- array");

    fm[88] = 77;
    fm.writeln("<- slice");
    array.writeln;

    assert(array[88] == 77);
    array.ptr.writefln!"@%s";

    array[7] = 777;
    fm.writeln;
  }
}

class Outter
{
  int[] array;
  AutoExpand!int fm;

  this(R)(R[] array)
  {
    this.array = array;
    this.fm = new AutoExpand!int(8);
  }

  class AutoExpand(T)
  {
    T[] memory;

    this(size_t limit)
    {
      memory = array[0..limit];
    }

    ref T opIndex(size_t i)
    {
      if(i >= array.length)
      {
        array.length = i + 1;
        array.length = array.capacity + 1;
        if(memory.ptr != array.ptr)
        {
          // refresh slice
          memory = array[0..memory.length];
          array.length.write;
          writeln(" @", memory.ptr);
        }
      }
      return array[i];
    }

    override string toString()
    {
      return format("%s, %s", memory.length,
                              memory);
    }
  }

  override string toString()
  {
    return format("%s @%s, Capacity: %s", array.length,
                                          array.ptr,
                                          array.capacity);
  }
}