On Saturday, 11 June 2022 at 15:01:05 UTC, Ali Çehreli wrote:

import std.stdio;

void main() {
  enum X = 2;
  enum Y = 3;
  enum Z = 4;

  int[X][Y][Z] s;
  int[X][Y][] d = new int[X][Y][Z];

  pragma(msg, typeof(s));
  pragma(msg, typeof(d));
}

Merhaba Hocam,

Şimdi ben İngilizce iyi ifade edememiş olabilirim ya da ne bileyim Z ismindeki belirsiz kişi farklı bir şeyi de kastetmiş olabilir. O yüzden Türkçe yazayım istedim...

Eğer aynı şeyleri bahsediyorsak ki ben "in reverse" dedim üçlü örneğimiz kısaca şöyle:

   enum { X = 2, Y = 3, Z = 4 }
   auto d = new bool[X][Y][Z];

   d[X][Y][Z] = true; /* array index 3 is out of bounds `d[2][0 .. 3]`
   hatasını alırı çünkü erişimde yer değiştiriyorlar */

Örnek Y ortada olduğu için, sadece X ile Z yer değiştirmiş oluyor ve X, Z'den küçük olduğu için erişilemeyen bir yeri true yapmaya çalışıyoruz...

Siz Türkçe şurda mealen şöyle dediniz:

Ben de "öyle düşünüyorum, katılıyorum" demek istedim ve şöyle devam ettim:

Sayenizde --consistent--v sözcüğünü de öğrendim!

void main()
{
  enum
  {
    Row = 2,
    Column = 3
  }
  size_t cal = Row * Column * int.sizeof;
  auto alloc = new ubyte[cal];
  size_t m = Column * int.sizeof;

  int[][] aSlice;
  foreach (i; 0 .. Row)
  {
    size_t n = i * m;
    aSlice ~= cast(int[])alloc[n .. n + m];
  }
  auto row = 2;
  auto column = 3;
  aSlice[row-1][column-1] = 1; // last element

  assert(
    *( &aSlice[0][0] // first element pointer
     + (row * column - 1)
     )
  ); // no error...


  //If you want to see it with your eyes:
  import std.stdio;
  aSlice.writefln!"%-(%-(%s %)\n%)";
}

Tamam, epey karışık ama bu daha önce birlikte geliştirdiğimiz bir işlevdi...

Yukardaki örneğimde, bellekteki adresleri kesinlikle ardı ardına olacak şekilde çift boyutlu (tamam buna itirazınız var ama söylenmesi kolay) erşiyoruz. Kurarken 2 satır ve 3 sütun kuralına uyduk ve pointer hesabı yaparak en sondaki 1 (true) yapıyorum. Çıktısını son satırda gözlerimizle görüyoruz. Ama eğer aynı parametreleri yer değiştirmeden kursaydık indekslerin 0'dan başlamasını da dikkate alarak son elemana şöyle ulaşırdık:

  auto birDizi = new bool[Row][Column];
  birDizi[2][1] = true; // hata vermez

Evet hata vermez çünkü biz derleyicinin diziyi kurarken, parametreleri tersten okumasını dikkate aldık ve 2. satırın 3.'ü elemanına eriş demedik ama biz Excel'deki gibi ABC yani üç sütun(column) istiyorduk neden 2 oldu!

Neyse, bu kadar kelam yer değişikliğini anlatmak içindi. Sanırım C'de de böyle. Tek farkı köşeli parantezin değişken isminin yanında olması.

Sevgiler, saygılar...

Merhaba,

Bu konu ya öyle hızlıca kapanmayacak (çünkü benim az önce netleştirdiğim şeyler var) ya da neredeyse tüm olasılıklara bakarak zaten kapatmak üzereyiz. Çıkış noktamız new operatörü ile kurulma tekniklerini anlatan şu sayfa:

https://dlang.org/spec/expression#new_multidimensional

Ancak dikkat, burada çok boyutlu diziler (Multidimensional Arrays) olarak nitelendirilen diziler dizisi, aşağıdaki spec'te, dikdörtgen diziler (Rectangular Arrays) olarak başlıklanırken daha çok işaretçilerin böldüğü (array of pointers to array) nitelendirilmiş...

https://dlang.org/spec/arrays.html#rectangular-arrays

Konu FORTRAN'dan başlayıp tırtıklı (jagged) diyebileceğimiz türde dizilere (hoş, aşağıdaki örneklerde bunu yapabilirdik) kadar uzuyor:

https://wiki.dlang.org/Dense_multidimensional_arrays

Buradaki konu başlığı her ne kadar statik diziler olsa da şu örneklerin biri (B maddesindeki 2 örnek) dışında her şey dinamik. O dizi sonuna (statik ve [2] birimlik olmak kaydıyla) ekleme bile yapabiliyorsunuz:

void printArray(Multi)(ref Multi arr)
{
  arr.writefln!"%-(%-(%12s %)\n%)";
  foreach(ref row; arr) {
    foreach(ref column; row) {
      write(&column, " ");
    }
    writeln;
  }
}
/* KISALTMALAR:
  =============
  - tür: tüm testin yapıldığı değişken (type)
  - sat: ilk baytın yerleştiği kısım (row)
  - süt: kaç adet (kısım x n) olacak (column)

  Açıklama: Kısım, aslında dizi ve tür.sizeof'dan
  sonra gelen en küçük birim. Çok boyutlu dizi ise
  dizi dizisi, yani en büyük birim.
 */
void main()
{
  alias tür = ubyte;

// A- 2 sat, 3 süt parantezli kurulum:

  auto satSüt = new tür[][](2, 3);
       satSüt[0][] = tür(1); // ilk satır 1 x 3

       satSüt[0].length = 4; /* dikkat: İlk kısım
       genişletilebiliyor! */

       satSüt.printArray;

  typeid(satSüt).writeln; // ubyte[][]

// B- öncekinin tersi sıralanan kurulum:

  auto sütSat = new tür[2][3];

       sütSat ~= [4, 4]; /* dikkat: dikey genişler
       ve statik dizilerin dizisidir */

       sütSat.printArray;
  typeid(sütSat).writeln; // ubyte[2][]

// C- Bu da aslında A'nın eşdeğeri (küçük a):
  auto a = new tür[][2];
       foreach(ref b; a)
       {
         b = new tür[3];
       }
       a.printArray;
  typeid(a).writeln;

Örneklerde işaretçilerin adrelerini ve içeriğini görebiliyorsunuz. Bunu bize sağlayan printArray() ve her şeyi değiştirerek istediğiniz gibi emin olmanız mümkün. O yüzden ben çok şey yazıp uzatmayacağım. Ancak dikkat çeken özellikle 2. örnek yani kısmen statik daha çok statik dizilerin dizisi, yanılıyor olabilir miyim?

On Saturday, 11 June 2022 at 16:26:18 UTC, Ali Çehreli wrote:

Yukarda verdiğim 2. adresin 3. notunda "opposite orders" yazıyor. Acaba konuştuğumuz şey bu mu?

Teşekkürler...