Nesneler bir çok dilin önemli konularından biri. Ama nesne ile çok tanışmamış biri için nesne'nin nasıl kullanıldığını bir ders biçiminde anlatabilir misiniz ?
D'deki nesneler ayrıca Java programlama dilindekine(Doğal olarak php'yede) benziyor mu ?

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

Ben bu seferlik kısaca anlatacağım...

Sınıf: Bir kaç (aslında sıfır veya daha fazla) değişkenin bir araya getirilerek bir tür oluşturulmasına, ve o tür üzerindeki işlemlerin de aynı program yapısı içinde tanımlanmasına sınıf denir. Bundan bir adet tanımlanır. Örnek: Dikdörtgen...

Nesne: Nasıl int türünden oluşturulan hava_sıcaklığı gibi bir program yapısına değişken deniyorsa, bir sınıf türünden oluşturulan program yapısına da nesne denir.

Örneğin bir oyun kağıdı destesini 52 tane Dikdörtgen nesnesinden oluşturabiliriz. (Çok kötü bir örnek oldu... :D)

class Dikdörtgen
{
private:

   uint uzunluk_;
   uint genişlik_;

public:

   this(uint uzunluk, uint genişlik)
   {
       uzunluk_ = uzunluk;
       genişlik_ = genişlik;
   }

   uint alan() const
   {
       return uzunluk_ * genişlik_;
   }
}

import std.stdio;

void main()
{
   Dikdörtgen[52] deste = new Dikdörtgen(10, 7);

   writeln("Yirmincisinin alanı: ", deste[19].alan(), " santimetre kare");

   // Tabii tek başına da oluşturabiliriz:
   auto pencere = new Dikdörtgen(120, 80);
   writeln("Penceremin alanı: ", pencere.alan(), "cm\²");
}

Ali

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

Sınıf ve yapı örneklemeleri yapabilmek için bir kaç zamandır ağ üzerinde dolaşıyorum. Bir c# makalesinde sınıflar ve yapılar arasındaki önemli farklara değinilirken şunlar ifade edilmiş:
Alıntı:

Bu durum D içinde geçerli midir acaba ve eğer geçerliyse bizler kodlarımızı tasarlarken nelere dikkat etmeliyiz?

mert

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

Genel olarak doğru.

Ben sınıfları daha çok iş yapmak içim kullanıyorum. Yapıları ise tür olarak kullanıyorum. Yani benim için yapı daha karmaşık bir string gibi tür iken, sınıf ise daha karmaşık işlev topluluğu.

Alıntı:

Bu D içinde olduğu gibi doğru. Geri kalanıda ben bilmiyorum ancak doğrudur. Çoğu zaman ikiside ihtiyacı yeterince karşılıyor. Ancak ben kendime tür tasarlayacak isem struct(yapı), işlevler topluluğu tanımlayacak isem sınıf kullanırım.

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

Sınıf nesneleri Andrei'nin ifadesiyle kişiliği olan elemanlardır :)

Alıntı:

Sınıf nesneleri her zaman çöp toplama mekanizması tarafından yönetilen heap (yığın) üzerinde oluşur.

class A
{
   int x = 42;
}

unittest
{
   auto a1 = new A;
   assert(a1.x == 42);
   auto a2 = a1;       // yeni bir A nesnesi oluşturulmaz sadece A nesnesi
                       // a2 tarafından da gösterilmeye başlanır
   assert(a1 is a2);
   assert(a1 == a2);

   a2.x = 100;
   assert(a1.x == 100);
}

Ayrıca daha önce de konuştuğumuz gibi buradaki 'a1' ve 'a2' aslında birer referanstır. 'a2''yi 'a1''e eşitlediğimizde aslında yeni bir nesne oluşturulmaz sadece aynı nesne iki referans tarafından gösterilmeye başlanır. Çöp toplama mekanizması ancak bir nesneye bağlanmış referans kalmadığından emin olduğunda o nesne için ayrılan bellek alanını geri verir.

Herhangi bir nesneye bağlanmamış bir referans 'null''dur. Bu yüzden sınıfın varsayılan kurucusu çalıştığında sınıfa ait referanslar da 'null' değer alır.

unittest
{
   A a;

   assert(a is null);
   a = new A;
   assert(a !is null);
   a = null;
   assert(a is null);
   a = A.init;
   assert(a is null);
}

Bunu yukardaki birim testinde de görebiliriz.

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

Yeniden merhaba;
Alıntı:

Demişsiniz. Ancak Erdem; http://ddili.org/makale/bellek.html adresindeki makalede ise şöyle bir başlık var "Sınıf Nesnelerini Yığıtta Oluşturmak" Oradan alıntılıyorum;
Alıntı:

* fonksiyonlarda yerel tanımlandıklarında
* new ile oluşturulduklarında
* new argümansız kullanıldığında (yine de kurucu için argüman kullanılabilir)
* scope depolama türü ile tanımlandıklarında

Anladığım kadarıyla sınıflar her zaman yığın içerisinde oluşmuyorlar. Genellikle daha doğru bir terim galiba ne dersiniz? Benim yakınlaşmaya çalıştığım asıl mesele şu aslında; çözümlemelerimde sınıfı ve yapıları en hızlı ve en az maliyetle nasıl tasarlar ve kullanabilirim. Yani İlk alıntıladığım "Bellekte nerede tutulurlar" bölümündeki şu tür ifadeler;
Alıntı:

Bizim için ne kadar doğrudur? Diyelim ki benim bir .txt dosyam var. O dosyamın içinde ise 10 bin adet int tipinde değişkenim var. Bu dosyadan verilerimi çeken bir yapı tasarlasam bu yapının bana sağladığı dizilerle işlem yapmamın hızı ve bellek kullanımı hakkında neleri öngörebilmem gerekir?

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

Alıntı (mert):

Emin değilim ama o makale D1 zamanından kalmış olmalı.

Alıntı:

'scope' konusunu tam bilmiyorum ama new ile oluşturulduklarında yığın(heap) üzerinde bellek ayrılır. Üstteki birim testinde görüldüğü gibi A a şeklinde kullanırsanız sadece 'null' bir referans oluşturulur.

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

Alıntı (erdem):

Aslında kalmamış :)

Alıntı:

Bu ifade doğru.

Alıntı:

Burada yanlız bir yazım yanlışı olmuş sanırım. Sanırım doğrusu new ile bellekten yer ayrıldığında olacak. Yani şunun gibi bir şey:

import std.c.stdlib;
import std.outofmemory;
import std.gc;

class Foo
{
   new(size_t sz)
   {
	void* p;

	p = std.c.stdlib.malloc(sz);
	if (!p)
	    throw new OutOfMemoryException();
	std.gc.addRange(p, p + sz);
	return p;
   }

   delete(void* p)
   {
	if (p)
	{   std.gc.removeRange(p);
	    std.c.stdlib.free(p);
	}
   }
}

Alıntı:

TDPL'de aynen böyle bir ifade var:

All class-based objects are dynamically allocated-unlike in C++, there is no way to allocate a class object on the stack.

Sanırım bu ifadenin doğrusu.

There is no built-in way to allocate a class object on the stack

D'nin kendi sunduğu olanaklarla bir sınıf nesnesi için yığıt (stack) üzerinde bellek alanı ayırmanın bir yolu yok olacak.

Gene de ben de tam emin olamadım en iyisi Ali beye soralım :)

Bir de bir ek daha. Makalenin orijinalinde:

http://www.digitalmars.com/d/2.0/memory.html#stackclass

Allocating Class Instances On The Stack

Yani sınıfa ait örnekler için yığıt üzerinde bellek ayırmak diyor.

Allocating Class Objects On The Stack

Yani sınıf nesneleri için yığıt üzerinde bellek ayırmak demiyor. Ya da ben yanlış anlıyorum :)

Örneğin bir sınıfa ait örnek bir tanedir. Ama sınıf nesnelerini istediğimiz kadar oluşturabiliriz.

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

Can ve Erdem zaten güzelce yanıtlamışlar. Ben tekrarlıyorum.

Öncelikle, dil kavramları ile gerçekleştirme kavramlarının birbirlerinden ayrı tutulmaları gerektiğini söylemek istiyorum. Bartosz Milewski gibi bir ustanın benimle aynı fikirde olduğunu biliyorum. Walter ve Andrei'nin bile dil olanaklarını tanımlarken 'stack'ten bahsetmelerinin yanlış olduğunu düşünüyorum.

İlgili olarak, bazen de forumlara katılan D'ciler yeni başlayanlara D'nin dilimlerini anlatırken "nasıl tanımlandığını bir görsen hemen anlarsın" diye açıklıyorlar. "Bak şu adreste bir resim var, içindeki gösterge elemanları nasıl da gösteriyor" diyorlar. O da yanlış. Dil, bu gibi alt düzey kavramlardan soyutlanmıştır. Hiçbir yeni başlayan, dilimleri anlamak için derleyicinin perde arkasında ne işlerle uğraştığını bilmek zorunda değildir ve olmamalıdır. (Ayrıca, eğer dilim kavramını gerçekleştirmesine bakmadan anlayamıyorsak o dilde bir hata var demektir. D'nin dilimleri bir noktada öyleydi.)

Dilim bir kavramdır. Dilim işlemlerinin sonuçlarında ne olacağı bellidir. Örneğin 'dilim[j]' işlemi anlatılırken hiç kimse "derleyici perde arkasındaki eleman göstergesine j'yi ekler ve sonuçta elde ettiği adresteki nesneye * işleci ile eriştirir" demez. Doğrusu, "j'inci elemana erişim sağlar"dır. Bunun nasıl gerçekleştirildiği dilden bağımsız bir olaydır.

Program yığıtı (program stack) konusu da böyledir.

C++ standardı bu konuda çok başarılıdır: yerel değişkenlerin yığıtta bulunmaları gerektiğinden filan bahsetmez. C++ standardının gözünde örneğin "yaşamı otomatik olarak idare edilen" değişkenler vardır. O çeşit değişkenlerin yerlerinin mikro işlemcinin 'stack pointer' düzeneği ile yıldırım hızında ayrılıyor olmaları ve yine aynı hızda geri veriliyor olmaları dili ilgilendirmez. Evet, o nesneler orada yaşarlar ama C++ tanımı açısından bunun sözü edilmez. (Walter ve Andrei'nin de C++ standardı kadar özenli olmalarını umardım.)

Karşıt örnekler: ben iki adet 'stack pointer'ı olan bir mikro işlemci tasarlasam Walter'a gidip otomatik nesneler için hangisini kullanacağımı mı sormalıyım? Tabii ki olamaz. Veya 'stack pointer'ı olmayan mikro işlemci tasarlasam onun için bir D derleyicisi yazamayacak mıyım? Tabii ki olmaz.

Tabii gerçekte bütün (modern?) mikro işlemcilerde 'stack pointer' diye bir yazmaç (register) vardır ve bütün otomatik değişkenler onun gösterdiği yerde yaşarlar. İşte bu gerçek yüzünden "bu nesnenin yaşamı otomatik olarak sonlandırılır" yerine "bu nesne stack'te yaşar" deniyor. Ama denmemeli. Çünkü yeni başlayan birisine dilin gözünde nesne yaşamlarını anlatmak kolaydır ve bunları bilmek doğru programlar üretmek için şarttır; ama 'stack'ten bahsetmeye başlayınca ya yeni başlayanların mikro işlemci ve derleyici teknolojilerini de bilmelerini beklemiş oluyoruz, ya da kafalarına yarım doğrular sokuyoruz.

Alıntı:

Aynen D'de de öyle.

Alıntı:

O kadarı da doğru çünkü sınıflarda değişken ile nesne diye iki kavram var. Nesne her zaman için isimsizdir; programda isimli olarak gördüğümüz, değişkendir.

Alıntı:

C# bilmiyorum ama o söylenenler D için ancak bazı durumlarda geçerlidir. Çürütelim... Şu örnekteki üye nerededir?

struct Yapı
{}

class Sınıf
{
   Yapı üye;           // <-- nerede?
   BaşkaSınıf üye2;
}

Yapı olduğu için 'stack'te midir? Yoksa bir sınıfın üyesi olduğu için öbekte midir? Peki şuradaki int ve hatta onu sarmalayan yapı nerededir?

struct Yapı
{
   int i;
}

İstersek 'stack'tedir, istersek öbektedir:

import std.stdio;

struct Yapı
{
   int i;
}

void main()
{
   auto nesne0 = Yapı();           // 'stack'te
   auto nesne1 = new Yapı();       // öbekte

   writeln(&nesne0.i);
   writeln(&nesne1.i);
}

Çıktısından anlaşıldığı gibi benim ortamımda iki nesne bambaşka bölgelerde yaşıyorlar:

'FF88C8E8
F7428E20
'

(FF ve F7 ile başlayan bölgeler birbilerinden çok uzaktalar.)

Alıntı:

C# için ne yanıt verileceğini bilemem.

D'de en genel olarak, tür bir değer ifade ediyorsa yapı kullanılır. Örneğin nesnelerin kimlikleri önemli değilse... Bir Piyon nesnesi diğerinden farklı mıdır? Programına göre değişir. Eğer Piyon programda değer olarak kullanılıyorsa struct olmalıdır.

Daha özel durumlarda çok şekilliği düşünmek gerekir. SatrançTaşı diye bir arayüz varsa ve her taş kendi bildiği davranışlara sahipse o zaman Piyon bir sınıf olmalıdır. Örneğin bir satranç taşına aslında ne olduğunu bilmeden "şu kareye gitmen yasal mıdır" diyebiliyorsak o zaman bütün satranç taşları sınıf türleridir.

Öncelikle böyle anlamsal açılardan yaklaşmak gerekir. Nesnelerin nerede durdukları ve aşağıdaki gibi performans sorunları ikincil önemdedir.

Alıntı:

D dilinde: "işlevlere sınıf değişkenlerinin kopyaları aktarılır; isimsiz sınıf nesnesi o iki kopya tarafından eriştirilmeye devam eder." Gösterelim:

import std.stdio;

class Sınıf
{
   int i;
}

void foo(Sınıf değişken)
{
   writeln("foo içinde değişken   : ", &değişken);
   writeln("foo içinde değişken.i : ", &(değişken.i));
}

void main()
{
   auto değişken = new Sınıf;

   writeln("main içinde değişken  : ", &değişken);
   writeln("main içinde değişken.i: ", &(değişken.i));

   foo(değişken);
}

Çıktısından görüldüğü gibi iki farklı değişkenden söz ediyoruz ama tek bir nesne var. i üyesinin adresi aynı:

'main içinde değişken : FFC55B4C
main içinde değişken.i: F736BE28
foo içinde değişken : FFC55B38
foo içinde değişken.i : F736BE28
'

Alıntı:

Bellek harcanmamasını anlarım ama onun referans türlerinin nedeni olarak gösterilmesi yanlış. Sınıf nesnelerinin kopyalanmamalarının nedeni, kimlikleri olan nesneler olmalarıdır. Sınıf nesneleri yeni kimliğe sahip olmasınlar diye kopyalanmazlar.

Tekrar altını çiziyorum: İşleve sınıf türü gönderilirken

• değişken kopyalanır

• nesne kopyalanmaz

Kaldı ki, D'de gösterge diye bir kavram var. Eğer istersek korkunç derecede büyük yapıları bile gösterge ile geçirebiliriz:

struct Yapı
{
   // ... korkunç büyük olsun ...
}

void foo(Yapı * nesne)
{
   // ...
}

void main()
{
   auto nesne = Yapı();
   foo(&nesne);        // <-- değer türü olduğu halde kopyalamadık
}

Gördüğünüz gibi, değer ve referans türü seçiminde veri büyüklüğünün hiçbir önemi yoktur.

Alıntı:

Tekrar söylüyorum; C# bilmiyorum ama eğer aynı şeyi C, C++, veya D için de söyleyeceklerse o uzmanlarla tanışmak isterdim. :) Eğer programlarınızı bu tür kaygılara göre yazacağımızı düşünmeye başladıysanız hemen durun! Türlerin yapı veya sınıf olacaklarına büyüklüklerine bakarak karar vermek programcılık cinayetidir.

Ayrıca mantık dışı ve yarım yamalak bir öğüttür. Düşünelim: kütüphanemizdeki 16 baytlık bir türü bugün yapı olarak tasarlamışken iki ay sonra 20 bayta çıktı diye sınıf mı yapacağız? Kullanıcı kodları ne olacak?

Ayrıca bunun tarih öncesinden beri geçerli olan bir adı bile var: "premature optimization is the root of all evil" ("Gereğinden önce yapılan eniyileştirme her kötülüğün anasıdır").

Alıntı:

D için geçerli değildir ve eğer C#'ta gösterge kavramı varsa orada da geçerli olduğunu sanmıyorum.

Ali

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

Alıntı:

Ben bu ifade ile ne anlatılmak istendiğini anlamadım :huh:

Alıntı:

Bununla ters düşmüyor mu :)

Alıntı:

Doğru mu anlamışım acaba. Yani:

Alıntı:

Burada sınıf nesnelerini kasdetmiyor sınıfa ait örnekleri kasdediyor değil mi. Ayrıca 'new' kullanarak yer ayırmak derken sınıfın kurucu ve bozucusundaki 'new 've 'delete' anahtar kelimelerini kullanarak elle bellek yönetimini yapmayı kasdediyor değil mi.

Alıntı (erdem):

> class A
> {
>     int x = 42;
> }
>
> unittest
> {
>     auto a1 = new A;
>     assert(a1.x == 42);
>     auto a2 = a1;       // yeni bir A nesnesi oluşturulmaz sadece A nesnesi
>                         // a2 tarafından da gösterilmeye başlanır
> // ...
> }
> ```

>

Benim değiştirdiğim kısım şu şekildeydi:

'Sınıflar kişiliği olan elemanlar oldukları için kopyalanmamaları gerekir. Yukarıdaki örnekte olduğu gibi. Kopyalanmamaları gerekiyor derken aynı nesneyi gösteren birden fazla referans olmasına izin vermemeliyiz. Çünkü beklenmeyen  bir şekilde referans değiştiği zaman uygulamanın bir yerinde olan sürpriz değişiklikler diğer tarafına da yansıyabilir.'

demiştim. Ama siz aynı nesneyi gösteren birden fazla referans olması konusunda *- duruma göre değişebilir -* demiştiniz. O yüzden ben de bunu hatırlayarak mesajı değiştirdim :)

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