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

Ali

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

Alıntı:

Belkide dersi takip edenler pek yaşam sürelerini takmıyordur :-) Her değişkenin sonu aynı ne de olsa. :-D (Benim ana düşüncem. İşi biten değişkenle alakam olmaz. İsterse yaşamı bitsin yada bitmesin. Ne de olsa hiç çok büyük bir program yazmadım. Php ile yaptığım şeylerde yüksek seviyenin faydalarını görüyordum. O yüzden yaşam süresine pek bakmam.)

Yada belki Sınıf yapısından bir kaç şey biliyordur dersleri izleyenler. :-)

import std.stdio;
void main()
{
class yaşa{
char[] yaşasınDünya;
void evet(char[] yaşasınDünya) {
writeln(yaşasınDünya);
}

}

auto yaş=new yaşa;
yaş.evet("Merhaba evren".dup);
yaş.evet("Merhaba Uzay GEmisi".dup);
}

Bu arada öylesine bir baktım da sanki struct(yapı) öğrenmeye çalışacağımıza direk class öğrenmeye çalışsak daha iyi gibi. Sizce ?
Bana şuan nedense struct öğrenmek zor ve gereksiz geliyor. Açayım digitalmars.comun class belgesini, öğreneyim sınıfları, yazayım bir projeyi nesne yönemli, olsun bitsin. Bunlar da sırf bir şey daha öğrenmem için yeni şeyler bulmuşlar.

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

Yeni başlayanların kafalarını karıştırabilecek bir şey farkettim.

Başka yerlerde

int saat;

dendiği zaman bir değişken yaşamaya başlıyordu. Yapılarda öyle olmuyor:

struct GününSaati
{
   int saat;
   int dakika;
}

O satırlarda iki değişken yaşamaya başlamıyor. Yapı nesnesi oluşturulunca ne tür değişkenlerin yaşamaya başlayacağı bildiriliyor.

Bu dersi bu noktayı belirtecek şekilde değiştireceğim.

Şu sırada dersleri çok az kişinin izlediğini biliyorum. Belki ileride okuyanlar artınca eksiklerimi gösterenler de artar. ;)

Ali

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

Alıntı (canalpay):

Orası kesinlikle doğru.

Ben aslında yaşam sürecinin öteki ucunu düşünmüştüm: yapı tanımlanınca üyeler hemen yaşamaya başlıyor sanılmasınlar. :) Sanki daha önce bu konuda kafası karışan C'ciler duymuştum.

Alıntı:

Çöp toplayıcılı dillerde öyle düşünülüyor. Ama bazen nesnelerin belirli bir anda sonlandırılmalarını isteriz. Örneğin değerli bir sistem kaynağını ellerinde tutuyorlardır ve hemen bırakmaları gerekebilir.

C++'da "C++'ca düşünmenin" önemli bir parçası, nesne yaşam süreçleridir. Henüz D'de o kadar deneyimim olmadığı için bu konunun ne kadar önemli olacağını bilmiyorum.

Bazen sonlandırıcı işlevlerde [destructor] önemli işler yapılır. Örneğin basit yapıda bir XML dosyası oluşturmada kullanılan bir yapı tasarlayalım. Bu yapının sonlandırıcısının görevi, '' diye açılmış olan XML elemanın '' diye kapatılması olsun:

import std.cstream;
import std.stream;

class XmlElemanı
{
   string isim;
   int girinti;
   Stream akım;

   this(string isim_, int girinti_, Stream akım_)
   {
       isim = isim_;
       girinti = girinti_;
       akım = akım_;

       foreach (i; 0 .. girinti) {
           akım.writef(' ');
       }
       akım.writefln('<', isim, '>');
   }

   ~this()
   {
       foreach (i; 0 .. girinti) {
           akım.writef(' ');
       }
       akım.writefln("</", isim, '>');
   }
}

void main()
{
   auto dış = new XmlElemanı("dış-eleman", 0, dout);

   foreach (i; 0 .. 2) {
       auto orta = new XmlElemanı("orta-eleman", 2, dout);

       foreach (j; 0 .. 2) {
           auto iç = new XmlElemanı("iç-eleman", 4, dout);
           dout.writefln("      değer-", i, '-', j);
       }
   }
}

O programı kullanarak şu çıktıyı üretmek istiyor olalım:

<dış-eleman>
 <orta-eleman>
   <iç-eleman>
     değer-0-0
   </iç-eleman>
   <iç-eleman>
     değer-0-1
   </iç-eleman>
 </orta-eleman>
 <orta-eleman>
   <iç-eleman>
     değer-1-0
   </iç-eleman>
   <iç-eleman>
     değer-1-1
   </iç-eleman>
 </orta-eleman>
</dış-eleman>

Gördüğün gibi bütün elemanlar düzgün, ve her açılan eleman doğru zamanda kapatılmış.

Oysa, nesnelerin yaşam süreçleri çöp toplayıcıya bırakılınca yukarıdaki programın çıktısı şöyle oluyor:

<dış-eleman>
 <orta-eleman>
   <iç-eleman>
     değer-0-0
   <iç-eleman>
     değer-0-1
 <orta-eleman>
   <iç-eleman>
     değer-1-0
   <iç-eleman>
     değer-1-1
   </iç-eleman>
   </iç-eleman>
 </orta-eleman>
   </iç-eleman>
   </iç-eleman>
 </orta-eleman>
</dış-eleman>

Yani elimizde bozuk bir XML dosyası var! :) (Çöp toplayıcının durumuna ve kafasına göre başka bir çıktı da olabilirdi.)

İşin güzeli, bu tür programlama yöntemlerini desteklemek için D'de 'scope' anahtar sözcüğü var. Programa dört tane 'scope' eklemek, o nesnelerin C++'da olduğu gibi, bulundukları kapsamdan çıkılırken sonlandırılmalarını sağlıyor ve çıktı istediğimiz gibi düzgün oluyor:

scope class XmlElemanı
// ...
   scope auto dış = new XmlElemanı("dış-eleman", 0, dout);
// ...
       scope auto orta = new XmlElemanı("orta-eleman", 2, dout);
// ...
           scope auto iç = new XmlElemanı("iç-eleman", 4, dout);

Alıntı:

Yapıları öğrenirken de sınıfları öğreniyoruz aslında. ;) Sınıfların daha becerikli yapılar olduklarını söyleyebiliriz.

Alıntı:

C'nin kullanıcı türü olarak tek olanağı 'struct' idi. C++ yapılara ve sınıflara bütünüyle aynı hakları verdi. (Tek fark, varsayılan üye erişim haklarındadır.) D, yapıları basitleştirerek C ile C++ arasında bir yere koydu. Ama sitelerinde "kimlikleri olmayan değerler" olarak düşünülmeye uygun oldukları yazıyor.

Yapılar aslında sınıflardan daha alt düzey kabul edilmeliler.

Ali

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

Alıntı (acehreli):

İki başlık ekledim: "Yapı tanımı, tür tanımıdır; nesne tanımı değildir" ve "static üyeler".

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

Ali

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

Alıntı (canalpay:1261418566):

Ben de öyle düşünmeye başladım. :/

Belki de yapılara gereğinden fazla önem veriyorum. Daha basit oldukları için önce onlar üzerinde gösterip sonra sınıflara geçecektim ama daha nasıl kurulduklarından bile emin olmadığımı farkettim! :)

Tür nesne = { 1, 2 };

İyi değil, çünkü sağ tarafta üyelerden az sayıda ilk değer kullanılırsa nesne'nin son üyelerinin değerleri belirsiz kalıyor. İlk değerlerini bile almıyorlar.

Tür nesne;
nesne.x = 1;
nesne.y = 2;

İyi değil, çünkü hem ilk satırda zaten ilk değerlerini alıyorlar ve gereksizce bir daha değer veriyoruz; hem de yapının her kullanıldığı yerde elle yapmamalıyız. Bu işi kurucu halletmeli...

auto nesne = Tür(1, 2);

İyi değil, çünkü önce sağda bir hazır değer oluşturuluyor; ve o değer nesne'ye kopyalanıyor. Daha garibi, eğer yapıya bir de 'opCall' işleci eklersek, sağ taraf artık hazır değer kurma anlamından çıkıyor ve o 'opCall''u çağırmak anlamına geliyor! :) (Ben bu noktada koptum... :))

Şimdi İngilizce haber grubunda soracağım bakalım benimsenen yöntem nasılmış...

Belki de yapıları boşvermek gerek... :)

Ali

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

Alıntı (acehreli):

> Tür nesne = { 1, 2 };
> ```


O kullanım emekliye ayrılacakmış.

Alıntı:
>

Önerilen kullanım oymuş. (Derslerde onu seçmem iyi olmuş! :) )

Alıntı:

O davranış, yapıların kurucularının olmadığı zamandan kalmaymış. Şimdi kurucular olduğu için 'opCall''un böyle araya karışması da kalmayacak.

Alıntı:

Bunları oradan öğrendim zaten. Rahatladım... :)

Ali

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

Bu dersin çözümlerini tamamladım. Çözüm bağlantısın dersin sonunda:

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

Ali

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