Merhaba,

Aşağıda bir garip yığıt yapısı ve hemen altında deneme kodu yer almakta...:)
Kısaca;

• Bu yapıyı bir dizi gibi hayal etmeliyiz. Ama kuramsal olarak başlangıç ve bitiş değerleri sonsuz!
• Başlangıç (daha doğrusu sol kenar boşluğu ~ offset), bizim tarafımızdan kurulurken belirleniyor.
• Sağ tarafı (dizinin devamı) ise boşluk ve değerleri de her zaman sıfır olmak zorunda,
• Çünkü bunlar (sol ve sağı veya alt ve üstü) sanal değerler ve olmayan bu değerlere erişilirken dizi gibi hata vermiyor...
• Doğal olarak hata vermemesine karşın hiç bir değere de eşitlenemiyor...:)

Dedik ya bir garip yığıt ama yerine göre çok işe yarayabilir...

struct birGaripYığıt
{
   private:
       int[] stack;
       size_t _Index;
       size_t _Offset;

   this (size_t realLen, size_t diffLen = 0)
   {
       stack = new int[realLen];
       _Offset = diffLen;
       //_Index = index();
   }

   public size_t index() @property
   {
       return stack.length + _Offset -1;
   }

   public void set(size_t len, int data) @property
   {
       if((len >= _Offset) &
          (len <= index()))
       {
           stack[len - _Offset] = data;
       }
   }

   public int get(size_t len) @property
   {
       if((len >= _Offset) &
          (len <= index()))
       {
           return stack[len - _Offset];
       }
       return 0;
   }
   enum empty = false;

   void popFront()
   {
       _Index++;
   }

   int front()
   {
       return get(_Index);
   }
}

import std.stdio;
void main() {
   int[] testArray = [ -3, -2, -1, 0, 1, 2, 3 ]; // 4 <-- SONRADAN EKLENEN VERİ
   // YAZILMAYAN VERİ -------------^  ^------- YAZILAN VERİ
   with(birGaripYığıt (10, 4))
   {
       index().writeln;               // kurucu parametre toplamlarının 1 eksiği
       foreach(index, data; testArray)
       {
           set(index, data);          // test dizisini yapıdaki diziye yerleştir
       }
       get(4).writeln;                // yapının gerçek ilk elemanını döndürür
       set(index(), 4);
       get(index()).writeln;          // yapının gerçek son elemanını döndürür
   }
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli):

>     int[] opSlice()
>     {
>         return stack;
>     }
> ```

>
opSlice ile döndürülen dizi sanal elemanlara sahip olmayacağı ve sonsuza gitmediği için bu yapıda işimize yaramayabilir.

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Doğru olmayan bir şey var ki o da take()'i kullanamamış olmam. Sebebini anlayamadım, şöyle bir hata alıyorum:
Alıntı:

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Çok teşekkürler...
http://img407.imageshack.us/img407/2017/smileythanks.jpg

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Yani elemanların ortasında yazılabilen bir bölge var. Aslında bu bölgenin dışına da yazılabiliyor ama o işlemlerin etkileri yok.

• İsimleri daha iyi seçebiliriz. Örneğin set() ve get()'in parametreleri 'len' değil de 'index' olacak galiba, değil mi? Çünkü sanırım onlara bir uzunluk değeri değil, bir konum değeri veriyoruz.

• Bu konuyla tam ilgili değil ama InputRange işlevlerini bu tür üstünde tanımlamak yerine bunun bir aralığı üstünde tanımlamak daha iyi olur. Bunun nedeni, bu bir topluluk. Birisi elemanlar üzerinde gezindi diye eleman kaybetmemeliyiz. Tabii kullanım amacına göre öyle olmayabilir de. Ben topluluklarla aralıkların böyle bir ayrımları olması gerektiğini yakın zaman önce farketmiştim. Topluluk yerinde durmalı ve istendikçe elemanları üzerinde gezinmeyi sağlayan aralıklar döndürmeli.

Bu da opSlice() ile çok kolay. empty, front ve popFront() yerine yalnızca şu işlevi yazmak yeterli:

   int[] opSlice()
   {
       return stack;
   }

foreach döngüsü, opSlice() işleci bulunan türlerde bu işleci de kullanabilir. (Sanırım bunu daha önce konuşmuştuk: TDPL bu olanağı anlatıyordu ama dmd eskiden sağlamıyordu.)

Böylece aralık olarak kullanıldığında _Index'in değeri artmadığı için topluluk eleman kaybetmemiş olur. Ama dediğim gibi, yanlış anlıyor olabilirim; sen de tam da kullandıkça baştan kısalmasını istiyorsundur. :)

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Doğru! :)

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

InputRange işlevlerini 'public' yapınca çalışıyor.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu iletiyi okuyanlar iki şey rica etsem yapar mısınız?

Şu garip yığıtı bir test etseniz çünkü önceki halinde gerçekten garip tavırları vardı...:)

Hoş zaten garip olduğu için henüz netleşmeye davranışları sergilediğini farkettim. Yani hata değil ama aşağıda yer alan yeni sürümü birlikte netleştirebilir miyiz?

struct Stack(T) {
   private:
       T[] stack;
       T empty_stack_cell;
       size_t _Index;
       size_t _Offset;

   this(size_t realLen, size_t diffLen = 0) {
       stack = new int[realLen];
       _Offset = diffLen;
   }

   size_t length() @property {
       return _Index;// - _Offset;
   }

   ref T set(size_t len) @property {
       _Index++;
       if((len >= _Offset) &
          (len <= _Index))
       {
           return stack[len - _Offset];
       } //else _Index--;
       return empty_stack_cell;

   }

   T get(size_t len) @property {
       if((len >= _Offset) &
          (len <= _Index))
       {
           return stack[len - _Offset];
       }
       return 0;
   }
}

import std.stdio;
void main() {
   int[] testArray = [ -3, -2, -1, 0, 1, 2, 3 ]; // 4 <-- SONRADAN EKLENEN VERİ
   // YAZILMAYAN VERİ -------------^  ^------- YAZILAN VERİ
   with(Stack!int(16)) {
       length.writeln;
       foreach(i, data; testArray) {
           set(i) = data;
       }
       length.writeln;
       set(length) = 4;
       stack.writeln;
       length.writeln;
   }
}

Ayrıca garibee bir kardeş geldi ismi gamsız, kod adı Infinity Stack..:D

Bu arkadaş henüz bebecik ve belki hala ana karnında! Doğmuş bile sayılmayan aşağıdaki örneği de denerseniz ikinci rica ettiğim şeyi görmüş olacaksınız. Yapmak istediğim dizi tükendiğinde index'i sona (arr.length - 1) alıyorum. Böylece ötekine benzer ama hiç bir zaman dolup taşmayan bir dizi elde ediyoruz. Sanırım oldu test ederseniz sevinirim...

struct iStack(T) {
   T[] arr;
   int len;

   this(int realLen) {
       arr = new int[realLen];
       len = realLen;
   }

   ref T equ() @property {
       if(--len < 0) len = arr.length - 1;
       return arr[len];
   }
}

import std.stdio;
void main() {
   int[] testArray = [ -3, -2, -1, 0, 1, 2, 3 ]; // 4 <-- SONRADAN EKLENEN VERİ

   auto veri = iStack!int(5);
   foreach(data; testArray) {
       veri.equ = data;
       veri.arr.writeln;
   }
   foreach(i; 0..10) veri.equ.writeln;

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Estağfirullah hocam.

Asıl hata benda; bir şeyi bitirmeden hemen diğerine geçebiliyorum. Bu sizde de var mı bilmyorum ama bir şeyle çok muhatap olunca sıkılıyor insan. Araya başka bir şey sokunca takıldığı şeyden de kurtuluyor; sıkıntısında da! Tabi bu sefer özyinelemeli işlevler (recursive function) gibi iyi bir hafıza istiyor...:)

Eee, gülü seven dikenine katlanır veya hamama giren terler diyelim...

Alıntı (acehreli):

Bu soruyu bende sordum ve karar veremedim! Üstelik bu ilk sürümde (iletide) yoktu. Sonradan ekledim çünkü index() işlevi ile (şimdi length oldu...) uzunluğunu alıyordum ve bana offset (diğer kenardaki dikkate alınmayan boşluk) ile toplayıp sanal uzunluk değerini veriyordu. Eee, haliyle diziye yazılan son elemanın konumunu öğrenemiyordum. Sanırım burada ciddi bir index ile length karmaşası var...:)

Alıntı (acehreli):

Yerden göğe kadar hakkın var, işte o yüzden son yığıtımızda (Gamsız) bunu kullanmadım. Sanırım with() kullanımını abartmamak gerekiyor.

Alıntı (acehreli):

Evet bu aile (Gamsız, Garip ve öteki büyük yığıta Gizem adını taktım) tam anlamıyla yığıt. Çünkü ilgili işlevleri ile (arr, set, push) sahip olduğu diziye, üst üste olacak şekilde bilgileri yazıyor. Ama Garip ve Gamsız'da özel, belki de garip bir durum var. Bunu yığıttan bağımsız özellik diyebiliriz. Bilemiyorum, belki çıkarmalıyım ama istiyorum ki diziyi (yığıtı) boşaltmadan da index yolu ile erişmek.

Kısaca bunlar özel yapıda diziler olarak düşünebiliriz Yığıt gibi ama sorgusuz suhalsiz veri alsın ama dizi boyutu taştığında veya olmayan bir index'e erişildiğinde laga luga etmesin...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

'Önemli Not:'
Bu yığıtların (dizilerin) hata atmaması (ben buna laga luga diyorum) önemli. Zaten o yüzden varlar. Biz bunları kullandığımız döngü içinde sınırlarını ve davranışlarını bildiğimiz için taşma durumlarını dışarıda tahmin edebiliyoruz. Ama kararlı çalışmaları gerekli yoksa yanlış kullanımda bu sefer gerçekten garip sonuçlar doğurabilir...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]