Kendim şöyle bir yanıt buldum:

core.memory modülündeki GC.free'yi çağırıyoruz. Sanırım C'den araklama olduğu için gösterge biçiminde. Yani kod şu hale geliyor :

import std.stdio;
import core.memory;
void main()
{
   class deneme
   {
       this()
       {
           File dosya = File("ogrenci_bilgisi", "a");
           dosya.writeln("İsim  : ", "Zafer");
           dosya.writeln("Numara: ", 123);
           dosya.writeln("Sınıf : ", "1A");
       }
       ~this()
       {
           File dosya = File("ogrenci_bilgisi", "a");
           dosya.writeln("Bozucu :İsim  : ", "Zafer");
           dosya.writeln("Bozucu :Numara: ", 123);
           dosya.writeln("Bozucu :Sınıf : ", "1A");
       }
   }
   auto örnek = new deneme();
   GC.free(&örnek);

}

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

GC.free ne işe yarıyor ki o zaman ?

Sanırım C'nin çözümlerine başvurmak zorundayız ? Açıkça böyle bir şey olamaz. Ben D için C'nin şeylerine bulaşmayı istemiyorum. O zaman kısadan C yazsam daha iyi.

Bu listelerde uzunca tartışılmış : http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=113090

Tartışmanın devamı: http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=113246

Andrei şunu önermiş : (Denemedim ki zaten şuan çalışmaz.)

void[] AllocateStuff(size_t size);
void DeallocateStuff(void* p);

Then you'd write these two helper functions to create and dispose objects:

T * myMake(T)() if (is(T == struct))
{
auto buf = AllocateStuff(T.sizeof);
return emplace!T(buf);
}

T myMake(T)() if (is(T == class))
{
auto buf = AllocateStuff(__traits(classInstanceSize,T));
return emplace!T(buf);
}

void myDelete(T)(T p)
{
clear(p);
DeallocateStuff(p);
}

Aslında bu durum ptDDev dediği gibi bir durum. Gıcıkca buna zorlanmayacağız umarım. Eğer istenmiyorsa delete bu kadar bir kütüphane olanağı haline gelsin ? Bu kadar zorlamaya gerek var mı ?

Şuan anladığım kadarıyla delete giderse yerine onu tutacak hiç bir şey yok.

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

Andrei'nin D'yi C++'laştıran olanaklar önerdiğini söylüyorlar.

Birisi delete anahtar sözcüğünün çıkmasını eleştiriyor (ben ise Andrei'nin açıklamasını çok mantıklı bulmuştum; benim kafam da Andrei ve Walter tarafına kaymış demek ki :))

ptDDev denen kişi açıkça Andrei'ye gıcık oluyor ve bu yüzden söylediklerinin bir bölümü değersiz ;) ama D'nin eskiden daha basit bir dil olduğunu ve gittikçe C++'laştığını; hatta Java'laştığını söylüyor. Doğru...

ptDDev, delete'in geri gelmesini ve gelecekse de işlev yerine işleç olmasının daha iyi olduğunu şiddetle savunuyor. (Aynı şekilde çalıştıktan sonra o kadar önemi olmamalı tabii)

Bunlar dışında elle tutulur başka fikir göremiyorum. Megalomanyaktır veya gıcık birisidir denmiş olmasının tartışmaya hiçbir katkısı olamaz. Tam tersine, fikirlerin negatifliğinin biraz da o yüzden olduğunu açıklar. (asshole, motherfucking jerk, vs.'nin hiçbirisi tam Türkçe anlamlarını taşımaz; farklı şiddetlerde "gıcık" demektir (aslında "gıcık" da modern Türkçe'de kalmamış olabilir :)))

Ali

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

Alıntı (canalpay):

clear zaten var; object.di içinde dört yüklemeli olarak buldum:

void clear(T)(T obj) if (is(T == class))
{
   auto ci = obj.classinfo;
   auto defaultCtor =
       cast(void function(Object)) ci.defaultConstructor;
   version(none) // enforce isn't available in druntime
       _enforce(defaultCtor || (ci.flags & 8) == 0);
   immutable size = ci.init.length;

   auto ci2 = ci;
   do
   {
       auto dtor = cast(void function(Object))ci2.destructor;
       if (dtor)
           dtor(obj);
       ci2 = ci2.base;
   } while (ci2)

   auto buf = (cast(void*) obj)[0 .. size];
   buf[] = ci.init;
   if (defaultCtor)
       defaultCtor(obj);
}

void clear(T)(ref T obj) if (is(T == struct))
{
   static if (is(typeof(obj.__dtor())))
   {
       obj.__dtor();
   }
   auto buf = (cast(void*) &obj)[0 .. T.sizeof];
   auto init = (cast(void*) &T.init)[0 .. T.sizeof];
   buf[] = init[];
}

void clear(T : U[n], U, size_t n)(ref T obj)
{
   obj = T.init;
}

void clear(T)(ref T obj)
   if (!is(T == struct) && !is(T == class) && !_isStaticArray!T)
{
   obj = T.init;
}

D çöp toplayıcılı bir dil mi değil mi; buna karar vermek gerek. Eğer çöp toplayıcıdan yararlanıyorsak, bırakırız işini yapar. Eğer gerçekten gerekiyorsa, kendi türlerimiz için new ve delete işlevlerini yazar ve bellek yönetimini kendimiz de halledebiliriz.

Daha da gerekiyorsa çöp toplayıcıya "bellek temizliğini şimdi yap" da diyebiliyoruz.

Ali

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

Belgelerle ve süreyle ilgili bütün eleştirilere katılıyorum. D2 belki biraz fazlaca organik gelişiyor. :/

Can'ın gösterdiği bağlantıdan da görüldüğü gibi, delete'in kalkması Andrei'nin kafasına göre bir işi değil. Konunun ilk yazısında da görüldüğü gibi Walter Bright ve Sean Kelly gibi en baş diğer iki kişinin de düşündükleri bir olanakmış.

Konuya katılan kişilerden hiçbirisi de bunun yanlış olduğunu söylemiyor ve güzel çözümler arıyorlar. Yani delete'in Adrei'nin egosu yüzünden kalktığı doğru değilmiş... :)

#d kanalındaki ptDDev gibi "bilgi sahibi olmadan fikir sahibi olanlar" böylece daha da "gıcık" duruma düşüyorlar. ;)

Ali

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

clear, sonlandırıcıyı işlettikten sonra nesneyi varsayılan kurucusuyla kurulmuş duruma getiriyor. clear'in kodunda görüyoruz:

   if (defaultCtor)
       defaultCtor(obj);

O yüzden nesne ikinci bir kere daha kurulup sonlandırılıyor.

Bu da, clear'in çağrılmasının gerçekten gerektiği durumlarda kurucu ve sonlandırıcı işlevlerin fazla becerikli olmamaları gerektiği sonucunu gösteriyor.

Ali

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

Ne yazık ki olmaz; çünkü daha nesne sonlandırılmadan belleğinin geri verilmesini istiyorsun. Sonlandırıcı işlev geçersiz bellek üzerinde tesadüfen çalışıyor.

Bir kaç writeln ile:

import std.stdio;
import core.memory;
void main()
{
   class deneme
   {
       this()
       {
           writeln("this()");
           File dosya = File("ogrenci_bilgisi", "a");
           dosya.writeln("İsim  : ", "Zafer");
           dosya.writeln("Numara: ", 123);
           dosya.writeln("Sınıf : ", "1A");
       }
       ~this()
       {
           writeln("~this()");
           File dosya = File("ogrenci_bilgisi", "a");
           dosya.writeln("Bozucu :İsim  : ", "Zafer");
           dosya.writeln("Bozucu :Numara: ", 123);
           dosya.writeln("Bozucu :Sınıf : ", "1A");
       }
   }
   auto örnek = new deneme();
   writeln("GC.free öncesi");
   GC.free(&örnek);
   writeln("GC.free sonrası");

}

Çıktısı:

this()
GC.free öncesi
GC.free sonrası
~this()

Görüldüğü gibi, çöp toplayıcı sonlandırıcıyı yine de kendisi çağırıyor ama bellek geri verildikten sonra...

Ali

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

Ben de çöp toplayıcılı dillerde deneyimli değilim ama bu kadar insan bu kadar dili kullandığına göre demek ki çalışıyor... :)

Hatırlayalım: Öncelikle, hiçbir şey yapmamıza gerek yok. Eğer hemen işletilmesi gereken bir işlem varsa, onu sonlandırıcı işleve yazmak zorunda değiliz. Hatta sınıf yapmak zorunda da değiliz. Yapı nesneleri hemen sonlandırılıyorlar. Sınıf nesneleri de scope ile işaretlenince hemen sonlandırılıyorlar.

clear'i çağırmanın gerekmesi nadir bir durum. Öyle nadir durumlarda da, sonlandırıcı işlevin önemli bir işlem yapmasını önleyebiliriz.

Ali

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

Bana göre clearı çağırdığımızda bir daha sonlandırıcı ile çağrılmaması için not bırakılmalı. Ve bence druntimeın şuan ki geliştiricileri(özellkle sean kelly) çöp toplayıcıya hakim değil diye düşünüyorum :-) Bu yüzden kendilerine gereksiz yük yüklemek istemiyorlar diye düşünüyordum. Ancak bu karışıklık belki programı yavaşlatacak bazı hatalara sebep olacaktır. Ama hala çöp toplama ile ilgili bir hata vardı ve yeniden yazılacaktı. Ne oldu merak ettim.

Bende bazı şeyler denerken Ali Bey ile c++ de sınıflar ile ilgili konuştuğumuz bir olayı(not bırakma olayını) cleara eklemek istedim ve basit bir örnek yazdım:

import std.stdio;

void main()
{
   class selam
   {
       static bool değişti_mi=!bool.init;
       char[] sa="selamun aleyküm".dup;
       char[] as="aleyküm selam".dup;

       this()
       {
           if(değişti_mi){

           writeln(sa);
           writeln(değişti_mi);
           }
       }
       ~this()
       {
           if(değişti_mi){
           writeln(as);
           değişti_mi=bool.init;
           writeln(değişti_mi);
           }
       }
   }

   auto sel = new selam;

   clear(sel);

}

Bu notu bir biçimde clear kendi yapamaz sanırım?

Eğer clear hepsine gereksiz anlamında özel bir değer verebilirse if ile direk onu kontrol eden basit bir işlevde yazılırsa bu yukarıdakinden daha iyi bir çözüm olabilir?

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

Alıntı:

Tamamen doğru buluyorum. Artı bence sadece bir kere sonlandırıcı çağrılmalı.

Alıntı:

Evet static olmamalı. Ancak o zaman her nesneye erişim sağlandığında eğer static ile erişilmez ise tekrar değişken kuruluyor. Uzatmayayım. static'i kaldırdığınızda anlayacaksınız : http://ideone.com/Spkm3

Alıntı:

Bende çöp toplayıcıyı çok beğeniyorum. Sadece dmd'ninki daha iyi yazılabilir miydi diye merak ediyorum.

Bence bu konular eğlenceli konular. Biraz daha düşünmeliyiz. Güzel şeyler bulabiliriz.

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