Şimdi hatırlardım, çıkarsama yapacak veri olmadığı için hata veriyor. Çünkü aşırı yükleme (overload) yapıyoruz.

Denemek isteyen için çalışmayan sınıf:
Alıntı ("ÇALIŞMAYAN KOD"):

>   class içİçeDizi(T) {
>     union {
>       T     x; // tek değerli herhangi bir tür
>       T[]   y; // tek boyutlu herhangi bir tür
>       T[][] z; // iki boyutlu herhangi bir tür
>     }
>     ref T opCall() { return x; }
>     ref T[] opCall() { return y; }
>     ref T[][] opCall() { return z; }
>   }
> ```

>

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

Paylaştığın için teşekkürler. Gerçekten çok ilginç olanaklar. :)

Ali

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

Çok ilginç bir tür olmuş ama çözüm değil:

• Hep aynı tür olmak zorunda

• En fazla iki boyutlu tür kullanılabiliyor

İndeksin değer olarak kullanılması da ilginç olmuş. Olası yanlışlıkları gizleyecektir ama belki yararlı kullanımları da vardır.

Ali

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

Merhaba,

Evet, maalesef verinin türüne erişemiyor, geri döndüremiyorum. Ama çok amatörce sınıfa şöyle bir işlev ekledim:

   void tekrarYaz() {
       if(hangisi == 'x') x.writeln;
       if(hangisi == 'y') y.writeln;
       if(hangisi == 'z') z.writeln;
   }

Bu sayede dizi boyutunu vererek (örn: dizi[1].tekrarYaz;) veri ekrana geliyor. Tabi her işlev içine hangisi'ne bir harf eşitlemek gerekiyor. Dedim ya çok amatörce ama kaput olduğumuzun resmi de! Çünkü ekrana yazılan şeyi tür olarak ana programa geri döndüremiyorum. Adeta kapalı kutu ve bu sınıflar tür bilgisini kendisine saklıyor. Sanki ilk sayfanın sonlarına doğru verdiğim örnekten bir adım öteye gidememişim...:)

Başarılar...

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

Tekrardan çok teşekkür ediyorum Salih ve Ali hocam.
Yazdıklarınızı değerlendiriyorum gerçekten çok faydanız oldu bana.

Daha çok visual basic, python, php gibi dillerle uğraştığım için bu veri türleri ve yapıları oldukça karışık geliyor bana açıkcası :)

Bu yüzden anlamam biraz yavaş oluyor kavramlar çok uzak geliyor ama gerçekten faydası oluyor.

Son bir soru daha Associative Arrays için a in b gibi a nın b nin içinde olup olmadığını kontrol edebiliyoruz. Normal arraylar için bunun gibi birşey var mı?

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

Alıntı (Salih Dinçer):

Çok doğru yapmışsın. Ama var olmayan indeks değeri bile kullansak kabul ediyor. Dolayısıyla programcının hatasını gizliyor! Programda hata var, yanlış indeks değerleri üretiyoruz buna rağmen sessizce kabul ediyor.

Ayrıca, indeks diye kullanılan değer indeks (yani konum) değil, verinin kendisi olarak kullanılıyor:

   T opIndex(T t) {
     x = t;
     return x;
   }

t'yi veri olarak kullandık. Hani indeksti? Bence bu çok yanıltıcı olur. Herhalde ~ ve ~= işleçleri daha uygun olur. O zaman indeks işlecini gerçekten konum olarak kullanabilirsin.

Belki yanıtı verildi ve ben kaçırdım ama en sonunda bu veriyi nasıl kullanmak istiyoruz? Baştan sona ilerlerken elemanlarla teker teker ne yapmak istiyoruz? T, T dizisi, veya T dizisi dizisi olduklarını nereden bileceğiz?

Ali

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

Alıntı (zekeriyadurmus):

Senin sorunun da bize çok faydası oldu. Deneysel alemlere kaydık. :-p

Alıntı:

Bu bir arama (find) konusu... Bunun bir çok yolu var.

Eğer dizideki elemanlar baştan sıralanmış iseler, bunun en hızlı yolu ikili aramadır. Şöyle bir kod:

import std.stdio;
import std.range;
import std.algorithm;
import std.random;

int[] sıralıDizi(int uzunluk)
{
   return
       iota(0, uzunluk)
       .map!(a => uniform(0, uzunluk))
       .array
       .sort;
}

void main()
{
   enum size_t uzunluk = 100;
   auto dizi = sıralıDizi(uzunluk);

   /* Elimizde zaten sıralanmış olan bir dizi olduğunda bunu program dilinde
    * ifade etmenin yolu, assumeSorted'ı çağırmaktır. assumeSorted(),
    * SortedRange şablonu döndürür ama tam türünü bilmek zorunda
    * değilizdir. */
   auto kesinSıralıAralık = assumeSorted(dizi);

   /* Bazı Phobos algoritmaları SortedRange'i tanıdığından ve böylece
    * aralığın sıralı olduğu kesin bilindiğinden, bu noktadan sonra o
    * algoritmalar daha hızlı işlerler.
    *
    * Bu algoritmalardan birisi equalRange()'dir; verilen kıstasa uyan
    * "ortadaki" aralığı verir: */
   auto aranan = uzunluk / 2;
   {
       writeln("\n--- equalRange() ile ---");
       auto sonuç = kesinSıralıAralık.equalRange(aranan);

       if (sonuç.empty) {
           writefln("%s aralıkta bulunamadı", aranan);

       } else {
           writefln("Sonuç: %s", sonuç);
       }
   }

   /* Dizinin sıralı olup olmadığını bilmiyorsak o zaman dizilerde "sırayla
    * arama" algoritmasını uygulayan find()'ı kullanabiliriz. */
   {
       writeln("\n--- find() ile ---");
       auto sonuç = dizi.find(aranan);

       if (sonuç.empty) {
           writefln("%s aralıkta bulunamadı", aranan);

       } else {
           writefln("Şu noktada bulundu: %s", sonuç);
       }
   }
}

equalRange()'den başka hızlı algoritmalar da var ama bunlar hep dizinin sıralanmış olmasına dayanıyorlar. (Yani, assumeSorted()'un çağrılmış olması gerek.)

Ali

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

Alıntı (acehreli):

Söylemeyi unutmuşum ama sırayla aramanın karmaşıklığı O(N)'dir ve ikili aramanın karmaşıklığı O(log N)'dir. Örneğin, 4 milyar eleman arasında sırayla ararken milyarlarca karşılaştırma gerekirken, ikili aramada 32 karşılaştırma yeter.

Ali

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

Alıntı (acehreli:1351532018):

>     // Kurucu bir veya daha fazla komutla başlayabilir
>     this(Komut[] komutlar...)
>     {
>         /* Not: Burada daha normal olarak şöyle yazabilmek isterdim:
>          *
>          *     this.komutlar = komutlar;
>          *
>          * Öyle yapınca program parçalama hatası veriyor çünkü "..." ile
>          * işaretlenmiş olan parametre gereğinden erken sonlandırılıyor. Bence
>          * öyle olmamalı. Araştıracağım ve gerekirse bir dmd hatası açacağım.
>          *
>          * Ama ~= işleci çalışıyor:
>          */
>         this.komutlar ~= komutlar;
>     }
> ```


Yukarıda neden 'this.komutlar = komutlar' yapılamadığını bugün öğrendim. Bu konu dilin tanımında 'Typesafe Variadic Functions' başlığı altında geçiyormuş:

 <http://dlang.org/function.html#variadic>

Orada yazdığına göre, belirsiz sayıda parametre alan işlevlere gönderilen parametre değerleri program yığıtında yaşayabilirlermiş ve o yüzden de kısa ömürlü olabilirlermiş:

Alıntı:
> An implementation may construct the object or array instance on the stack. Therefore, it is an error to refer to that instance after the variadic function has returned:

this.komutlar'ın içine ~= işleci ile eklenmeleri (kopyalanmaları) o yüzden doğru oluyor.

Ali

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

Anlamıyorum...:)

Ben de niye tersi çalışırken, yukarıdaki örnekten çalışan çalışmıyor? Çünkü ben de belirsiz sayıda parametre alıyorum:

 class içİçeDizi(T) {
   union {
     T     x; // tek değerli herhangi bir tür
     T[]   y; // tek boyutlu herhangi bir tür

   :    :    :

   T[] opCall(T[] t...) {
     y = t;
     return y;
   }

   :    :    :

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