Problem çözümlerini vermediğim 6 ders kalmış:

http://ddili.org/ders/d/siniflar.html
http://ddili.org/ders/d/tureme.html
http://ddili.org/ders/d/object.html
http://ddili.org/ders/d/gostergeler.html
http://ddili.org/ders/d/bit_islemleri.html
http://ddili.org/ders/d/foreach_opapply.html

Çok mu kolay? Çok mu zor? Ne oluyor? Deneyen var mı? :)

Ali

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

Bana zor gibi geldi :-)

Sırasıyla yanıtlamaya başlayayım:
Sınıflarla ilgili soruların bana göre yanıtları :

1. Soru : sayılar ve çiftler dizinide aynı nesneye erişim sağlıyor. Burada çiftler sayıların dilimi.
   (Ayrıca sınıflar referans olduğu için foreach ile değerleri değiştirilebiliyor.)

2. Artık aynı nesneye değil farklı nesneye erişim sağlıyor. Burada çiftler sayıların dilimi değil.

3. Yapılar sınıflar gibi referans değil. Bu yüzden kopyaya erişiyor ve kopyayı değiştiriyor.

Yanıtlardan emin değilim :-) Hocam sorular zordu B kitapçığı daha kolay idi :-P

Şimdi Türemeye bakayım :
1.sorunun istediği kodu yazdım çok eğlenceli idi :-) :

import std.cstream;

class DemirYoluAracı
{
   void ilerle(in int kilometre)
   {
       dout.writef(kilometre, " kilometre: ");

       foreach (i; 0 .. kilometre) {
           dout.writef(ses(), ' ');
       }

       dout.writefln();
   }
   abstract string ses();
}

class Drezin : DemirYoluAracı
{
   override string ses()
   {
       return "of puf";
   }
}
class Vagon: DemirYoluAracı
{
   override string ses()
   {
       return "takıtak tukutak";
   }
}
class Lokomotif: DemirYoluAracı
{
   override string ses()
   {
       return "çuf çuf";
   }
}

void main()
{
   auto drezin = new Drezin;
   drezin.ilerle(2);

   auto vagon = new Vagon;
   vagon.ilerle(3);

   auto lokomotif = new Lokomotif;
   lokomotif.ilerle(4);
}

2.Soru void main() şu hale gelirse iş çözülür :

void main()
{
   auto lokomotif = new Lokomotif;
   auto tren = new YolcuTreni;
   tren.lokomotif=lokomotif;
   tren.ilerle(1);

}

Yada sizin problemde verdiğiniz fikri uygulamazsak yine çözülür. İlk sizin verdiğiniz fikri uygulamadım baktım parçalama arızası vermiyor :-D Ondan sonra anladım ki sizin verdiğiniz fikirden gitmek gerekiyorki hatayı alalım ve hatayı düzeltelim:

Bu arada sizin bütün kodları vermemişsiniz. Derslerden topladım kodları çok oldu :-)

Diğer mesajda diğerlerine bakarım.

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

En baştan problemleri çözmeye başlayacağım.

Zaten geriye kalan çözümsüz problemleri çok çözmek istemiyorum. Bit işlemleri matematiktede çok az mantık adıyla görmüştük sanırım. Hiç sevmem :-) Düşük almıştım :-P (Programlama dilinden olayları bildiğim halde :-P )

Göstergeler. Çözebilirim ama göstergeleride sevemedim :-) Özellikle işlev göstergeleri ve kapamalar. Dersi okudum ama pek anlayamadım. Ve ikinci kez dersi bile okuyamıyorum. Yarısında sıkılıyorum. Onlar için örnek kodlara bakarak anlamam gerekir herhalde.

Diğerleri zaten işleç yükleme ile ilgili ve gidiciler :-)

İlk çözüme sizin sevdiğiniz sorudan başlayacağım.

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

Object dersinin sorularını çözüyorum :

1. Soru :

void main()
{
enum Renk { mavi, yeşil, kırmızı };

class Nokta
{
   int x;
   int y;
   Renk renk;

   this(int x, int y, Renk renk)
   {
       this.x = x;
       this.y = y;
       this.renk = renk;
   }

   override bool opEquals(Object o)const
   {
       auto sağdaki = cast(const Nokta)o;
       return((x == sağdaki.x)&&(y == sağdaki.y));
   }
}

   // Renkleri farklı
   auto maviNokta = new Nokta(1, 2, Renk.mavi);
   auto yeşilNokta = new Nokta(1, 2, Renk.yeşil);

   // Yine de eşitler
   assert(maviNokta == yeşilNokta);

}

2.Soru :

void main()
{
enum Renk { mavi, yeşil, kırmızı };

class Nokta
{
   int x;
   int y;
   Renk renk;

   this(int x, int y, Renk renk)
   {
       this.x = x;
       this.y = y;
       this.renk = renk;
   }
   override int opCmp(Object o)const
   {
       auto sağdaki = cast(const Nokta)o;
       if(x != sağdaki.x ) {
           return x - sağdaki.x;
       } else {
           if ( y != sağdaki.y ) {
               return y - sağdaki.y;
           } else {
               return 0;
           }
       }
   }



}

   auto maviNokta = new Nokta(1, 2, Renk.mavi);
   auto yeşilNokta = new Nokta(1, 2, Renk.yeşil); //Gereksiz.


   auto kırmızıNokta1 = new Nokta(-1, 10, Renk.kırmızı);
   auto kırmızıNokta2 = new Nokta(-2, 10, Renk.kırmızı);
   auto kırmızıNokta3 = new Nokta(-2,  7, Renk.kırmızı);

   assert(kırmızıNokta2 < maviNokta);
   assert(kırmızıNokta3 < kırmızıNokta2);
}

3.Soruyu daha çözemedim. Geldiğim yer :

void main()
{
       enum Renk { mavi, yeşil, kırmızı };

   class Nokta
   {
       int x;
       int y;
       Renk renk;

       this(int x, int y, Renk renk)
       {
           this.x = x;
           this.y = y;
           this.renk = renk;
       }
       override int opCmp(Object o)const
       {
           auto sağdaki = cast(const Nokta)o;
           if(x != sağdaki.x ) {
               return x - sağdaki.x;
           } else {
               if ( y != sağdaki.y ) {
                   return y - sağdaki.y;
               } else {
                   return 0;
               }
           }
       }

       override bool opEquals(Object o) const
       {
           auto sağdaki = cast(const Nokta)o;

           return ((x == sağdaki.x)
                   &&
                   (y == sağdaki.y));
       }



   }
   auto maviNokta = new Nokta(1, 2, Renk.mavi);
   auto yeşilNokta = new Nokta(1, 2, Renk.yeşil);
   auto kırmızıNokta = new Nokta(1,2, Renk.kırmızı);



   class ÜçgenBölge
   {
       Nokta[3] noktalar;

       this(Nokta bir, Nokta iki, Nokta üç)
       {
           noktalar = [ bir, iki, üç ];
       }

       override bool opEquals(Object o) const
       {
           auto sağdaki = cast(const ÜçgenBölge)o;

           return ((noktalar[0] == sağdaki.noktalar[0])
                   &&
                   (noktalar[1] == sağdaki.noktalar[1])
                   &&
                   (noktalar[2] == sağdaki.noktalar[2] ));
       }

       override int opCmp(Object o) const

       {
           auto sağdaki = cast(const ÜçgenBölge)o;
           if ( noktalar[0] != sağdaki.noktalar[0]) {

               if (noktalar[0] > sağdaki.noktalar[0]) {

                   return 5;

               } else {

                   return -5;

               }

           } else {
               if( noktalar[1] != noktalar[1] ) {

                   if (noktalar[1] > sağdaki.noktalar[1]) {

                       return 5;

                   } else {

                       return -5;

                   }

               } else {
                   if( noktalar[2] != sağdaki.noktalar[2] ) {

                       if (noktalar[2] > sağdaki.noktalar[2]) {

                           return 5;

                       } else {

                           return -5;

                       }

                   } else {
                       return 0;
                   }
               }
           }

       }

       override hash_t toHash() const
       {
           // Yanlış buraya ne gelecek ki ? return noktalar[0] + noktalar[1] + noktalar[2];
       }

   }

}

**Bu arada başka bir sorum daha var : opCmp işleç yüklemesini tanımlarken opEquals işleç yüklemesinide tanımlamak gerekiyor diyor derste. Ama ben tanımlamadan derleyebiliyorum. **

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

Alıntı:

Tamam ben hatırlatırım :-)

Göstergeye gelince daha ilk soruda tıkandım. Derside okumak istemiyorum.

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

foreach'te opApply'den birinci soruyu yaptım(Unutmamak için yazıyorum.) :

import std.stdio;

void main()
{
   foreach (sayı; Aralık(0, 10, 2)) {
       write(sayı, ' ');
   }

}

struct Aralık
{
   int baş;
   int son;
   int atlama;
   this(int baş, int son, int atlama)
   {
       this.baş = baş;
       this.son = son;
       this.atlama=atlama;
   }


   bool empty() const
   {
       // baş, son'a eşit olduğunda aralık tükenmiş demektir
       return baş == son;
   }

   void popFront()
   {
       baş+=2;
   }

   int front() const
   {
       // Aralığın başındaki değer, baş'ın kendisidir
       return baş;
   }
}

2.soruda delegate anahtar sözcüğünü görünce daha dersi okumadan bıraktım. Artık yarın yapamadığım tüm soruları yapmaya çalışırım.

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

Teşekküüür! :)

Alıntı (canalpay):

Doğru.

Alıntı:

Doğru!

Alıntı:

Evet.

(Kolaylık olsun diye, şuradaki 2 numaralı problemle ilgili konuşuyoruz: http://ddili.org/ders/d/siniflar.html)

İkinci foreach içinde

eleman = new Sayı(uniform(0, 20));

yazınca, 'eleman' o noktada yeni bir Sayı nesnesine erişim sağlamaya başlıyor. Bu 'eleman''ın yaşamı çok kısa: yaşamı, döngünün kapama parantezinde son buluyor.

Alıntı:

Aslında 'çiftler' yine de aynı; onda bir değişiklik olmuyor. 'eleman', foreach içinde önce o dilimin bir elemanı ile aynı nesneyi gösterirken, biz 'eleman''ı yepyeni bir nesneyi göstermesini sağlayarak onun çiftler'le ilişkisini kesiyoruz.

Alıntı:

Doğru.

Alıntı:

D kitapçığı bile gelse yine de doğru yanıtlardın! ;)

Alıntı:

Sevindim! :) Benim en eğlendiğim problem mors kodu ile ilgili olandı. İşlevler dersinin

http://ddili.org/ders/d/islevler.html

2 numaralı sorusunun yanıtında şöyle bir tablo var: :D

string morsKarşılığı(char harf)
{
   string[char] morsAlfabesi =
   [
       ' ' : boşluk() ~ boşluk(),
       'a' : dıt()   ~ dıııt(),
       'b' : dıııt() ~ dıt()   ~ dıt()   ~ dıt(),
       'c' : dıııt() ~ dıt()   ~ dıııt() ~ dıt(),
       // ...

Benim hoşuma gitmişti... :)

Alıntı:

Yine kolaylık olsun diye, şimdi de şu dersin

http://ddili.org/ders/d/tureme.html

2 numaralı problemiyle ilgili konuşuyoruz.

Alıntı:

>
>
> void main()
> {
>     auto lokomotif = new Lokomotif;
>     auto tren = new YolcuTreni;
>     tren.lokomotif=lokomotif;
>     tren.ilerle(1);
>
> }
> ```


Doğru.

Sorun, Tren'in lokomotif üyesini ilklenmemiş, yani null olarak bırakmaktı. Aslında Tren'e bir kurucu işlev eklemek daha iyi olur:

class Tren : DemirYoluAracı
{
// ...
this()
{
lokomotif = new Lokomotif;
}
// ...
}

Böylece hem başka zamanlarda da unutulması önlenmiş olur, hem de kullanımı daha kolay olur.

Alıntı:
> Diğer mesajda diğerlerine bakarım.

Teşekkür! :)

Ali

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

Alıntı:

Hatırlatayım dedim :-) (http://ddili.org/forum/post/2264)
Sanırım doğru kodlamışsınız. Sizin toHash işlevinide ekledim ve soruda verilen assertleride ekledim ve hatasız çalıştı:

void main()
{
       enum Renk { mavi, yeşil, kırmızı };

   class Nokta
   {
       int x;
       int y;
       Renk renk;

       this(int x, int y, Renk renk)
       {
           this.x = x;
           this.y = y;
           this.renk = renk;
       }
       override int opCmp(Object o)const
       {
           auto sağdaki = cast(const Nokta)o;
           if(x != sağdaki.x ) {
               return x - sağdaki.x;
           } else {
               if ( y != sağdaki.y ) {
                   return y - sağdaki.y;
               } else {
                   return 0;
               }
           }
       }

       override bool opEquals(Object o) const
       {
           auto sağdaki = cast(const Nokta)o;

           return ((x == sağdaki.x)
                   &&
                   (y == sağdaki.y));
       }



   }
   auto maviNokta = new Nokta(1, 2, Renk.mavi);
   auto yeşilNokta = new Nokta(1, 2, Renk.yeşil);
   auto kırmızıNokta = new Nokta(1,2, Renk.kırmızı);



   class ÜçgenBölge
   {
       Nokta[3] noktalar;

       this(Nokta bir, Nokta iki, Nokta üç)
       {
           noktalar = [ bir, iki, üç ];
       }

       override bool opEquals(Object o) const
       {
           auto sağdaki = cast(const ÜçgenBölge)o;

           return ((noktalar[0] == sağdaki.noktalar[0])
                   &&
                   (noktalar[1] == sağdaki.noktalar[1])
                   &&
                   (noktalar[2] == sağdaki.noktalar[2] ));
       }

   override const int opCmp(Object o)
   {
       auto sağdaki = cast(const ÜçgenBölge)o;

       foreach (i, nokta; noktalar) {
           const int karşılaştırma =
               nokta.opCmp(sağdaki.noktalar[i]);

           if (karşılaştırma != 0) {
               return karşılaştırma;
           }
       }

       return 0;
   }



       override hash_t toHash() const
       {
           return typeid(noktalar).getHash(&noktalar);
       }

   }


   auto kırmızıNokta1 = new Nokta(-1, 10, Renk.kırmızı);
   auto kırmızıNokta2 = new Nokta(-2, 10, Renk.kırmızı);
   auto kırmızıNokta3 = new Nokta(-2,  7, Renk.kırmızı);

       /*
     Farklı ama aynı değerli noktalarla kuruluyorlar.

     Hatırlatma: maviNokta ve yeşilNokta değer olarak eşit
                 kabul ediliyorlardı.
   */
   auto bölge1 =
       new ÜçgenBölge(maviNokta, yeşilNokta, kırmızıNokta1);
   auto bölge2 =
       new ÜçgenBölge(yeşilNokta, maviNokta, kırmızıNokta1);

   // Yine de eşitler
   assert(bölge1 == bölge2);

   // Bir eşleme tablosu
   double[ÜçgenBölge] bölgeler;

   // bölge1 ile indeksleniyor
   bölgeler[bölge1] = 1.25;

   // bölge2 ile de aynı veriye erişiliyor
   assert(bölge2 in bölgeler);
   assert(bölgeler[bölge2] == 1.25);

}

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

Alıntı (canalpay):

Doğru. (Ama fazla kolaydı tabii... :p)

Alıntı:

>     override int opCmp(Object o)const
>     {
>         auto sağdaki = cast(const Nokta)o;
>         if(x != sağdaki.x ) {
>             return x - sağdaki.x;
>         } else {
>             if ( y != sağdaki.y ) {
>                 return y - sağdaki.y;
>             } else {
>                 return 0;
>             }
>         }
>     }
> ```


Ben de aynısını '?:' işleciyle daha kısa yazmışım:

override const int opCmp(Object o)
{
auto sağdaki = cast(const Nokta)o;

   return (x != sağdaki.x
           ? x - sağdaki.x
           : y - sağdaki.y);

}

Anlaşılan, o sıralarda 'const''ı işlev parametrelerinden sonra yazmaya karar vermemişim daha. Artık seninki gibi yazıyorum ama ondan önce kesin bir boşluk bırakırım. ;)

Alıntı:
>
> 3.Soruyu daha çözemedim. Geldiğim yer :
>
>

class Nokta
{

Bir şeye dikkat ettim: sen türleri main'in içinde tanımlamışsın. Zararı yok ve D buna izin veriyor ama normalde işlevlerin dışında tanımlanır. Eğer bir tür yalnızca tek işlev içinde kullanılacaksa, yani o kadar yerelse, o zaman tek işlevin içinde tanımlandığı da olur.

Alıntı:

>     class ÜçgenBölge
>     {
>         Nokta[3] noktalar;
>
>         this(Nokta bir, Nokta iki, Nokta üç)
>         {
>             noktalar = [ bir, iki, üç ];
>         }
>
>         override bool opEquals(Object o) const
>         {
>             auto sağdaki = cast(const ÜçgenBölge)o;
>
>             return ((noktalar[0] == sağdaki.noktalar[0])
>                     &&
>                     (noktalar[1] == sağdaki.noktalar[1])
>                     &&
>                     (noktalar[2] == sağdaki.noktalar[2] ));
>         }
> ```


Ben, sabit uzunluklu dizilerin bir özelliğinden yararlanmışım:

override const bool opEquals(Object o)
{
auto sağdaki = cast(const ÜçgenBölge)o;
return noktalar == sağdaki.noktalar;
}

Sabit uzunluklu diziler değer türü oldukları için, yukarıdaki basit karşılaştırma çalışıyor.

Alıntı:
>

    override int opCmp(Object o) const

    {
        auto sağdaki = cast(const ÜçgenBölge)o;
        if ( noktalar[0] != sağdaki.noktalar[0]) {

            if (noktalar[0] > sağdaki.noktalar[0]) {

                return 5;

            } else {

                return -5;

            }

        } else {
            if( noktalar[1] != noktalar[1] ) {

                if (noktalar[1] > sağdaki.noktalar[1]) {

                    return 5;

                } else {

                    return -5;

                }

            } else {
                if( noktalar[2] != sağdaki.noktalar[2] ) {

                    if (noktalar[2] > sağdaki.noktalar[2]) {

                        return 5;

                    } else {

                        return -5;

                    }

                } else {
                    return 0;
                }
            }
        }

    }

Benimki şöyleymiş:

   override const int opCmp(Object o)
   {
       auto sağdaki = cast(const ÜçgenBölge)o;

       foreach (i, nokta; noktalar) {
           const int karşılaştırma =
               nokta.opCmp(sağdaki.noktalar[i]);

           if (karşılaştırma != 0) {
               return karşılaştırma;
           }
       }

       return 0;
   }

Alıntı:

>
>         override hash_t toHash() const
>         {
>             // Yanlış buraya ne gelecek ki ? return noktalar[0] + noktalar[1] + noktalar[2];
>         }
>
>     }
>
> }
> ```


Ben şöyle yapmışım:

override const hash_t toHash()
{
return typeid(noktalar).getHash(&noktalar);
}

Ama şimdi bir şüphem var! Çünkü derleyicinin değer türleri için kullandığı getHash, nesnelerin bütün bitlerini göze alır. Oysa ben renkleri göz ardı etmek istemiştim. Sanırım benim yazdığım doğru olmaz.

Alıntı:
> opCmp işleç yüklemesini tanımlarken opEquals işleç yüklemesinide tanımlamak gerekiyor diyor derste. Ama ben tanımlamadan derleyebiliyorum.

O konu, programın doğruluğu ile ilgilidir. Tür için eşitlik, sıralama, veya hash hesabını bir kere kendimiz yazmaya başlamışsak; her üçünün birbirleriyle tutarlı olmalarını sağlamamız gerekir. Yoksa, o nesnelerin kullanıldığı algoritmalar yanlış çalışabilirler.

O yüzden, yukarıda benim yazdığım toHash'in doğru olup olmadığından şimdi emin değilim. opEquals ve opCmp renk'i gözardı ediyorlar ama derleyicinin yazdığı hash hesabı bunu bilmiyor.

Şimdi zamanım yok ama bunun doğru olup olmadığını öğrenip yazacağım. (Bana hatırlatın! :) )

Ali

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

Alıntı (canalpay):

>         this.atlama=atlama;
> //...
>     void popFront()
>     {
>         baş+=2;
>     }
> ```


Çok ufak bir hata: 2 yerine 'atlama' olacak tabii...

Alıntı:
> 2.soruda delegate anahtar sözcüğünü görünce daha dersi okumadan bıraktım.

Bence foreach'in delegate ile kullanımı, D'nin en zor konularından birisi. Programcının yazdığı foreach bloğu ile sınıf içinde yazılan opApply'ın paslaşmaları filan çok zorlayıcı konular. :)

Bence o problem aslında çok güzel, çünkü foreach'i nasıl farklı parametrelerle kullanabildiğimizi öğretiyor.

Örneğin, bir eşleme tablosunda tek parametre kullanırsak değer oluyor; iki parametre kullanırsak indeks (veya 'anahtar') ve değer oluyor:

foreach (değer; tablo) {
// ...
}

foreach (indeks, değer; tablo) {
// ...
}

Ali

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